Tantangan ini terkait dengan beberapa fitur bahasa MATL, sebagai bagian dari acara Bahasa Bulan Mei 2018 .

pengantar

Dalam MATL, banyak fungsi dua-input berfungsi elemen dengan siaran . Ini berarti yang berikut:

• Elemen-bijaksana (atau vektor ): fungsi mengambil input dua array dengan ukuran yang cocok. Operasi yang ditentukan oleh fungsi diterapkan pada setiap pasangan entri yang sesuai. Misalnya, menggunakan notasi pasca-perbaikan:

  [2 4 6] [10 20 30] +
  

  memberikan ouput

  [12 24 36]
  

  Ini juga berfungsi dengan array multi-dimensi. Notasi [1 2 3; 4 5 6]mewakili 2× 3array (matriks)

  1 2 3
  4 5 6
  

  yang memiliki ukuran 2sepanjang dimensi pertama (vertikal) dan 3sepanjang dimensi kedua (horizontal). Jadi misalnya

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

  memberi

  [20 80 180; 120 300 560]
  

• Broadcasting or ( ekspansi tunggal ): dua array input tidak memiliki ukuran yang cocok, tetapi di setiap dimensi yang tidak cocok salah satu array memiliki ukuran 1. Array ini secara implisit direplikasi sepanjang dimensi lain untuk membuat ukuran cocok; dan kemudian operasi diterapkan berdasarkan elemen seperti di atas. Misalnya, pertimbangkan dua larik masukan dengan ukuran 1× 2dan 3× 1:

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

  Berkat penyiaran, ini setara dengan

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

  dan itu memberi

  [10 20; 5 10; 2 4]
  

  Demikian pula, dengan ukuran 3× 2dan 3× 1(penyiaran sekarang hanya berfungsi sepanjang dimensi kedua),

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

  memberi

  [19 18; 27 26; 35 34]
  

  Jumlah dimensi bahkan mungkin berbeda. Misalnya, input dengan ukuran 3 × 2 dan 3 × 1 × 5 kompatibel, dan memberikan hasil 3 × 2 × 5. Bahkan, ukuran 3 × 2 adalah sama dengan 3 × 2 × 1 (ada banyak dimensi trailing tunggal implisit yang sewenang-wenang).

  Di sisi lain, sepasang 2× 2dan 3× 1array akan memberikan kesalahan, karena ukuran sepanjang dimensi pertama adalah 2dan 3: mereka tidak sama dan tidak satupun dari mereka adalah 1.

Definisi penyiaran modular

Penyiaran modular adalah generalisasi penyiaran yang berfungsi meskipun tidak ada ukuran yang tidak cocok 1. Pertimbangkan misalnya 2× 2dan 3× 1array berikut sebagai input dari fungsi +:

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

Aturannya adalah sebagai berikut: untuk setiap dimensi, larik yang lebih kecil di sepanjang dimensi itu direplikasi secara modular (secara siklik) agar sesuai dengan ukuran larik lainnya. Ini akan membuat setara dengan di atas

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

dengan hasilnya

[12 14; 26 28; 32 34]

Sebagai contoh kedua,

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

akan menghasilkan

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

Secara umum, input dengan ukuran a× bdan c× dmemberikan hasil ukuran max(a,b)× max(c,d).

Tantangan

Terapkan penambahan untuk array dua dimensi dengan penyiaran modular seperti yang didefinisikan di atas.

Array akan berbentuk persegi panjang (tidak kasar), hanya akan berisi bilangan bulat non-negatif , dan akan memiliki ukuran setidaknya1 di setiap dimensi.

Aturan tambahan:

• Input dan output dapat diambil dengan cara apa pun yang wajar . Formatnya fleksibel seperti biasa.

• Program atau fungsi diizinkan, dalam bahasa pemrograman apa pun . Celah standar dilarang .

• Kode terpendek dalam byte menang.

Uji kasus

Berikut ini digunakan ;sebagai pemisah baris (seperti pada contoh di atas). Setiap test case menunjukkan dua input dan kemudian 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]

Jelly , 10 byte

ṁ€ZL$Z€Ɗ⁺S

Mengambil pasangan matriks (dua array baris) sebagai input dan mengembalikan matriks.

Cobalah online!

Bagaimana itu bekerja

ṁ€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.

Arang , 25 23 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil input sebagai array 3 dimensi. Penjelasan:

Ａθ

Masukkan semuanya.

    θ                   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

MATL , 25 24 byte

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

Cobalah online!

Akhirnya! Hanya butuh satu minggu untuk tantangan yang terinspirasi oleh Bahasa Bulan ini untuk dijawab oleh Bahasa Bulan ini!

Dugaan saya adalah bahwa ini tidak sesingkat mungkin, tapi saya cukup senang karena versi awal saya lebih dari 40 byte. sunting: Saya benar, Luis menemukan byte lain untuk dimatikan!

,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

Python 3 , 127 126 125 byte

golf byte dengan mengubah sum(m)kem+n

Satu byte lagi berkat @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))))

Mengambil input sebagai daftar dua array 2 dimensi.

• The Zlambda mengambil dua array sebagai masukan dan mengembalikan sebuah iterator menghasilkan indeks dan digabung nilai-nilai dari kedua array, sampai indeks mencapai panjang array terbesar ini. Variabel indeks tidak berguna bagi saya dan saya biaya byte, tapi saya tidak tahu bagaimana melakukannya tanpa itu ... ( terkait )
• Lambda utama hanya mengambil array input dan memanggil array Zluar dan dalam. Nilai-nilai terdalam ditambahkan bersama.

Cobalah online!

Menggunakan itertools.cycleterasa agak seperti curang tapi saya pikir saya sudah cukup dihukum dengan panjangnya pernyataan impor :)

Saya yakin ini bisa golf lagi, terutama metode iterasi yang membuat variabel idan tidak berguna ini j. Saya akan berterima kasih atas tips bagaimana golf itu, saya mungkin kehilangan sesuatu yang jelas.

JavaScript (ES6), 131 byte

Bukan alat yang tepat untuk pekerjaan itu, dan mungkin juga bukan pendekatan yang tepat. Oh 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)))

Cobalah online!

Bagaimana?

Fungsi helper g () membuat array yang sebesar array input terbesar ( a atau b ) dan memanggil fungsi callback c di atasnya:

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

Fungsi helper h () membaca 2D-array a at (x, y) dengan penyiaran modular:

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

Kode utama sekarang cukup dibaca sebagai:

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

Versi rekursif, 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)

Cobalah online!

05AB1E , 15 byte

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

Cobalah online!

Versi lama, 25 byte

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

Cobalah online!

Penjelasan

15-byter:

2FεIζg∍ø] øεø¨} O - Program lengkap. Mengambil input sebagai daftar [A, B] 3D dari STDIN.
2F - Mendaftar dua kali:
  ε - Untuk masing-masing dalam [A, B]:
   Iζ - Transpose input (mengisi celah dengan spasi).
     g - Panjang (mengambil jumlah baris).
      ∍ - Perpanjang item saat ini (A atau B) dengan panjang yang diperlukan.
       ø - Transpose.
        ] - Tutup semua loop.
         ø - Transpos lagi.
          ε - Untuk setiap baris dalam ^ (kolom hasil loop):
           ø - Ubah posisi kolom.
            ¨} - Hapus elemen terakhir dan tutup loop peta.
              O - Jumlah.

25-byter:

é`DŠg∍) Σнg} `DŠнgδ∍ € ˜) ø € øO - Program lengkap. Mengambil input sebagai daftar 3D dari STDIN.
é - Urutkan daftar menurut panjangnya.
 `D - Membuang konten secara terpisah ke tumpukan, menduplikasi ToS.
   Š - Melakukan triple swap. a, b, c -> c, a, b.
    g - Dapatkan panjang ToS.
     ∍ - Perpanjang daftar yang lebih pendek (tingginya) sesuai.
      ) Σ} - Bungkus seluruh tumpukan ke dalam daftar dan urutkan berdasarkan:
        нg - Panjang item pertama.
           `DŠ - Sama seperti di atas.
              нg - Panjang elemen pertama.
                δ∍ € ˜ - Perpanjang daftar yang lebih pendek (lebar) sesuai. 
                    ) ø - Bungkus tumpukan ke dalam daftar dan transpos (zip) itu.
                      € ø - Kemudian poskan setiap daftar.
                        O - Terapkan penjumlahan vektor.

R , 136 104 103 95 93 byte

Golf turun 33 35 byte mengikuti saran Giuseppe. Berhasil mendapatkan di bawah 100 byte dengan menggunakan operator sebagai nama fungsi. Lihat riwayat untuk kode yang lebih mudah dibaca.

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)

Cobalah online!

K (ngn / k) , 23 byte

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

Cobalah online!

05AB1E , 18 byte

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

Cobalah online!

Penjelasan

é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

Pyth, 24 byte

KeSmlhdQmm+Fm@@bdkQKeSlM

Coba di sini

Penjelasan

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.

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

Cobalah online.

Penjelasan:

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

APL (Dyalog Classic) , 23 21 byte

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

Cobalah online!

ini bisa menjadi satu-satunya waktu saya mendapatkan kesempatan untuk menggunakan |[0]

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

Cobalah online!

Penjelasan:

Mengambil daftar dua daftar 2-d sebagai input.

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

Python 2 , 101 97 105 byte

Sunting: Terima kasih (lagi!) Ke Dead Possum karena menyimpan 4 byte

Sunting 2: kehilangan 8 byte, beberapa kasus uji tidak lulus

Gabungan antara solusi Dead Possum sebelumnya (terima kasih padanya!), Dan solusi Python 3 saya sendiri .

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

Cobalah online!

Masukan yang sama dengan solusi Python 3 saya (sepasang daftar 2 dimensi).

Kode yang dikomentari:

# 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

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

Cobalah online!

(Ganti ⧻dengan \terima kasih kepada Jo King )

Bekerja dengan mengulangi setiap matriks secara horizontal dan vertikal sehingga mereka berdua memiliki ukuran yang sama (produk ukuran baris x produk ukuran kolom), menambahkan mereka ke atas dan mengekstraksi keluar daerah yang benar dari itu. (Input vektor baris atau input vektor kolom perlu reshapepanggilan untuk dilemparkan sebagai array 2 dimensi, yang saya asumsikan baik-baik saja karena pertanyaannya menentukan "Menerapkan penambahan untuk array dua dimensi" dan "Input dan output dapat diambil oleh cara yang masuk akal. Format mereka fleksibel seperti biasa. ")