Latar Belakang

Atom aritmatika Jelly melakukan vektorisasi secara otomatis. Faktanya, x + y didefinisikan dengan baik setiap kali x dan y adalah angka atau array angka yang kasar. Kode sumber Jelly mengimplementasikan perilaku ini menggunakan vektorizer generik, tetapi untuk tantangan ini, kami hanya akan mempertimbangkan penambahan integer dan array integer bersarang.

Definisi

Tentukan kedalaman x sebagai 0 jika x adalah bilangan bulat, sebagai 1 jika itu adalah array datar (mungkin kosong) dari bilangan bulat, dan sebagai n + 1 jika berisi setidaknya satu elemen kedalaman n dan tidak ada elemen kedalaman k> n .

Dengan cara ini, 1 memiliki kedalaman 0 , [] dan [1] dan [1, 1] memiliki kedalaman 1 , [[], []] dan [[1], [1]] dan [[1]] dan [1] , []] memiliki kedalaman 2 , [1, [1, [1]]] memiliki kedalaman 3 , dll.

Operasi x + y didefinisikan sebagai berikut.

1. Jika x dan y memiliki kedalaman 0 , kembalikan jumlahnya.

2. Jika x dan y memiliki kedalaman yang sama tetapi positif, terapkan secara + untuk semua item x dan item yang sesuai dari y .

   Jika x dan y memiliki panjang yang berbeda, tambahkan ekor array yang lebih panjang ke array jumlah.

   Kembalikan hasilnya.

3. Jika kedalaman x benar-benar lebih kecil dari kedalaman y , terapkan secara rekursif + ke x dan semua item y , dan kembalikan hasilnya.

   Lakukan sebaliknya jika kedalaman y benar-benar lebih kecil dari x .

Misalnya, pertimbangkan operasi [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] .

• Kedalaman argumen kiri adalah 2 , sedangkan kedalaman argumen kanan adalah 3 , jadi kami menghitung [1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ] dan [1, [2, 3], [4]] + 60 .

  • [1, [2, 3], [4]] dan [[10, 20], [30], 40, 50] keduanya memiliki kedalaman 2 , jadi kami menghitung 1 + [10, 20] , [2, 3] + [30] dan [4] + 40 .

    • 1 + [10, 20] = [1 + 10, 1 + 20] = [11, 21]

    • [2, 3] + [30] = [2 + 30, 3] = [32, 3]

      Perhatikan bahwa 3 tetap tidak tersentuh, karena tidak memiliki elemen yang cocok.

    • [4] + 40 = [4 + 40] = [44]

    
    50 tidak memiliki unsur yang cocok, sehingga hasilnya adalah [[[11, 21], [32, 3], [44], 50]] .

  • [1, [2, 3], [4]] + 60 = [1 + 60, [2, 3] + 60, [4] + 60] = [61, [2 + 60, 3 + 60], [ 4 + 60]] , menghasilkan [61, [62, 63], [64]] .

• Hasil akhirnya adalah [[[11, 21], [32, 3], [44], 50], [61, [62, 63], [64]]] .

Tugas

Tulis program atau fungsi yang mengambil dua bilangan bulat, dua array bertumpuk dari bilangan bulat atau kombinasi keduanya sebagai input dan mengembalikan jumlah mereka, sebagaimana didefinisikan di atas.

Jika bahasa Anda memiliki beberapa jenis seperti array (daftar, tupel, vektor, dll.) Anda dapat memilih salah satu dari mereka untuk jawaban Anda. Jenis kembali harus cocok dengan jenis argumen.

Untuk mencegah solusi yang membosankan dan tidak ada duanya, jika suatu bahasa memiliki ketepatan ini operasi yang sebagai bawaan, Anda mungkin tidak menggunakan bahasa itu.

Semua bawaan dari semua bahasa lain diizinkan. Jika bahasa pilihan Anda mengizinkan ini, Anda mungkin kelebihan beban dan / atau mendefinisikan ulang penambahan bawaan.

Ini adalah kode-golf , jadi kode terpendek dalam byte menang.

Uji kasus

0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]

Untuk menghasilkan lebih banyak kasus uji, Anda dapat menggunakan program Jelly ini .

Pyth, 42 byte

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

Suite uji

4 byte terakhir cukup menjalankan fungsi pada input.

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

L?sIb0heSyM+b0
                  Define y(b), a helper function to calculate the depth.
 ?                Ternary:
  sIb             If b is invariant under the s function, which is only the case
                  if s is an int.
     0            The depth is 0.
           +b0    Add a 0 on to b. This handles the edge case where b is [].
         yM       Map each to their depth
       eS         Take the max.
      h           Add one.

M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ
M                               Define g(G, H), which calculates the Jelly +.
 ?                              Ternary:
       ,GH                      Form [G, H].
      J                         Save it to J.
    yM                          Map each to its depth.
  qF                            Check if they are equal.
          ?yG                   If so, check if the depth is nonzero.
               .tJ0             If so, transpose J, pairing each element of each
                                argument with the corresponding element of the
                                other. Pad with zeroes.
             gM                 Map each to its Jelly +.
                   +GH          If the depths are zero, return the normal sum.
                         yDJ    If the depths are different, order J by depth.
                      gLF       Apply the function which left-maps the Jelly +
                                function to the two values. The first is
                                treated as a constant, while the second varies
                                over elements over the second values.

APL, 44 byte

{1=≡⍺⍵:⍺+⍵⋄=/∆←|≡¨⍺⍵:⊃∇¨/↓↑⍺⍵⋄</∆:⍺∘∇¨⍵⋄⍵∇⍺}

APL juga +mendistribusikan melalui array, tetapi dengan cara yang cukup berbeda sehingga ini tidak dapat digunakan. Namun, ada fungsi kedalaman bawaan (≡ ).

Penjelasan:

• 1=≡⍺⍵:⍺+⍵: jika kedalaman ⍺ ⍵keduanya nol (dan oleh karena itu kedalaman ⍺ ⍵1), tambahkan.
• ∆←|≡¨⍺⍵: ambil yang absolut dari kedalaman keduanya ⍺dan ⍵dan simpan di ∆. ( ≡memberikan nilai negatif jika tidak semua elemen memiliki kedalaman yang sama.)
• =/∆: jika mereka memiliki kedalaman yang sama:
  • ↓↑⍺⍵: pad array terpendek dengan nol untuk mencocokkan array yang lebih panjang
  • ⊃∇¨/: mendistribusikan fungsi melalui kedua array
• </∆: jika kedalaman ⍺kurang dari itu dari ⍵:
  • ⍺∘∇¨⍵: ikat ⍺dan kemudian petakan⍵
• ⍵∇⍺: jika tidak ada yang lain (jadi ⍵lebih dalam dari ⍺), tukar argumen dan coba lagi.

Mathematica, 122 byte

d=Depth
x_~f~y_/;d@x>d@y:=y~f~x
x_~f~y_/;d@x<d@y:=x~f~#&/@y
x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]
x_~f~y_=x+y

Menentukan fungsi rekursif fyang menghitung jumlah. Memanfaatkan pencocokan pola Mathematica, fungsi ini terdiri dari empat definisi yang terpisah:

x_~f~y_/;d@x>d@y:=y~f~x

Jika kedalaman xlebih besar dari itu y, bertukar argumen sehingga kita hanya perlu menangani distribusi dalam satu arah (yang bisa kita lakukan, karena penambahan bersifat komutatif).

x_~f~y_/;d@x<d@y:=x~f~#&/@y

Jika kedalaman xkurang thann bahwa y, menggantikan setiap nilai #di ydengan f[x,#], yang mengurus distribusi untuk argumen yang tidak setara mendalam.

x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]

Kalau tidak, jika satu argumen adalah daftar (yang menyiratkan bahwa yang lain juga adalah daftar, karena kita tahu mereka memiliki kedalaman yang sama), kita menempatkan kedua argumen dalam daftar, pad dengan panjang yang sama PadRight[..., Automatic](yang hanya mengisi sebuah array kasar dengan nol untuk membuatnya persegi panjang), dan kemudian gunakan MapThreaduntuk menerapkan fke pasangan yang sesuai dari dua daftar.

Dan akhirnya, kasus dasar:

x_~f~y_=x+y

Jika tidak ada pola lain yang cocok, kita harus mencoba menambahkan dua angka, jadi kita lakukan saja.

Haskell, 150 byte

data L=S Int|V{v::[L]}
d(V z)=1+maximum(d<$>S 0:z);d _=0
S x!S y=S$x+y
x!y|d x<d y=V$(x!)<$>v y|d x>d y=y!x|1<2=V$v x#v y
(x:a)#(y:b)=x!y:a#b;a#b=a++b

Penjelasan

Baris pertama mendefinisikan tipe data aljabar L, yang dapat berupa Scalar (mengandung a Int) atau Vector (berisi daftar Ls, diakses menggunakan record pengambil v, yang merupakan fungsi parsial L → [L].)

Baris kedua mendefinisikan fungsi kedalaman : kedalaman Vektor adalah satu ditambah kedalaman maksimumnya. Saya menambahkan S 0ke nilai-nilai dalam vektor, sehingga depth [] == 1 + maximum [depth (S 0)] == 1. Kedalaman "apa pun" (skalar) adalah0 .

Baris ketiga mendefinisikan case dasar untuk !(fungsi penjumlahan): jumlah skalar hanyalah skalar.

Baris kelima mendefinisikan varian zipWith (!)yang hanya mengambil elemen dari daftar terpanjang ketika salah satunya kosong.

Baris keempat terbagi dalam tiga kasus:

x!y | d x<d y = V$(x!)<$>v y
    | d x>d y = y!x
    | True    = V$v x#v y

• Jika kedalaman xbenar-benar kurang dari kedalaman y, petakan di (x!)atas elemeny . (Penggunaan vdijamin valid, seperti d(y) ≥ 1.)

• Jika kedalaman xbenar-benar lebih besar, balik argumen dan mulai ulang.

• Jika kedalamannya sama, masukkan argumen bersama (!). (Penggunaan vdijamin valid, seperti kasusnyad(x) = d(y) = 0 ini ditangani sebagai kasus dasar.)

Uji kasus

instance Show L where
  show (S x) = show x
  show (V x) = show x

lArg = V [S 1, V [S 2, V [S 3, V [S 4]]]]
rArg = V [S 10, V [S 20]]

Lalu show (lArg ! rArg) == "[[11,[21]],[[12,[22]],[13,[24]]]]".

Jawa, 802 794 754 746 byte

Saya memutuskan untuk mengambil @ Dennis ♦ untuk tantangan untuk beroperasi pada string "sebagai pilihan terakhir" karena itu mungkin "terlalu rumit". Juga, dalam bahasa terburuk untuk bermain golf.

Array dalam input dipisahkan oleh koma, dikelilingi dengan tanda kurung siku, dan tanpa spasi putih.

Program penuh dengan fungsi yang dibungkus ke dalam kelas dan dengan kasus uji

import java.util.*;
List<String>p(String s){List r=new ArrayList<String>();String p="";int l=0;for(char c:s.substring(1,s.length()-1).toCharArray()){l+=c=='['?1:c==']'?-1:0;if(c==','&&l<1){r.add(p);p="";}else p+=c;}if(p!="")r.add(p);return r;}
int d(String s){int l=0;if(s.contains("[")){for(String c:p(s))l=d(c)>l?d(c):l;l++;}return l;}
String f(String x,String y){int i=0;String r="";if(d(x)<1&&d(y)<1)r+=Integer.valueOf(x)+Integer.valueOf(y);else{r="[";if(d(x)<d(y))for(String k:p(y))r+=(i++<1?"":",")+f(x,k);else if(d(x)>d(y))for(String k:p(x))r+=(i++<1?"":",")+f(k,y);else for(;i<p(x).size()||i<p(y).size();i++)r+=(i<1?"":",")+(i<p(x).size()&&i<p(y).size()?f(p(x).get(i),p(y).get(i)):i<p(x).size()?p(x).get(i):p(y).get(i));r+="]";}return r;}

Saya mungkin port ini ke C + + kemudian karena itu bahasa lain yang saya tahu yang tidak mendukung array kasar, karena saya cukup yakin hampir pasti akan lebih pendek dari jawaban ini. Ini sebagian besar merupakan bukti konsep tetapi tips golf masih akan dihargai!

-31 byte dari @ user902383 menyarankan menggunakan foreach melalui array karakter yang dikonversi, dan kemudian saya menyimpan sedikit lebih banyak dari mengatur ulang blok if di bagian akhir.

Python 2.7, 261 209 202 198 191 185 197 181 byte

Solusi sepele FGITW

EDIT: Tentu saja @ Dennis mengalahkan itu

Terima kasih kepada @LeakyNun karena menyimpan 57 byte dengan tips tentang ekspresi lambda, dan 2 byte dari tanda kurung yang tidak dibutuhkan.

Terima kasih kepada @Adnan untuk 4 byte karena saran untuk digunakan, typebukanisinstance

Terima kasih kepada @Lynn selama 7 byte dengan -~danmap

Terima kasih kepada @FryAmTheEggman untuk z>=[]alih - alihtype

+12 byte untuk mengonversi lambda menjadi if else dan memperbaiki bug utama

-16 byte terima kasih kepada @Kevin Lau - bukan Kenny

Cobalah online

d=lambda z:z==[]or z>[]and-~max(map(d,z))
p=lambda x,y:p(y,x)if d(x)>d(y)else(x+y if d(x)<1 else[p(a,b)for a,b in zip(x,y)]+x[len(y):]+y[len(x):])if d(x)==d(y)else[p(a,x)for a in y]

Python 2, 145 136 byte

d=lambda t:t>{}and-~max(map(d,t+[0]))
s=lambda x,y:s(y,x)if d(y)<d(x)else map(s,(x,[x]*len(y))[d(x)<d(y)],y)if d(y)else(x or 0)+(y or 0)

Uji di Ideone .

Bagaimana itu bekerja

Dalam Python 2, semua bilangan bulat kurang dari semua kamus, tetapi semua daftar lebih besar. d secara rekursif menghitung kedalaman t dengan mengembalikan 0 untuk bilangan bulat atau maksimum peningkatan kedalaman elemen-elemennya dan 0 . t+[0]menghindari casing khusus daftar kosong.

Secara rekursif menghitung jumlah Jelly x dan y .

Jika kedalaman y melebihi x , s(y,x)panggil s dengan argumen bertukar, pastikan bahwa d (x) ≤ d (y) .

Jika y memiliki kedalaman positif, map(s,(x,[x]*len(y))[d(x)<d(y)],y)lakukan hal berikut.

• Jika x 'dan y ' s kedalaman cocok, dijalankan map(s,x,y), pemetaan s atas seluruh elemen x dan unsur-unsur yang sesuai y .

  Dalam hal daftar dengan panjang yang berbeda, peta akan melewatkan None sebagai argumen kiri atau kanan untuk elemen yang hilang dalam daftar yang lebih pendek.

• Jika kedalaman x lebih rendah dari y , itu dijalankan map(s,[x]*len(y),y), memetakan (x, ·) di atas y .

Jika y (dan, oleh karena itu, x ) memiliki kedalaman 0 , (x or 0)+(y or 0)menggantikan argumen falsy ( Tidak ada atau 0 ) dengan nol dan mengembalikan jumlah bilangan bulat yang dihasilkan.

JavaScript (ES6), 152 byte

f=(a,b,g=a=>a.map?1+Math.max(0,...a.map(g)):0)=>g(a)<g(b)?f(b,a):g(b)<g(a)?a.map(e=>f(e,b)):g(a)?a.length<b.length?f(b,a):a.map((e,i)=>f(e,b[i]||0)):a+b
;t=(x,y,z)=>o.textContent+=`
${JSON.stringify(x)}
${JSON.stringify(y)}
${JSON.stringify(z)}
${JSON.stringify(f(x,y))}
`;`
0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]`.slice(1).split`
`.map(l=>t(...l.split(/ [+=] /).map(a=>JSON.parse(a))));

<pre id=o></pre>

Ruby 2.3, 143 145 148 149 byte

Ruby memiliki semua keanehan kecil ini dalam cara zipkerjanya dengan array panjang yang berbeda dan mapdengan fungsi multi-argumen, membuat ini cukup menyenangkan untuk bermain golf.

f=->x,y{d=->a{-~(a.map(&d).max||0)rescue 0}
d[x]<d[y]?y.map{|e|f[x,e]}:d[x]>d[y]?x.map{|e|f[e,y]}:d[x]<1?x+(y||0):[*x.zip(y).map(&f),*y[x.size..-1]]}

Julia, 113 byte

~=endof;!t=0t!=0&&1+maximum(!,[t;0])
x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

Cobalah online!

Bagaimana itu bekerja

~=endof

membuat alias 1-byte untuk endof , yang mengembalikan panjang array.

!t=0t!=0&&1+maximum(!,[t;0])

mendefinisikan fungsi kedalaman. Kedalaman t adalah nol jika dan hanya jika 0t == 0 . Jika tidak, t adalah array, dan kedalamannya dihitung sebagai penambahan maksimum dari kedalaman elemen-elemennya dan 0 . [t;0]menambahkan 0 ke array t , sehingga menghindari kebutuhan untuk huruf khusus array kosong.

Jumlah bawaan Julia + sudah berlaku seperti jumlah Jelly jika salah satu (atau keduanya) dari argumennya adalah bilangan bulat. Namun, jumlah dua array ( + ) membutuhkan array dengan bentuk yang sama, dan bahkan jumlah vektor ( . + ) Diperlukan array yang dapat disiarkan ke bentuk umum.

Kami mendefinisikan ulang + untuk sepasang array melalui

x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

Ini tidak mempengaruhi definisi + untuk argumen integer / integer, array / integer atau integer / array.

(!x,~x)>(!y,~y)Secara leksikografis membandingkan pasangan kedalaman dan panjang x dan y . Jika kedalaman x melebihi y , atau jika kedalamannya cocok dan panjang x melebihi y , maka y+xpanggilan + berulang dengan argumen bertukar.

Kalau tidak, !x<!ytes apakah kedalaman x lebih rendah dari y . Jika memang,map(t->x+t,y) petakan x + · over y .

Jika kedalamannya cocok, ~x<~yuji apakah x lebih pendek dari y . Jika ya, [x;0]+ypanggilan + secara rekursif setelah menambahkan a 0 ke argumen kiri.

Akhirnya, jika kedua kedalaman dan panjangnya identik, x.+ypeta + seluruh elemen x dan elemen terkait y .