यह चुनौती मई के 2018 लैंग्वेज ऑफ द मंथ इवेंट के हिस्से के रूप में MATL भाषा की कुछ विशेषताओं से संबंधित है ।

परिचय

MATL में, कई दो-इनपुट फ़ंक्शन प्रसारण के साथ तत्व-वार काम करते हैं । इसका मतलब निम्न है:

तत्व-वार (या वेक्टरकृत ): फ़ंक्शन मिलान आकारों के साथ इनपुट को दो सरणियों के रूप में लेता है। फ़ंक्शन द्वारा परिभाषित ऑपरेशन संबंधित प्रविष्टियों के प्रत्येक जोड़े पर लागू होता है। उदाहरण के लिए, पोस्ट-फिक्स नोटेशन का उपयोग करना:
```
[2 4 6] [10 20 30] +
```
ouput देता है
```
[12 24 36]
```
यह बहुआयामी सरणियों के साथ भी काम करता है। संकेतन × सरणी (मैट्रिक्स) का [1 2 3; 4 5 6]प्रतिनिधित्व करता है23
```
1 2 3
4 5 6
```
जिसका आकार 2पहले आयाम (ऊर्ध्वाधर) के 3साथ और दूसरा (क्षैतिज) है। इसलिए उदाहरण के लिए
```
[2 4 6; 3 5 7] [10 20 30; 40 60 80] *
```
देता है
```
[20 80 180; 120 300 560]
```
प्रसारण या ( सिंगलटन विस्तार ): दो इनपुट सरणियों के मिलान आकार नहीं होते हैं, लेकिन प्रत्येक गैर-मिलान आयाम में किसी एक सरणियों का आकार होता है 1। इस सरणी को स्पष्ट रूप से आकार मिलान करने के लिए अन्य आयामों के साथ दोहराया गया है; और फिर ऑपरेशन को ऊपर के रूप में तत्व-वार लागू किया जाता है। उदाहरण के लिए, आकार 1× 2और 3× के साथ दो इनपुट सरणियों पर विचार करें 1:
```
[10 20] [1; 2; 5] /
```
प्रसारण के लिए धन्यवाद, यह इसके बराबर है
```
[10 20; 10 20; 10 20] [1 1; 2 2; 5 5] /
```
और इसलिए यह देता है
```
[10 20; 5 10; 2 4]
```
इसी प्रकार, आकार 3× 2और 3× 1(अब प्रसारण केवल दूसरे आयाम के साथ काम करता है),
```
[9 8; 7 6; 5 4] [10; 20; 30] +
```
देता है
```
[19 18; 27 26; 35 34]
```
आयामों की संख्या भिन्न भी हो सकती है। उदाहरण के लिए, 3 × 2 और 3 × 1 × 5 आकार वाले इनपुट संगत हैं, और 3 × 2 × 5 परिणाम देते हैं। वास्तव में, आकार 3 × 2 3 × 2 × 1 के समान है (मनमाने ढंग से कई निहित अनुगामी सिंगलटन आयाम हैं)।

दूसरी ओर, 2× 2और 3× 1सरणियों की एक जोड़ी एक त्रुटि देगी, क्योंकि पहले आयाम के साथ आकार हैं : 2और 3वे समान नहीं हैं और उनमें से कोई भी नहीं है 1।

मॉड्यूलर प्रसारण की परिभाषा

मॉड्यूलर प्रसारण प्रसारण का एक सामान्यीकरण है जो काम करता है भले ही गैर-मिलान आकार में से कोई भी हो 1। फ़ंक्शन के इनपुट के रूप में निम्नलिखित 2× 2और 3× 1सरणियों के उदाहरण पर विचार करें +:

[2 4; 6 8] [10; 20; 30] +

नियम इस प्रकार है: प्रत्येक आयाम के लिए, वह सरणी जो उस आयाम के साथ छोटी होती है, को दूसरे सरणी के आकार से मेल खाने के लिए मॉड्यूलर (साइक्लिकली) दोहराया जाता है । यह उपरोक्त के बराबर होगा

[2 4; 6 8; 2 4] [10 10; 20 20; 30 30] +

नतीजे के साथ

[12 14; 26 28; 32 34]

दूसरे उदाहरण के रूप में,

[5 10; 15 20] [0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0] +

उत्पादन होगा

[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

सामान्य तौर पर, आकारों के साथ आदानों a× bऔर c× dदे आकार का एक परिणाम max(a,b)× max(c,d)।

चुनौती

ऊपर वर्णित के रूप में मॉड्यूलर प्रसारण के साथ दो आयामी सरणियों के लिए इसके अलावा को लागू करें ।

सरणियां आयताकार होंगी (रैग्ड नहीं), इसमें केवल गैर-नकारात्मक पूर्णांक होंगे , और प्रत्येक आयाम में कम से कम आकार1 होगा ।

सशर्त नियम:

इनपुट और आउटपुट किसी भी उचित माध्यम से लिया जा सकता है । उनका प्रारूप हमेशा की तरह लचीला है।
प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है ।
बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

निम्नलिखित ;पंक्ति विभाजक के रूप में उपयोग किया जाता है (ऊपर दिए गए उदाहरणों में)। प्रत्येक परीक्षण का मामला दो इनपुट और फिर आउटपुट दिखाता है।

[2 4; 6 8]
[10; 20; 30]
[12 14; 26 28; 32 34]

[5 10; 15 20]
[0 0 0 0; 1 2 3 4; 0 0 0 0; 5 6 7 8; 0 0 0 0]
[5 10 5 10; 16 22 18 24; 5 10 5 10; 20 26 22 28; 5 10 5 10]

[1]
[2]
[3]

[1; 2]
[10]
[11; 12]

[1 2 3 4 5]
[10 20 30]
[11 22 33 14 25]

[9 12 5; 5 4 2]
[4 2; 7 3; 15 6; 4 0; 3 3]
[13 14 9;12 7 9;24 18 20;9 4 6;12 15 8]

[9 12 5; 5 4 2]
[4 2 6 7; 7 3 7 3; 15 6 0 1; 4 0 1 16; 3 3 3 8]
[13 14 11 16; 12 7 9 8; 24 18 5 10; 9 4 3 21; 12 15 8 17]

[6 7 9]
[4 2 5]
[10 9 14]

— लुइस मेंडो
स्रोत

"द्वि-आयामी सरणियों के लिए कार्यान्वयन" - एक आयामी परीक्षण मामले हैं।

— जोनाथन एलन

क्या हम मान सकते हैं कि हमें कोई रैग्ड एरेस इनपुट नहीं मिला है? (ऐसा दिखता है)

— जोनाथन एलन

1

@JonathanAllan स्पष्ट नहीं होने के लिए क्षमा करें। हां, आप मान सकते हैं कि कोई रैग्ड एरे नहीं है। वे आयताकार सरणियाँ होंगी। "एक आयामी" वाले को दो-आयामी माना जाना चाहिए आकार 1× n(जैसे [1 2 3]) या n× 1(जैसे [1; 2; 3])

— लुइस मेंडो

आपके द्वारा वर्णित प्रसारण MATLAB या NumPy प्रसारण की तुलना में अधिक सीमित लगता है; आपके विवरण में, इनपुट में समान आयाम हैं, MATLAB या NumPy में मौजूद प्रतिबंध नहीं है। क्या यह MATL प्रतिबंध है, या चुनौती के प्रयोजनों के लिए सरलीकरण है (चूंकि चुनौती 2D इनपुट तक सीमित है)?

— user2357112

@ user2357112 हां, यह विवरण में एक सरलीकरण था। MATL का प्रसारण MATLAB की तरह ही है: आपके पास 3 × 2 और 3 × 1 × 5 इनपुट हो सकते हैं और 3 × 2 × 5 परिणाम प्राप्त कर सकते हैं। दरअसल, 3 × 2 3 × 2 × 1 (अंतर्निहित अनुगामी आयाम) के बराबर है। मुझे लगता है कि यह Numpy (लेकिन प्रमुख आयामों के साथ) में समान है। मैंने स्पष्ट किया है कि परिचय में

— लुइस मेंडो

4

जेली , 10 बाइट्स

ṁ€ZL$Z€Ɗ⁺S

एक मैट्रिक्स जोड़ी (पंक्तियों के दो सरणियों) को इनपुट के रूप में लेता है और एक मैट्रिक्स लौटाता है।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ṁ€ZL$Z€Ɗ⁺S  Main link. Argument: [M, N] (matrix pair)

  Z $       Zip M with N (i.e., transpose the matrix of arrays [M, N], ...
   L            then take the length (number of rows) of the result.
ṁ€          Mold M and N like the indices, cyclically repeating their rows as many
            times as needed to reach the length to the right.
     Z€     Zip each; transpose both M and N.
       Ɗ⁺   Combine the three links to the left into a chain and duplicate it.
            The first run enlarges the columns, the second run the rows.
         S  Take the sum of the modified matrices.

— डेनिस
स्रोत

1

बेशक ... मैं इन सभी गोल्फिंग भाषाओं को एक चुनौती के लिए आवश्यक बाइट्स के संदर्भ में कुछ हद तक संगत के रूप में देखता हूं (जेली, 05AB1E, पायथ, एपीएल, आदि) वर्तमान जवाबों में से अधिकांश लगभग 20 बाइट्स हैं, और यहां विज़ार्ड डेनिस आता है उस के उत्तर के साथ आधा ..;) सुंदर अजीब जब memes और सच्चाई एक और एक ही हैं: " कोई भी डेनिस से बाहर नहीं निकलता है! "

— केविन क्रूज़सेन

1

@ केविनक्रूजसेन एपीएल एक गोल्फ भाषा नहीं है।

— Adám

1

@ मुझे पता है, मुझे पता है। लेकिन यह अभी भी बहुत कम है (1960 के दशक में पहली बार विकसित होने के बावजूद)। हो सकता है कि मुझे गोल्फ की भाषाओं के बजाय छोटी भाषाएँ कहनी चाहिए थीं। अच्छी तरह से ..

— केविन क्रूज़सेन

5

चारकोल , 25 23 बाइट्स

ＡθＩＥ⌈ＥθＬιＥ⌈ＥθＬ§λ⁰ΣＥθ§§νιλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 3-आयामी सरणी के रूप में इनपुट लेता है। स्पष्टीकरण:

~~Ａθ~~

~~सब कुछ इनपुट करें।~~

    θ                   Input
   Ｅ                    Map over arrays
      ι                 Current array
     Ｌ                  Length
  ⌈                     Maximum
 Ｅ                      Map over implicit range
          θ             Input
         Ｅ              Map over arrays
             λ          Current array
            § ⁰         First element
           Ｌ            Length
        ⌈               Maximum
       Ｅ                Map over implicit range
                 θ      Input
                Ｅ       Map over arrays
                    ν   Current array
                   § ι  Cyclically index using outer loop index
                  §   λ Cyclically index using inner loop index
               Σ        Sum
Ｉ                       Cast to string
                        Implicitly print on separate lines and paragraphs

— नील
स्रोत

: P (हालांकि यह लंबा है> _>)

— केवल

5

MATL , 25 24 बाइट्स

,iZy]vX>XKx,@GK:KP:3$)]+

इसे ऑनलाइन आज़माएं!

आखिरकार! माह की भाषा से प्रेरित चुनौती का जवाब देने के लिए केवल एक सप्ताह का समय लिया गया है!

मेरा अनुमान है कि यह जितना संभव हो उतना छोटा नहीं है, लेकिन मैं काफी खुश हूं क्योंकि मेरा शुरुआती संस्करण 40 बाइट्स से अधिक था। संपादित करें: मैं सही था, लुइस ने बाहर निचोड़ने के लिए एक और बाइट पाया!

,iZy]	# do twice: read input and find the size of each dimension
vX>	# find the maximum along each dimension
XKx	# save this into clipboard K and delete from stack. Stack is now empty.
,	# do twice:
 @G	# push the input at index i where i=0,1.
	# MATL indexes modularly, so 0 corresponds to the second input
 K:	# push the range 1...K[1]
 KP:	# push the range 1...K[2]
 3$)	# use 3-input ) function, which uses modular indexing
	# to expand the rows and columns to the appropriate broadcasted size
]	# end of loop
+	# sum the now appropriately-sized matrices and implicitly display

— ग्यूसेप
स्रोत

लुइस मेंडू के लिए 5 और बाइट्स गोल्फ के लिए इंतजार कर ;-)

— Giuseppe

: -D परीक्षण मामलों के लिए मेरा कार्यक्रम 26 बाइट्स था, अच्छी तरह से किया! :वेक्टर इनपुट के साथ अच्छा उपयोग

— लुइस मेंडो

4

पायथन 3 , 127 126 125 बाइट्स

बदलकर एक बाइट golfed sum(m)कोm+n

@Jonathan Frech को एक और बाइट धन्यवाद

lambda y:[[m+n for n,m,j in Z(l)]for*l,i in Z(y)]
from itertools import*
Z=lambda y:zip(*map(cycle,y),range(max(map(len,y))))

इनपुट को दो 2-आयामी सरणियों की सूची के रूप में लेता है।

Zजब तक सूचकांक सबसे बड़ा सरणी की लंबाई तक पहुँच जाता है लैम्ब्डा इनपुट के रूप में दो सरणियों लेता है और एक इटरेटर एक सूचकांक उपज और दोनों सरणियों से मूल्यों विलय कर देता है,। सूचकांक चर मेरे लिए उपयोगी नहीं है और मुझे बाइट्स की लागत है, लेकिन मुझे नहीं पता कि इसके बिना कैसे करना है ... ( संबंधित )
मुख्य लैम्ब्डा केवल इनपुट सरणियों को लेता है और Zबाहरी और आंतरिक सरणियों पर कॉल करता है। अंतर मानों को एक साथ जोड़ा जाता है।

इसे ऑनलाइन आज़माएं!

उपयोग करने से itertools.cycleधोखा देने जैसा कुछ महसूस होता है, लेकिन मुझे लगता है कि मुझे सरासर आयात कथन की लंबाई से काफी सजा दी गई है :)

मुझे यकीन है कि यह कुछ और अधिक हो सकता है, विशेष रूप से पुनरावृत्ति विधि जो इन बेकार iऔर jचर को छोड़ देती है । मैं कैसे गोल्फ के लिए किसी भी सुझाव पर आभारी होंगे कि, मैं शायद कुछ स्पष्ट याद कर रहा हूँ।

— etene
स्रोत

क्या आप अपनी zipदलीलें बदल सकते हैं , उल्टा fकाम को समझ सकते हैं और इस तरह एक स्थान ( for i,*l-> for*l,i) को हटा सकते हैं ? ( 125 बाइट्स )?

— जोनाथन फ्रीच

एक और बाइट, धन्यवाद! मैं अपनी पोस्ट को अपडेट करूंगा।

— इथेन

3

जावास्क्रिप्ट (ईएस 6), 131 बाइट्स

नौकरी के लिए सही उपकरण नहीं है, और शायद सही दृष्टिकोण भी नहीं है। ओह वेल ... well \ _ (ツ) _ / ¯

a=>b=>(g=(a,b,c)=>[...Array((a[b[L='length']]?a:b)[L])].map(c))(a,b,(_,y)=>g(a[0],b[0],(_,x)=>(h=a=>a[y%a[L]][x%a[0][L]])(a)+h(b)))

इसे ऑनलाइन आज़माएं!

कैसे?

हेल्पर फंक्शन g () एक ऐरे बनाता है जो सबसे बड़े इनपुट ऐरे ( a या b ) जितना बड़ा होता है और कॉलबैक फंक्शन को c पर लागू करता है:

g = (a, b, c) =>
  [...Array(
    (a[b[L = 'length']] ? a : b)[L]
  )].map(c)

सहायक समारोह ज () पढ़ता है 2 डी सरणी एक में (एक्स, वाई) मॉड्यूलर प्रसारण के साथ:

h = a => a[y % a[L]][x % a[0][L]]

मुख्य कोड अब बस के रूप में पढ़ता है:

a => b =>
  g(a, b, (_, y) =>
    g(a[0], b[0], (_, x) =>
      h(a) + h(b)
    )
  )

पुनरावर्ती संस्करण, 134 बाइट्स

a=>b=>(R=[],g=x=>a[y]||b[y]?a[0][x]+1|b[0][x]+1?g(x+1,(R[y]=R[y]||[])[x]=(h=a=>a[y%a.length][x%a[0].length])(a)+h(b)):g(+!++y):R)(y=0)

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

3

05AB1E , 15 बाइट्स

2FεIζg∍ø]øεø¨}O

इसे ऑनलाइन आज़माएं!

पुराना संस्करण, 25 बाइट्स

é`DŠg∍)Σнg}`DŠнgδ∍€˜)ø€øO

इसे ऑनलाइन आज़माएं!

व्याख्या

15-byter:

2F 2I¨g∍ø] øεø O} O - पूर्ण कार्यक्रम। STDIN से 3 डी [ए, बी] सूची के रूप में इनपुट लेता है।
2F - दो बार लागू करें:
  [- [ए, बी] में प्रत्येक के लिए:
   I input - इनपुट स्थानांतरित करें (रिक्त स्थान के साथ अंतराल को भरना)।
     जी - लंबाई (पंक्तियों की संख्या को पुनः प्राप्त करें)।
      The - वर्तमान वस्तु (ए या बी) को आवश्यक लंबाई तक बढ़ाएं।
       ø - संक्रमण।
        ] - सभी छोरों को बंद करें।
         ø - फिर से स्थानांतरण करें।
          row - ^ (पंक्ति के परिणाम का कॉलम) में प्रत्येक पंक्ति के लिए:
           ø - कॉलम को स्थानांतरित करें।
            ¨} - अंतिम तत्व निकालें और मैप-लूप बंद करें।
              ओ - सुम।

25-byter:

é`D `g∍) gнg} `Dδ∍нg˜ €) ø € øO - पूर्ण कार्यक्रम। STDIN से 3 डी सूची के रूप में इनपुट लेता है।
é - लंबाई द्वारा सूची को क्रमबद्ध करें।
 `डी - स्टैक पर अलग से डंप सामग्री, टूएस को डुप्लिकेट करें।
   Tri - एक ट्रिपल स्वैप करें। ए, बी, सी -> सी, ए, बी।
    जी - ToS की लंबाई प्राप्त करें।
     The - तदनुसार छोटी सूची (ऊंचाई में) बढ़ाएं।
      ) List} - पूरे स्टैक को एक सूची में लपेटें और इसे इसके द्वारा क्रमबद्ध करें:
        нg - इसके पहले आइटम की लंबाई।
           `डी` - ऊपर के रूप में भी।
              нg - पहले तत्व की लंबाई।
                δ∍ € δ∍ - तदनुसार छोटी सूची (चौड़ाई में) बढ़ाएँ। 
                    ø - स्टैक को एक सूची में लपेटें और इसे स्थानांतरित करें (ज़िप करें)।
                      € ø - फिर प्रत्येक सूची को ज़िप करें।
                        ओ - सदिश योग को लागू करें।

— मिस्टर एक्सकोडर
स्रोत

3

आर , 136 104 103 95 93 बाइट्स

एक whopping नीचे golfed 33 ग्यूसेप की सलाह निम्नलिखित 35 बाइट्स। एक फ़ंक्शन नाम के रूप में एक ऑपरेटर का उपयोग करके 100 बाइट्स के तहत प्राप्त करने का प्रबंधन। अधिक सुपाठ्य कोड के लिए इतिहास देखें।

function(x,y,d=pmax(dim(x),dim(y)))y/d[2]/d[1]+x/d[2]/d[1]
"/"=function(x,j)apply(x,1,rep,,j)

इसे ऑनलाइन आज़माएं!

— Jayce
स्रोत

अच्छा! मैं करने के लिए इस नीचे golfed गए 104 बाइट्स लेकिन का उपयोग कर applyऔर rep.lenहालांकि मैं अपने आप को यह कोडिंग अप करने के लिए चारों ओर हो गया नहीं था कि मैं क्या माना जाता था है।

— ग्यूसेप

@Giuseppe धन्यवाद! 104 संस्करण हालांकि अपेक्षित आउटपुट नहीं देता है।

— JayCe

1

ऊ, मैं तुम्हें भटका रहा हूँ! यह काम करना चाहिए

— Giuseppe

1

@Giuseppe dim, बहुत अधिक क्लीनर के उपयोग से प्यार करें और पुनरावर्ती कॉल के साथ एक बहुआयामी सामान्यीकरण के लिए दरवाजा खोलता हैr

— JayCe

मैं उपयोग करने की कोशिश कर रहा हूं outer(x,y,"+")जिसमें सभी सही रकम शामिल हैं, और एक स्पष्ट पैटर्न में। समझ नहीं पा रहे हैं कि उन्हें कुशलतापूर्वक कैसे निकाला जाए।

— एन जी एम

2

के (ngn / k) , 23 बाइट्स

{+/2{+:'(|/#:'x)#'x}/x}

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

2

05AB1E , 18 बाइट्स

éR`UvXNèy‚é`©g∍®+ˆ

इसे ऑनलाइन आज़माएं!

व्याख्या

éR                  # sort by length, descending
  `U                # store the shorter list in X
    v               # for each list y, index N in the longer list
     XNè            # get the nth element of the shorter list
        y‚é         # pair with y and sort by length
           `©g∍     # repeat the shorter list to the same length as the longer
               ®+   # elementwise addition of the lists
                 ˆ  # add to global list
                    # implicitly print global list

— Emigna
स्रोत

2

अजगर, 24 बाइट्स

KeSmlhdQmm+Fm@@bdkQKeSlM

इसे यहाँ आज़माएँ

व्याख्या

KeSmlhdQmm+Fm@@bdkQKeSlM
                    eSlMQ  Get the maximum length of (implicit) input...
KeSmlhdQ           K       ... and the maximum row length.
        mm                 For each 2d index ...
          +Fm@@bdkQ        ... get the sum of the appropriate elements.

2

जावा 8, 172 बाइट्स

A->B->{int m=A.length,o=A[0].length,d=B.length,u=B[0].length,l=m>d?m:d,a=o>u?o:u,r[][]=new int[l][a],$;for(;l-->0;)for($=a;$-->0;)r[l][$]=A[l%m][$%o]+B[l%d][$%u];return r;}

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

A->B->{                   // Method with integer-matrix as both parameters and return-type
  int m=A.length,         //  Rows of `A`                        (we got an     M)
      o=A[0].length,      //  Columns of `A`                     (we got an     O)
      d=B.length,         //  Rows of `B`                        (we got a      D)
      u=B[0].length,      //  Columns of `B`                     (we got a      U)
      l=m>d?m:d,          //  Maximum of both rows               (we got an     L)
      a=o>u?o:u,          //  Maximum of both columns            (we got an     A)
      r[][]=new int[l][a],//  Result-matrix of size `l` by `a`   (and we got an R)
      $;                  //  Temp integer                       (which $pells? ;P)
  for(;l-->0;)            //  Loop over the rows
    for($=a;$-->0;)       //   Inner loop over the columns
      r[l][$]=            //    Set the current cell in the result-matrix to:
        A[l%m][$%o]       //     The value at {`l` modulo-`m`, `$` modulo-`o`} in `A`
        +B[l%d][$%u];     //     Plus the value at {`l` modulo-`d`, `$` modulo-`u`} in `B`
  return r;}              //  Return the result matrix

— केविन क्रूज़सेन
स्रोत

2

APL (Dyalog Classic) , 23 21 बाइट्स

↑{+⌿⍺[⍵|[0]⍳⍴⍺]}2,¨⍴¨

इसे ऑनलाइन आज़माएं!

यह केवल समय हो सकता है जब मुझे उपयोग करने का मौका मिले |[0]

— NGN
स्रोत

2

पायथन 2 , 124 116 बाइट्स

l=len
A,B=sorted(input(),key=l)
A*=l(B)
for i in eval(`zip(A,B)`):a,b=sorted(i,key=l);a*=l(b);print map(sum,zip(*i))

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

इनपुट के रूप में दो 2-डी सूचियों की सूची लेता है।

l=len
A,B=sorted(input(),key=l)         # Sort inputed lists by length
A*=l(B)                           # Extend shorter list
for i in eval(`zip(A,B)`):        # Zip and remove copied references
  a,b=sorted(i,key=l)             # Sort lists in each pair (keep references)
  a*=l(b)                         # Extend shorter list
  print map(sum,zip(*i))          # Zip and sum

— मृत पोसुम
स्रोत

मैंने हमारे दोनों समाधानों से विचार लिया और 105 बाइट्स पर आ गया । मुझे हालांकि पायथन 2 का उपयोग करना था, और मुझे आपके कोड से गुणन की चाल मिली, इसलिए यह मेरे उत्तर को अद्यतन करने के लिए सही नहीं लगेगा :)

— etene

1

@etene आपको इसे पोस्ट करना चाहिए, यह अच्छा उपाय है!

— मृत पोसुम

धिक्कार है, मेरी ओर से बहुत मूर्खतापूर्ण गलतियों, धन्यवाद (फिर से)!

— इथेन

1

@etene अभी देखा, इस समाधान में 2 और 6 परीक्षण मामलों के मुद्दे थे। कॉपी किए गए संदर्भों को हटाने की आवश्यकता है

— डेड पॉसम

1

@etene वापस 105 बाइट्स के लिए : C

— डेड पॉसम

2

पायथन 2 , 101 97 105 बाइट्स

संपादित करें: 4 बाइट बचाने के लिए डेड पॉसम को धन्यवाद (फिर से!)

2 संपादित करें: 8 बाइट्स खो गए, कुछ परीक्षण मामले गुजर नहीं रहे थे

डेड पोसुम के पहले समाधान (उसके लिए धन्यवाद!), और मेरे अपने पायथन 3 समाधान के बीच एक मिश्रण ।

lambda y:[map(sum,P(i))for i in P(y)]
def P(y):y=sorted(y,key=len);y[0]*=len(y[1]);return eval(`zip(*y)`)

इसे ऑनलाइन आज़माएं!

मेरे अजगर 3 समाधान (2 आयामी सूचियों की एक जोड़ी) के रूप में एक ही इनपुट।

टिप्पणी कोड:

# Iterate over the nested lists, resized & joined by P(),
# and sum the inner joined items
lambda y:[map(sum,P(i))for i in P(y)]
def P(y):
 y=sorted(y,key=len)  # Sort the two input lists by length
 y[0]*=len(y[1])      # Multiply the smallest one by the biggest one's length
                      # (The smallest list is now the previously largest one)
 return eval(`zip(*y)`)  # Return paired list elements up to the smallest list's length

— etene
स्रोत

1

जूलिया 0.6 , 85 83 बाइट्स

M\N=(((r,c),(s,d))=size.((M,N));repmat(M,s,d)+repmat(N,r,c))[1:max(r,s),1:max(c,d)]

इसे ऑनलाइन आज़माएं!

( जो किंग को धन्यवाद के ⧻साथ बदलें )\

प्रत्येक मैट्रिक्स को क्षैतिज और लंबवत दोहराते हुए काम करता है ताकि उन दोनों का आकार समान हो (पंक्ति आकारों के उत्पाद स्तंभ के आकार के x उत्पाद), उन्हें जोड़कर और उसमें से सही क्षेत्र निकालकर। (पंक्ति वेक्टर इनपुट या स्तंभ वेक्टर इनपुट reshapeको 2-आयामी सरणियों के रूप में कॉल करने की आवश्यकता होती है , जो मैं मान रहा हूं क्योंकि प्रश्न "दो-आयामी सरणियों के लिए कार्यान्वयन को लागू करता है" और "इनपुट और आउटपुट किसी भी द्वारा लिया जा सकता है" उचित साधन। उनका प्रारूप हमेशा की तरह लचीला है। ")

— sundar - मोनिका को बहाल करना
स्रोत