Jam jangan tambahkan seperti itu

16

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

Dennis
sumber
Bagaimana jika bahasa kita tidak mendukung array kasar? Apakah kami diizinkan merestrukturisasi input atau haruskah kami mengimplementasikan array yang tidak rata? Atau mungkin hanya menggunakan bahasa yang berbeda?
mil
Apa yang Anda maksud dengan merestrukturisasi input ?
Dennis
Dalam pemikiran lebih lanjut, saya menyadari itu tidak akan berhasil untuk merestrukturisasi input tetapi bagaimanapun saya akan meringkas apa yang saya maksud sebelumnya. Saya berpikir tentang menggunakan nilai isian ke pad, yang akan menghilangkan beberapa pekerjaan tetapi juga membuat masalah yang berbeda (mungkin berbeda dari pertanyaan yang Anda maksudkan) tetapi sekarang sadari bahwa kasus uji Anda menyertakan angka negatif juga.
mil
Array juga mungkin heterogen, jadi nilai isi tidak cukup untuk membuatnya menjadi empat persegi panjang. Sebagai upaya terakhir, selalu ada opsi untuk beroperasi pada string, tapi itu mungkin terlalu rumit.
Dennis
3
Hei, judul yang bagus! .. sekarang Google membantu saya mendapatkannya :-)
Luis Mendo

Jawaban:

3

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.
isaacg
sumber
7

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.
marinus
sumber
3
Terkadang saya pikir saya tahu APL oke. Kemudian saya melihat sebuah mahakarya seperti ini dan saya menyadari bahwa saya hampir tidak tahu sama sekali.
Alex A.
Apakah karakter APL benar-benar dihitung sebagai byte?
metalim
@metalim APL memiliki halaman kode lama yang ada sebelum Unicode beberapa dekade. Di dalamnya, setiap karakter adalah satu byte.
Dennis
Maka jenis pengkodean harus disediakan dengan solusi. Hanya IMO.
metalim
@metalim Saya menambahkan tautan.
Adám
5

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.

Martin Ender
sumber
5

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]]]]".

Lynn
sumber
Saya baru saja memperbaikinya juga ^^ (Saya telah bertukar garis untuk keterbacaan, tapi saya melakukannya dengan cara yang salah ...) Itu importkarena Ideone memiliki kompiler Haskell lama. Versi modern dari GHC dimasukkan <$>dalam Prelude, sehingga Anda tidak perlu impor Control.Applicativeuntuk menggunakannya hari ini.
Lynn
Agh terlalu banyak pengeditan pada saat yang sama dengan tindakan saya yang lain: P Dan tentu saja, sepertinya oke sekarang, tapi saya merasa cukup aneh bahwa itu menyebabkan kesalahan kompilasi. Apakah semua bit pencocokan pola suatu fungsi harus berurutan?
FryAmTheEggman
Benar sekali.
Lynn
Baiklah, terima kasih atas semua bantuan Anda :) "Saya akan memahami bahasa ini suatu hari nanti" - FryAmTheEggman 7 tahun yang lalu.
FryAmTheEggman
4

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.

Nilai Tinta
sumber
Itu mengesankan.
Dennis
Saya pikir jika Anda mengganti loop Anda dengan foreach loop melalui array char yang diperoleh dari string, Anda bisa menghemat banyak byte.
user902383
1
Errr ... Java mendukung array kasar; Saya tidak yakin apa yang Anda maksud dengan itu. MenggunakanObject[] , yang berisi bersarang Object[]atau Integer. Atau hanya Daftar non-generik.
Robert Fraser
4

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]
Biru
sumber
Bahkan lebih pendek untuk beralih ke Python 2.7 dan menulisz==[]or`z`>']'and ...
Lynn
Juga, saya pikir mengganti max(d(a)+1for a in z)dengan -~max(d(a)for a in z)menghemat satu byte (karena Anda dapat menghapus ruang sebelumnya max). Yang kemudian adil -~max(map(d,z)).
Lynn
Beralih ke python 2 menghemat bahkan lebih dalam bahwa Anda dapat mengubah [p(a,b)for a,b in zip(x,y)]menjadi map(p,x,y). Anda masih dapat melakukan ini dalam 3 tetapi Anda harus menambahkan panggilan ke list. Saya pikir Anda juga bisa meningkatkan saran Lynn menjadi z>=[]. Tidak terkait, Anda juga harus dapat menukar typeurutan perbandingan untuk menghemat ruang.
FryAmTheEggman
Err, maksud saya or`z`>'[', tentu saja, tetapi saya tidak dapat mengubah komentar saya lagi. Tetapi memang, z>[]bahkan lebih pendek ( ==kasus ini sudah ditangani)!
Lynn
Peta @FryAmTheEggman tidak berfungsi ketika daftar memiliki ukuran yang berbeda; zip terpotong dengan benar. Saya akan memperbarui dengan daftar periksa tho
Blue
3

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.

Dennis
sumber
1

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>

Neil
sumber
1

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]]}
Nilai Tinta
sumber
Itu sangat menarik - Saya belum pernah melihat kesalahan itu sebelumnya untuk fungsi ini. Saya masih memperbaiki beberapa hal karena bug lain sekarang, tetapi selain itu berfungsi untuk saya (tetapi masih gagal pada ideone). Saya pikir itu karena ideone menjalankan 2.1 dan saya memiliki 2.3, jadi mungkin 2.1 tidak bisa hanya mappada fungsi dua-arg cara saya mengaturnya di akhir. Berikut adalah versi yang diedit untuk 2.1 yang berfungsi yang mengubah mappanggilan di akhir bekerja. ideone.com/q1jqTA
Nilai Tinta
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 .

Dennis
sumber