Mô-đun phát sóng


24

Thử thách này có liên quan đến một số tính năng của ngôn ngữ MATL, như là một phần của sự kiện Ngôn ngữ của tháng 5 năm 2018 .


Giới thiệu

Trong MATL, nhiều hàm hai đầu vào hoạt động theo yếu tố thông minh với phát sóng . Điều này có nghĩa như sau:

  • Element-khôn ngoan (hoặc vectorized ): hàm lấy làm đầu vào hai mảng với kích thước khớp nhau. Hoạt động được xác định bởi chức năng được áp dụng cho từng cặp mục tương ứng. Ví dụ: sử dụng ký hiệu sửa lỗi:

    [2 4 6] [10 20 30] +
    

    đưa ra thông số

    [12 24 36]
    

    Điều này cũng hoạt động với các mảng đa chiều. Ký hiệu [1 2 3; 4 5 6]đại diện cho mảng 2× 3(ma trận)

    1 2 3
    4 5 6
    

    có kích thước 2dọc theo chiều thứ nhất (dọc) và 3dọc theo chiều thứ hai (ngang). Ví dụ

    [2 4 6; 3 5 7] [10 20 30; 40 60 80] *
    

    cho

    [20 80 180; 120 300 560]
    
  • Phát sóng hoặc ( mở rộng singleton ): hai mảng đầu vào không có kích thước khớp nhau, nhưng trong mỗi kích thước không khớp, một trong các mảng có kích thước 1. Mảng này được sao chép ngầm dọc theo các kích thước khác để làm cho kích thước khớp với nhau; và sau đó các hoạt động được áp dụng yếu tố khôn ngoan như trên. Ví dụ: hãy xem xét hai mảng đầu vào có kích thước 1× 23× 1:

    [10 20] [1; 2; 5] /
    

    Nhờ phát sóng, điều này tương đương với

    [10 20; 10 20; 10 20] [1 1; 2 2; 5 5] /
    

    và vì vậy nó mang lại

    [10 20; 5 10; 2 4]
    

    Tương tự, với kích thước 3× 23× 1(giờ chỉ phát theo chiều thứ hai),

    [9 8; 7 6; 5 4] [10; 20; 30] +
    

    cho

    [19 18; 27 26; 35 34]
    

    Số lượng kích thước thậm chí có thể khác nhau. Ví dụ: các đầu vào có kích thước 3 × 2 và 3 × 1 × 5 tương thích và cho kết quả 3 × 2 × 5. Trong thực tế, kích thước 3 × 2 giống như 3 × 2 × 1 (có nhiều kích thước đơn lẻ ẩn ý tùy ý).

    Mặt khác, một cặp 2× 23× 1mảng sẽ cung cấp cho một lỗi, vì kích thước dọc theo chiều đầu tiên là 23: họ không bình đẳng và không ai trong số họ là 1.

Định nghĩa phát sóng mô-đun

Phát sóng mô-đun là một khái quát của phát sóng hoạt động ngay cả khi không có kích thước không phù hợp 1. Ví dụ, xem xét các mảng × và 2× sau đây làm đầu vào của hàm :231+

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

Quy tắc như sau: đối với mỗi kích thước, mảng nhỏ hơn dọc theo chiều đó được sao chép theo mô-đun (theo chu kỳ) để phù hợp với kích thước của mảng khác. Điều này sẽ làm cho ở trên tương đương với

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

Với kết quả

[12 14; 26 28; 32 34]

Như một ví dụ thứ hai,

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

sẽ sản xuất

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

Nói chung, các đầu vào có kích thước a× bc× dcho kết quả là kích thước max(a,b)× max(c,d).

Các thách thức

Triển khai bổ sung cho mảng hai chiều với phát sóng theo mô-đun như được định nghĩa ở trên.

Các mảng sẽ có hình chữ nhật (không bị rách), sẽ chỉ chứa các số nguyên không âm và sẽ có kích thước ít nhất1 trong mỗi chiều.

Quy tắc bổ trợ:

Các trường hợp thử nghiệm

Sau đây sử dụng ;như dấu phân cách hàng (như trong các ví dụ ở trên). Mỗi trường hợp thử nghiệm cho thấy hai đầu vào và sau đó đầu ra.

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

"Thực hiện bổ sung cho mảng hai chiều" - có các trường hợp thử nghiệm một chiều.
Jonathan Allan

Chúng tôi có thể giả định rằng chúng tôi không nhận được mảng đầu vào rách rưới? (có vẻ như vậy)
Jonathan Allan

1
@Jonathan ALLan Xin lỗi vì đã không rõ ràng. Có, bạn có thể giả sử không có mảng rách rưới. Chúng sẽ là các mảng hình chữ nhật. Những cái "một chiều" nên được coi là hai chiều với kích thước 1× n(chẳng hạn như [1 2 3]) hoặc n× 1(chẳng hạn [1; 2; 3])
Luis Mendo

Việc phát sóng mà bạn mô tả có vẻ hạn chế hơn so với phát sóng MATLAB hoặc NumPy; trong mô tả của bạn, các đầu vào phải có cùng số lượng kích thước, một hạn chế không có trong MATLAB hoặc NumPy. Đây có phải là hạn chế MATL hay đơn giản hóa cho các mục đích của thử thách (vì thử thách được giới hạn ở đầu vào 2D)?
user2357112 hỗ trợ Monica

@ user2357112 Vâng, đó là một sự đơn giản hóa trong mô tả. Phát sóng của MATL giống như trong MATLAB: bạn có thể có đầu vào 3 × 2 và 3 × 1 × 5 và nhận được kết quả 3 × 2 × 5. Trên thực tế, 3 × 2 tương đương với 3 × 2 × 1 (kích thước dấu ngầm). Tôi nghĩ rằng nó tương tự trong Numpy (nhưng với kích thước hàng đầu). Tôi đã làm rõ điều đó trong phần giới thiệu
Luis Mendo

Câu trả lời:


4

Thạch , 10 byte

ṁ€ZL$Z€Ɗ⁺S

Lấy một cặp ma trận (hai mảng hàng) làm đầu vào và trả về một ma trận.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ṁ€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
Tất nhiên ... Tôi thấy tất cả các ngôn ngữ chơi gôn này có phần tương thích về các byte cần thiết cho một thử thách (Jelly, 05AB1E, Pyth, APL, v.v.) Hầu hết các câu trả lời hiện tại là khoảng 20 byte, và đến đây là Wizard Dennis với một nửa câu trả lời đó ..;) Khá buồn cười khi các meme và sự thật là một và giống nhau: " Không ai vượt qua Dennis! .. "
Kevin Cruijssen

1
@KevinCruijssen APL không phải là ngôn ngữ chơi gôn.
Adám

1
@ Adám tôi biết, tôi biết. Nhưng nó vẫn rất ngắn (mặc dù được phát triển lần đầu tiên vào những năm 1960). Có lẽ tôi nên nói ngôn ngữ ngắn thay vì ngôn ngữ golf. À ..
Kevin Cruijssen

5

Than , 25 23 byte

AθIE⌈EθLιE⌈EθL§λ⁰ΣE觧νιλ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đưa đầu vào dưới dạng mảng 3 chiều. Giải trình:

Aθ

Nhập mọi thứ.

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

: P (mặc dù dài hơn> _>)
ASCII - chỉ

5

MATL , 25 24 byte

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

Hãy thử trực tuyến!

Cuối cùng! Chỉ mất một tuần để thử thách ngôn ngữ của tháng được trả lời bằng Ngôn ngữ của tháng!

Tôi đoán là nó không hoàn toàn ngắn nhất có thể, nhưng tôi đủ hạnh phúc vì phiên bản ban đầu của tôi là hơn 40 byte. chỉnh sửa: Tôi đã đúng, Luis tìm thấy một byte khác để vắt kiệt!

,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

chờ Luis Mendo chơi golf thêm 5 byte nữa ;-)
Giuseppe

:-D Chương trình của tôi cho các trường hợp thử nghiệm có 26 byte, được thực hiện tốt! Sử dụng tốt :với đầu vào véc tơ
Luis Mendo

4

Python 3 , 127 126 125 byte

đánh một byte bằng cách thay đổi sum(m)thànhm+n

Thêm một byte nhờ @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))))

Lấy đầu vào là một danh sách hai mảng 2 chiều.

  • Các Zlambda mất hai mảng như là đầu vào và trả về một iterator năng suất một chỉ số và sáp nhập giá trị từ hai mảng, cho đến khi chỉ số đạt chiều dài mảng lớn nhất. Biến chỉ mục không hữu ích với tôi và làm tôi tốn byte, nhưng tôi không biết làm thế nào để không có nó ... ( liên quan )
  • Lambda chính chỉ nhận các mảng đầu vào và các cuộc gọi Ztrên các mảng bên ngoài và bên trong. Các giá trị trong cùng được thêm vào với nhau.

Hãy thử trực tuyến!

Sử dụng itertools.cyclecảm thấy hơi giống như gian lận nhưng tôi nghĩ rằng tôi đã bị trừng phạt đủ bởi độ dài câu lệnh nhập tuyệt đối :)

Tôi chắc chắn rằng điều này có thể được đánh gôn thêm, đặc biệt là phương pháp lặp để lại các biến ivà vô dụng này j. Tôi sẽ biết ơn bất kỳ lời khuyên nào về cách chơi golf đó, có lẽ tôi đang thiếu một cái gì đó rõ ràng.


Bạn có thể trao đổi zipcác đối số của mình, fgán lại sự hiểu biết của mình và do đó xóa một khoảng trắng ( for i,*l-> for*l,i) không? ( 125 byte )?
Jonathan Frech

Thêm một byte nữa, cảm ơn bạn! Tôi sẽ cập nhật bài viết của tôi.
etene

3

JavaScript (ES6), 131 byte

Không phải là công cụ phù hợp cho công việc, và có lẽ cũng không phải là phương pháp phù hợp. Ồ tốt ... ¯ \ _ (ツ) _ /

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

Hãy thử trực tuyến!

Làm sao?

Hàm trợ giúp g () tạo ra một mảng lớn bằng mảng đầu vào lớn nhất ( a hoặc b ) và gọi hàm gọi lại c qua nó:

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

Hàm trợ giúp h () đọc mảng 2D a tại (x, y) với phát sóng theo mô-đun:

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

Mã chính bây giờ chỉ đơn giản là đọc là:

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

Phiên bản đệ quy, 134 byte

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)

Hãy thử trực tuyến!


3

05AB1E , 15 byte

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

Hãy thử trực tuyến!


Phiên bản cũ, 25 byte

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

Hãy thử trực tuyến!

Giải trình

15-byter:

2FεIζg∍ø] øεø¨} O - Chương trình đầy đủ. Lấy đầu vào dưới dạng danh sách 3D [A, B] từ STDIN.
2F - Áp dụng hai lần:
  - Đối với mỗi trong [A, B]:
   Iζ - Chuyển đổi đầu vào (lấp đầy các khoảng trống bằng khoảng trắng).
     g - Chiều dài (lấy số lượng hàng).
      ∍ - Mở rộng mục hiện tại (A hoặc B) đến độ dài cần thiết.
       ø - Chuyển vị.
        ] - Đóng tất cả các vòng.
         ø - Chuyển tiếp một lần nữa.
          ε - Đối với mỗi hàng trong ^ (cột kết quả vòng lặp):
           ø - Chuyển vị cột.
            ¨} - Xóa phần tử cuối cùng và đóng vòng lặp bản đồ.
              Ô - Tổng.

25-byter:

é`DŠg∍) Σнg} `DŠнgδ∍ € ˜) ø € øO - Chương trình đầy đủ. Lấy đầu vào dưới dạng danh sách 3D từ STDIN.
é - Sắp xếp danh sách theo chiều dài.
 `D - Kết xuất nội dung riêng biệt trên ngăn xếp, nhân đôi ToS.
   - Thực hiện trao đổi ba. a, b, c -> c, a, b.
    g - Lấy chiều dài của ToS.
     - Mở rộng danh sách ngắn hơn (chiều cao) tương ứng.
      )} - Gói toàn bộ ngăn xếp vào một danh sách và sắp xếp nó theo:
        нg - Chiều dài của mục đầu tiên của nó.
           `DŠ - Tương tự như trên.
              нg - Độ dài của phần tử đầu tiên.
                € ˜ - Mở rộng danh sách ngắn hơn (theo chiều rộng) tương ứng. 
                    ) ø - Gói ngăn xếp vào một danh sách và hoán vị (zip) nó.
                      € ø - Sau đó nén từng danh sách.
                        O - Áp dụng tổng hợp véc tơ.

3

R , 136 104 103 95 93 byte

Đánh xuống con số khổng lồ 33 35 byte theo lời khuyên của Giuseppe. Được quản lý để có được dưới 100 byte bằng cách sử dụng một toán tử làm tên hàm. Xem lịch sử để biết thêm mã dễ đọc.

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)

Hãy thử trực tuyến!


Tốt đẹp! Tôi đã đánh nó xuống tới 104 byte nhưng sử dụng applyrep.lenlà những gì tôi đã xem xét, mặc dù tôi đã không phải tự mình mã hóa nó.
Giuseppe

@Giuseppe Cảm ơn! Phiên bản 104 không cung cấp đầu ra dự kiến ​​mặc dù.
JayCe

1
Ugh, tôi tiếp tục dẫn bạn lạc lối! cái này sẽ hoạt động
Giuseppe

1
@Giuseppe Yêu thích việc sử dụng dim, sạch sẽ hơn nhiều và mở ra cơ hội khái quát hóa đa chiều với các cuộc gọi đệ quy đếnr
JayCe

Tôi đã cố gắng sử dụng outer(x,y,"+")trong đó có tất cả các khoản tiền đúng, và trong một mô hình rõ ràng. Không thể tìm ra cách giải nén chúng một cách hiệu quả.
ngm


2

05AB1E , 18 byte

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

Hãy thử trực tuyến!

Giải trình

é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

2

Bình thường, 24 byte

KeSmlhdQmm+Fm@@bdkQKeSlM

Hãy thử nó ở đây

Giải trình

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 byte

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;}

Hãy thử trực tuyến.

Giải trình:

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

Python 2 , 124 116 byte

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

Hãy thử trực tuyến!

Giải trình:

Lấy danh sách hai danh sách 2-d làm đầu vào.

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

Tôi lấy ý tưởng từ cả hai giải pháp của chúng tôi và giảm xuống còn 105 byte . Tôi đã phải sử dụng Python 2 và tôi đã nhận được thủ thuật nhân từ mã của bạn, vì vậy sẽ không cảm thấy đúng khi cập nhật câu trả lời của tôi :)
etene

1
@etene Bạn nên đăng nó, đó là giải pháp tốt!
Xác chết vào

Chết tiệt, lỗi khá ngu ngốc về phía tôi, cảm ơn bạn (một lần nữa)!
etene

1
@etene Chỉ cần lưu ý, giải pháp này có vấn đề với 2 và 6 trường hợp thử nghiệm. Cần xóa các tài liệu tham khảo đã sao chép
Dead Possum

1
@etene Quay lại 105 byte : C
Dead Possum

2

Python 2 , 101 97 105 byte

Chỉnh sửa: Cảm ơn (một lần nữa!) Cho Dead Possum vì đã lưu 4 byte

Chỉnh sửa 2: mất 8 byte, một số trường hợp kiểm tra không vượt qua

Một sự pha trộn giữa giải pháp trước đó của Dead Possum (nhờ anh ấy!) Và giải pháp Python 3 của riêng tôi .

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

Hãy thử trực tuyến!

Đầu vào giống như giải pháp Python 3 của tôi (một cặp danh sách 2 chiều).

Mã nhận xét:

# 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

1

Julia 0,6 , 85 83 byte

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

Hãy thử trực tuyến!

(Thay thế bằng \lời cảm ơn đến Jo King )

Hoạt động bằng cách lặp lại từng ma trận theo chiều ngang và chiều dọc để cả hai đều có cùng kích thước (sản phẩm có kích thước hàng x sản phẩm có kích thước cột), thêm chúng vào và trích xuất vùng chính xác từ đó. (Đầu vào vectơ hàng hoặc đầu vào vectơ cột cần một reshapelệnh gọi được gọi là mảng 2 chiều, điều mà tôi cho là ổn vì câu hỏi chỉ rõ "Thực hiện bổ sung cho mảng hai chiều" và "Có thể thực hiện đầu vào và đầu ra phương tiện hợp lý. Định dạng của chúng linh hoạt như bình thường. ")

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.