ความท้าทายนี้จะเกี่ยวข้องกับบางส่วนของคุณสมบัติภาษา MATL ที่เป็นส่วนหนึ่งของพฤษภาคม 2018 ภาษาของเดือนเหตุการณ์

บทนำ

ใน MATL ฟังก์ชั่นสองอินพุตหลายทำงานองค์ประกอบที่ชาญฉลาดด้วยการออกอากาศ นี่หมายความว่า:

Element-wise (หรือvectorized ): ฟังก์ชันใช้เป็นอินพุตสองอาร์เรย์พร้อมขนาดที่ตรงกัน การดำเนินการที่กำหนดโดยฟังก์ชั่นจะใช้กับรายการที่เกี่ยวข้องแต่ละคู่ ตัวอย่างเช่นการใช้สัญลักษณ์หลังการแก้ไข:
```
[2 4 6] [10 20 30] +
```
ให้ ouput
```
[12 24 36]
```
นอกจากนี้ยังทำงานร่วมกับอาร์เรย์หลายมิติ สัญกรณ์[1 2 3; 4 5 6]แสดงถึงอาร์เรย์2× 3(เมทริกซ์)
```
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และพวกเขาจะไม่เท่ากันและไม่มีของพวกเขาคือ31

ความหมายของการออกอากาศแบบแยกส่วน

กระจายเสียง Modular 1เป็นลักษณะทั่วไปของการเผยแพร่ผลงานว่าแม้ไม่มีขนาดที่ไม่ตรงกัน ลองพิจารณาตัวอย่างของอาร์เรย์× และ2× ต่อไปนี้เป็นอินพุตของฟังก์ชัน:231+

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

กฎมีดังนี้: สำหรับแต่ละมิติอาร์เรย์ที่มีขนาดเล็กกว่าตามมิตินั้นจะถูกจำลองแบบโมดูลาร์ (cyclically)เพื่อให้ตรงกับขนาดของอาร์เรย์อื่น สิ่งนี้จะทำให้เทียบเท่ากับ

[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ในแต่ละมิติ

กฎ Aditional:

input และ output สามารถดำเนินการโดยวิธีการที่เหมาะสมใด ๆ รูปแบบของพวกเขายืดหยุ่นตามปกติ
โปรแกรมหรือฟังก์ชั่นที่ได้รับอนุญาตในการเขียนโปรแกรมภาษา ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

ต่อไปนี้ใช้;เป็นตัวคั่นแถว (ดังในตัวอย่างด้านบน) กรณีทดสอบแต่ละรายการจะแสดงทั้งสองอินพุตจากนั้นเอาต์พุต

[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]

— หลุยส์เมนโด
แหล่งที่มา

"เพิ่มการใช้งานสำหรับอาร์เรย์สองมิติ" - มีกรณีทดสอบหนึ่งมิติ

— Jonathan Allan

เราขอสมมติว่าเราไม่ได้รับอินพุตอะเรย์ที่ขาด (ดูเหมือนว่า)

— Jonathan Allan

1

@JonathanAllan ขออภัยที่ยังไม่ชัดเจน ใช่คุณสามารถสมมติว่าไม่มีอาร์เรย์ที่ขาดการใช้งานได้ พวกเขาจะเป็นอาร์เรย์สี่เหลี่ยม คน "หนึ่งมิติ" ควรถูกมองว่าเป็นสองมิติที่มีขนาด1× n(เช่น[1 2 3]) หรือn× 1(เช่น[1; 2; 3])

— Luis Mendo

การออกอากาศที่คุณอธิบายนั้นมี จำกัด มากกว่าการออกอากาศ MATLAB หรือ NumPy; ในคำอธิบายของคุณอินพุตจะต้องมีจำนวนมิติเท่ากันข้อ จำกัด ที่ไม่มีอยู่ใน MATLAB หรือ NumPy นี่เป็นข้อ จำกัด MATL หรือการทำให้เข้าใจง่ายสำหรับวัตถุประสงค์ของการท้าทาย (เนื่องจากความท้าทายถูก จำกัด ที่อินพุต 2D) หรือไม่

— user2357112 รองรับ Monica

@ user2357112 ใช่มันเป็นความเรียบง่ายในคำอธิบาย การออกอากาศของ MATLAB นั้นเหมือนกับใน MATLAB: คุณสามารถมีอินพุต 3 × 2 และ 3 × 1 × 5 และรับผลแบบ 3 × 2 × 5 ที่จริงแล้ว 3 × 2 เทียบเท่ากับ 3 × 2 × 1 (ขนาดต่อท้ายแบบนัย) ฉันคิดว่ามันคล้ายกันใน Numpy (แต่มีขนาดนำ) ฉันชี้แจงว่าในการแนะนำ

— Luis Mendo

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

แน่นอน ... ฉันเห็นภาษากอล์ฟเหล่านี้ค่อนข้างเข้ากันได้ในแง่ของจำนวนไบต์ที่จำเป็นสำหรับความท้าทาย (Jelly, 05AB1E, Pyth, APL และอื่น ๆ ) คำตอบปัจจุบันส่วนใหญ่มีขนาดประมาณ 20 ไบต์และ Wizard Dennis มาพร้อมกัน ด้วยคำตอบที่ลดลงครึ่งหนึ่ง .. ;) ค่อนข้างตลกเมื่อมส์และความจริงเป็นหนึ่งเดียวกัน: " ไม่มีใคร outgolfs Dennis! .. "

— Kevin Cruijssen

1

@KevinCruijssen APL ไม่ใช่ภาษากอล์ฟ

— อดัม

1

@ Adámฉันรู้ฉันรู้ แต่ก็ยังสั้นมาก (แม้จะถูกพัฒนาขึ้นครั้งแรกในปี 1960) บางทีฉันควรพูดภาษาสั้น ๆ แทนภาษากอล์ฟ อาดี ..

— เควิน Cruijssen

5

ถ่าน , 25 23 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน รับอินพุตเป็นอาร์เรย์สามมิติ คำอธิบาย:

~~Ａθ~~

~~ใส่ทุกอย่าง~~

    θ                   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 (นานกว่านั้น> _>)

— ASCII- เท่านั้น

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

— จูเซปเป้
แหล่งที่มา

รอให้ Luis Mendo ตีกอล์ฟอีก 5 ไบต์ ;-)

— Giuseppe

:-D โปรแกรมของฉันสำหรับกรณีทดสอบมี 26 ไบต์ทำได้ดีมาก! ใช้งานได้ดี:กับอินพุตเวกเตอร์

— Luis Mendo

4

Python 3 , 127 126 125 ไบต์

golfed byte โดยเปลี่ยนsum(m)เป็นm+n

อีกหนึ่งไบต์ขอบคุณ @Jathanathan 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แลมบ์ดาจะใช้เวลาสองอาร์เรย์เป็น input และส่งกลับ iterator ผลผลิตดัชนีและรวมค่าจากอาร์เรย์ทั้งสองจนดัชนีความยาวถึงอาร์เรย์ที่ใหญ่ที่สุดของ ตัวแปรดัชนีไม่มีประโยชน์สำหรับฉันและทำให้ฉันต้องจ่ายเป็นไบต์ แต่ฉันไม่รู้ว่าจะทำอย่างไรหากไม่มี ... ( เกี่ยวข้อง )
แลมบ์ดาหลักใช้เพียงแค่อินพุตอาร์เรย์และการเรียกใช้อาร์เรย์Zภายนอกและภายใน ค่าที่อยู่ด้านในสุดถูกรวมเข้าด้วยกัน

ลองออนไลน์!

การใช้itertools.cycleรู้สึกเหมือนการโกง แต่ฉันคิดว่าฉันถูกลงโทษเพียงพอโดยความยาวคำสั่งการนำเข้าที่แท้จริง :)

ฉันแน่ใจว่านี่สามารถเล่นกอล์ฟได้มากกว่านี้โดยเฉพาะวิธีการทำซ้ำที่ทำให้ไร้ประโยชน์iและjตัวแปรเหล่านี้ ฉันจะขอบคุณในเคล็ดลับเกี่ยวกับวิธีการเล่นกอล์ฟฉันอาจพลาดอะไรบางอย่างที่ชัดเจน

— etene
แหล่งที่มา

คุณสามารถสลับzipข้อโต้แย้งของคุณกลับfการมอบหมายความเข้าใจกลับแล้วจึงลบหนึ่งช่องว่าง ( for i,*l-> for*l,i) ได้ไหม ( 125 ไบต์ )

— Jonathan Frech

อีกหนึ่งไบต์ขอขอบคุณ! ฉันจะอัปเดตโพสต์ของฉัน

— etene

3

JavaScript (ES6), 131 ไบต์

ไม่ใช่เครื่องมือที่เหมาะสมสำหรับงานและอาจไม่ใช่แนวทางที่ถูกต้องเช่นกัน โอ้ ... ¯ \ _ (ツ) _ / ¯

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)

ฟังก์ชั่นตัวช่วยh ()อ่านอาเรย์ 2 มิติa at (x, y)พร้อมการออกอากาศแบบแยกส่วน:

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εIζg∍ø] øεø¨} O - โปรแกรมเต็มรูปแบบ ใช้อินพุตเป็นรายการ 3D [A, B] จาก STDIN
2F - ใช้สองครั้ง:
  ε - สำหรับแต่ละใน [A, B]:
   Iζ - ย้ายอินพุต (เติมช่องว่างด้วยช่องว่าง)
     g - ความยาว (ดึงข้อมูลจำนวนแถว)
      ∍ - ขยายรายการปัจจุบัน (A หรือ B) เป็นความยาวที่จำเป็น
       ø - ไขว้
        ] - ปิดลูปทั้งหมด
         ø - ไขว้อีกครั้ง
          ε - สำหรับแต่ละแถวใน ^ (คอลัมน์ของผลลัพธ์ลูป):
           ø - ย้ายคอลัมน์
            ¨} - ลบองค์ประกอบสุดท้ายและปิด map-loop
              O - ผลรวม

25 byter:

é`DŠg∍) Σнg} `DŠнgδ∍€ ˜) ø€øO - โปรแกรมเต็มรูปแบบ รับอินพุตเป็นรายการ 3D จาก STDIN
é - เรียงลำดับรายการตามความยาว
 `D - เนื้อหาการถ่ายโอนข้อมูลแยกกันลงบนสแต็คทำซ้ำ ToS
   Š - ทำการสลับสามครั้ง a, b, c -> c, a, b
    g - รับความยาวของ ToS
     ∍ - ขยายรายการที่สั้นกว่า (ตามความสูง) ตามลำดับ
      ) Σ} - ห่อทั้งสแต็กลงในรายการและเรียงตาม:
        нg - ความยาวของรายการแรก
           `DŠ - เหมือนข้างบน
              нg - ความยาวขององค์ประกอบแรก
                δ∍€ ˜ - ขยายรายการให้สั้นลง (ตามความกว้าง) ตามลำดับ 
                    ) ø - ห่อสแต็คลงในรายการและเปลี่ยน (zip)
                      €ø - จากนั้นบีบแต่ละรายการ
                        O - ใช้ผลรวมของเวกเตอร์

— นาย Xcoder
แหล่งที่มา

3

R , 136 104 103 95 93 ไบต์

ลงสนามขนาดมหึมา33 35 bytes ตามคำแนะนำของ Giuseppe จัดการเพื่อให้ได้ต่ำกว่า 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
แหล่งที่มา

ดี! ฉันเล่นกอล์ฟนี้ลงถึง104 ไบต์แต่ใช้applyและrep.lenเป็นสิ่งที่ฉันพิจารณาถึงแม้ว่าฉันจะไม่ได้เขียนโปรแกรมเอง

— Giuseppe

@iuseppe ขอบคุณ! เวอร์ชัน 104 ไม่ได้ให้ผลลัพธ์ที่คาดหวัง

— JayCe

1

เอ่อฉันพาคุณหลงทาง! อันนี้น่าจะใช้ได้

— Giuseppe

1

@Giuseppe ชอบการใช้งานที่dimสะอาดกว่าและเปิดประตูสู่การวางตัวแบบหลายมิติด้วยการโทรซ้ำเพื่อr

— JayCe

ฉันพยายามใช้ outer(x,y,"+")ซึ่งมีผลรวมที่ถูกต้องทั้งหมดและในรูปแบบที่ชัดเจน ไม่สามารถหาวิธีดึงข้อมูลได้อย่างมีประสิทธิภาพ

— ngm

2

K (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

Pyth, 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

Java 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

— Kevin Cruijssen
แหล่งที่มา

2

APL (Dyalog Classic) , 23 21 ไบต์

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

ลองออนไลน์!

นี่อาจเป็นครั้งเดียวที่ฉันได้รับโอกาสใช้งาน |[0]

— NGN
แหล่งที่มา

2

Python 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-d สองรายการเป็นอินพุต

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 คุณควรโพสต์มันเป็นทางออกที่ดี!

— Dead Possum

ห่าฉันผิดอย่างโง่ ๆ ในส่วนของฉันขอบคุณ (อีกครั้ง)!

— etene

1

@etene เพิ่งสังเกตเห็นวิธีแก้ปัญหานี้มีปัญหากับ 2 และ 6 กรณีทดสอบ จำเป็นต้องลบข้อมูลอ้างอิงที่คัดลอกแล้ว

— Dead Possum

1

@etene กลับไปที่105 ไบต์ : C

— Dead Possum

2

Python 2 , 101 97 105 ไบต์

แก้ไข: ขอบคุณ (อีกครั้ง!) ถึง Dead Possum สำหรับการบันทึก 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)`)

ลองออนไลน์!

อินพุตเช่นเดียวกับโซลูชัน Python 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

Julia 0.6 , 85 83 bytes

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)]

ลองออนไลน์!

(แทนที่⧻ด้วย\ขอบคุณJo King )

ทำงานโดยการทำซ้ำแต่ละเมทริกซ์ในแนวนอนและแนวตั้งเพื่อให้ทั้งคู่มีขนาดเท่ากัน (ผลิตภัณฑ์ของขนาดแถว x ผลิตภัณฑ์ของขนาดคอลัมน์) เพิ่มขึ้นและแยกพื้นที่ที่ถูกต้องออกจากที่นั้น (อินพุตแบบเวกเตอร์แถวหรืออินพุตแบบเวกเตอร์คอลัมน์จำเป็นต้องมีการreshapeโทรเพื่อโยนเป็นอาร์เรย์แบบสองมิติซึ่งฉันถือว่าดีเนื่องจากคำถามระบุว่า "การเพิ่มการใช้งานสำหรับอาร์เรย์แบบสองมิติ" และ "อินพุตและเอาต์พุตสามารถทำได้โดยใด ๆ รูปแบบของพวกเขายืดหยุ่นตามปกติ ")

— sundar - Reinstate Monica
แหล่งที่มา