Hintergrund

Jellys arithmetische Atome werden automatisch vektorisiert. Tatsächlich ist x + y immer dann gut definiert, wenn x und y Zahlen oder zerlumpte Anordnungen von Zahlen sind. Jellys Quellcode implementiert dieses Verhalten mithilfe eines generischen Vektorisierers. Bei dieser Herausforderung werden jedoch nur Ganzzahlen und verschachtelte Ganzzahl-Arrays hinzugefügt.

Definitionen

Definieren Sie die Tiefe von x als 0, wenn x eine Ganzzahl ist, als 1, wenn es sich um ein (möglicherweise leeres) flaches Array von Ganzzahlen handelt, und als n + 1, wenn es mindestens ein Element der Tiefe n und keine Elemente der Tiefe k> enthält n .

Auf diese Weise hat 1 die Tiefe 0 , [] und [1] und [1, 1] die Tiefe 1 , [[], [] und [[1], [1] und [1] und [1] , []] haben die Tiefe 2 , [1, [1, [1]] haben die Tiefe 3 usw.

Die Operation x + y ist wie folgt definiert.

1. Wenn x und y die Tiefe 0 haben , geben Sie ihre Summe zurück.

2. Wenn x und y gleiche, aber positive Tiefen haben, wenden Sie rekursiv + auf alle Elemente von x und die entsprechenden Elemente von y an .

   Wenn x und y unterschiedlich lang sind, hängen Sie das Ende des längeren Arrays an das Array der Summen an.

   Gib das Ergebnis zurück.

3. Wenn die Tiefe von x streng kleiner als die Tiefe von y ist , wenden Sie rekursiv + auf x und alle Elemente von y an und geben Sie das Ergebnis zurück.

   Machen Sie das Gegenteil, wenn die Tiefe von y strikt kleiner als die von x ist .

Betrachten Sie zum Beispiel die Operation [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] .

• Die Tiefe des linken Arguments ist 2 , während die Tiefe des rechten Arguments 3 ist. Wir berechnen also [1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ] und [1, [2, 3], [4]] + 60 .

  • [1, [2, 3], [4]] und [[10, 20], [30], 40, 50] haben beide die Tiefe 2 , also berechnen wir 1 + [10, 20] , [2, 3] + [30] und [4] + 40 .

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

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

      Beachten Sie, dass 3 unberührt bleibt, da es kein passendes Element enthält.

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

    
    50 kein passendes Element hat, so ist das Ergebnis [[[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]] , was zu [61, [62, 63], [64]] führt .

• Das Endergebnis ist [[[11, 21], [32, 3], [44], [50], [61, [62, 63], [64]] .

Aufgabe

Schreiben Sie ein Programm oder eine Funktion, die zwei Ganzzahlen, zwei verschachtelte Arrays von Ganzzahlen oder eine Kombination davon als Eingabe verwendet und deren Summe wie oben definiert zurückgibt.

Wenn Ihre Sprache über mehrere Array-ähnliche Typen verfügt (Listen, Tupel, Vektoren usw.), können Sie einen beliebigen Typ für Ihre Antwort auswählen. Der Rückgabetyp muss mit dem Argumenttyp übereinstimmen.

Um langweilige und unschlagbare Lösungen zu vermeiden , können Sie diese Sprache möglicherweise nicht verwenden , wenn eine Sprache genau diese Funktion aufweist.

Alle eingebauten Sprachen aller anderen Sprachen sind erlaubt. Wenn Ihre Sprache dies zulässt, können Sie den eingebauten Zusatz überladen und / oder neu definieren.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Testfälle

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

Um weitere Testfälle zu generieren, können Sie dieses Jelly-Programm verwenden .

Pyth, 42 Bytes

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

Testsuite

Die letzten 4 Bytes führen einfach die Funktion am Eingang aus.

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 Bytes

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

APLs +verteilen sich ebenfalls über Arrays, jedoch auf eine Weise, die nicht wirklich verwendet werden kann. Es gibt jedoch eine integrierte Tiefenfunktion ( ≡).

Erläuterung:

• 1=≡⍺⍵:⍺+⍵: Wenn die Tiefen von ⍺ ⍵beide Null sind (und daher die Tiefe von ⍺ ⍵1 ist), addieren Sie sie.
• ∆←|≡¨⍺⍵Nehmen Sie die absolute der Tiefe der beiden: ⍺und ⍵und speichern sie in ∆. ( ≡Gibt einen negativen Wert zurück, wenn nicht alle Elemente die gleiche Tiefe haben.)
• =/∆: wenn sie die gleiche Tiefe haben:
  • ↓↑⍺⍵: Fülle das kürzeste Array mit Nullen auf, um es dem längeren Array anzupassen
  • ⊃∇¨/: verteile die Funktion auf beide Arrays
• </∆: Wenn die Tiefe von ⍺geringer ist als die von ⍵:
  • ⍺∘∇¨⍵: binden ⍺und dann übermappen⍵
• ⍵∇⍺: Wenn nichts anderes (also ⍵tiefer als ⍺) ist, tauschen Sie die Argumente aus und versuchen Sie es erneut.

Mathematica, 122 Bytes

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

Definiert eine rekursive Funktion f, die die Summe berechnet. Diese Funktion nutzt die Mustererkennung von Mathematica und besteht aus vier separaten Definitionen:

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

Wenn die Tiefe von xgrößer als die von ist y, tauschen Sie die Argumente aus, damit wir die Verteilung nur in eine Richtung handhaben müssen (was wir tun können, da die Addition kommutativ ist).

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

Wenn die Tiefe von xweniger thann dass der yErsetzen jedes Wert #in ymit f[x,#], die Argumente von ungleichen Tiefen Pflege der Verteilung erfolgt.

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

Wenn andernfalls ein Argument eine Liste ist (was impliziert, dass das andere auch eine Liste ist, da wir wissen, dass sie die gleiche Tiefe haben), fügen wir beide Argumente in eine Liste ein und füllen sie mit der gleichen Länge auf PadRight[..., Automatic](was einfach a ausfüllt) zackiges Array mit Nullen, um es rechteckig zu machen), und MapThreadwenden Sie es dann fauf die entsprechenden Paare aus den beiden Listen an.

Und zum Schluss der Basisfall:

x_~f~y_=x+y

Wenn keines der anderen Muster übereinstimmt, müssen wir versuchen, zwei Zahlen hinzuzufügen, also machen wir das einfach.

Haskell, 150 Bytes

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

Erläuterung

Die erste Zeile definiert einen algebraischen Datentyp L, der entweder ein SKalender (mit einem Int) oder ein VEktor (mit einer Liste von Ls) ist, auf den mit einem Datensatz-Getter zugegriffen wird. Dies vist eine Teilfunktion L → [L].)

Die zweite Linie definiert die Tiefe - Funktion: die Tiefe einer Vector ist eins plus seine maximale Tiefe. Ich stelle S 0den Werten im Vektor voran , damit depth [] == 1 + maximum [depth (S 0)] == 1. Die Tiefe von "irgendetwas anderem" (einem Skalar) ist 0.

Die dritte Zeile definiert den Basisfall für !(die Additionsfunktion): Die Summe der Skalare ist einfach ein Skalar.

Die fünfte Zeile definiert eine Variante, bei der zipWith (!)nur Elemente aus der längsten Liste ausgewählt werden, wenn eines davon leer ist.

Die vierte Zeile ist in drei Fälle aufgeteilt:

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

• Wenn die Tiefe von xgenau kleiner als die Tiefe von ist y, ordnen (x!)Sie die Elemente von zu y. (Die Verwendung von vist garantiert gültig, da d(y) ≥ 1.)

• Wenn die Tiefe von xstrikt größer ist, drehen Sie die Argumente um und starten Sie neu.

• Wenn ihre Tiefen gleich sind, zippen Sie die Argumente zusammen mit (!). (Die Verwendung von vist garantiert gültig, da der Fall d(x) = d(y) = 0als Basisfall behandelt wurde.)

Testfälle

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

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

Java, 802 794 754 746 Bytes

Ich habe mich für @ Dennis ♦ entschieden, um die Herausforderung zu bewältigen, Strings "als letzten Ausweg" zu bearbeiten, weil es wahrscheinlich "zu kompliziert" war. Auch in der schlechtesten Sprache zum Golfen.

Arrays in der Eingabe sind durch Kommas getrennt, in eckigen Klammern und ohne Leerzeichen.

Volles Programm mit Funktionen, die in eine Klasse eingebunden sind, und mit Testfällen

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

Ich könnte dies später nach C ++ portieren, da es sich um die andere Sprache handelt, die keine zerlumpten Arrays unterstützt, da ich mir ziemlich sicher bin, dass sie kürzer als diese Antwort sein wird. Dies war größtenteils ein Proof of Concept, aber Golftipps sind immer noch willkommen!

-31 Bytes von @ user902383, die die Verwendung von foreach über ein konvertiertes Zeichenarray vorschlagen, und dann habe ich ein wenig mehr davon gespart, die if-Blöcke im letzten Teil neu anzuordnen.

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

FGITW triviale Lösung

EDIT: Natürlich schlägt @Dennis es

Vielen Dank an @LeakyNun für das Speichern von 57 Bytes mit Tipps zu Lambda-Ausdrücken und 2 Bytes aus nicht benötigten Klammern.

Vielen Dank an @Adnan für 4 Bytes aufgrund des Vorschlags, typeanstelle von zu verwendenisinstance

Danke an @Lynn für 7 Bytes mit -~undmap

Vielen Dank an @FryAmTheEggman für z>=[]statttype

+12 Bytes, um Lambda in if else umzuwandeln und einen größeren Fehler zu beheben

-16 Bytes dank @Kevin Lau - nicht Kenny

Probieren Sie es online aus

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 Bytes

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)

Teste es auf Ideone .

Wie es funktioniert

In Python 2 sind alle Ganzzahlen kleiner als alle Wörterbücher, aber alle Listen sind größer. d berechnet rekursiv die Tiefe von t, indem es 0 für ganze Zahlen oder das inkrementierte Maximum der Tiefen seiner Elemente und 0 zurückgibt . t+[0]Vermeidet die Sonderanfertigung der leeren Liste.

s berechnet rekursiv die Jelly-Summe von x und y .

Wenn die Tiefe von y die von x überschreitet , s(y,x)ruft s mit vertauschten Argumenten auf und stellt dabei sicher, dass d (x) ≤ d (y) ist .

Wenn y eine positive Tiefe hat, map(s,(x,[x]*len(y))[d(x)<d(y)],y)gilt Folgendes.

• Wenn die Tiefen von x und y übereinstimmen, map(s,x,y)wird s über alle Elemente von x und die entsprechenden Elemente von y abgebildet .

  Im Fall von Listen unterschiedlicher Länge, Karte wird passiert Keine als linkes oder rechtes Argument für Elemente in der kürzeren Liste fehlt.

• Wenn die Tiefe von x geringer als die von y ist , wird es ausgeführt map(s,[x]*len(y),y), indem s (x, ·) über y abgebildet wird .

Wenn y (und daher x ) die Tiefe 0 hat , werden (x or 0)+(y or 0)falsche Argumente ( Keine oder 0 ) durch Nullen ersetzt und die Summe der resultierenden ganzen Zahlen zurückgegeben.

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 Bytes

Ruby hat all diese kleinen Macken darin, wie es zipmit Arrays unterschiedlicher Länge und mapmit Funktionen mit mehreren Argumenten funktioniert, was das Golfspielen zum Vergnügen macht.

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 Bytes

~=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

Probieren Sie es online!

Wie es funktioniert

~=endof

Erstellt einen 1-Byte-Alias ​​für endof , der die Länge eines Arrays zurückgibt.

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

definiert eine Tiefenfunktion. Die Tiefe von t ist genau dann Null, wenn 0t == 0 ist . Wenn nicht, t ein Array und seine Tiefe wird als inkrementiertes Maximum der Tiefen seiner Elemente und 0 berechnet . [t;0]Hängt eine 0 an das Array t an und vermeidet so die Notwendigkeit, das leere Array in Sonderfällen zu behandeln.

Julias eingebaute Summe + verhält sich bereits wie Jellys Summe, wenn eines (oder beide) seiner Argumente eine Ganzzahl ist. Die Summe von zwei Arrays ( + ) erfordert jedoch Arrays derselben Form, und selbst die vektorisierte Summe ( . + ) Erfordert Arrays, die in einer gemeinsamen Form übertragen werden können.

Wir definieren + für ein Paar Arrays über neu

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

Dies hat keine Auswirkungen auf die Definition von + für Ganzzahl- / Ganzzahl-, Array- / Ganzzahl- oder Ganzzahl- / Array-Argumente.

(!x,~x)>(!y,~y)vergleicht lexikographisch die Tiefen- und Längenpaare von x und y . Wenn die Tiefe von x die von y überschreitet oder wenn ihre Tiefe übereinstimmt und die Länge von x die von y überschreitet , wird +y+x rekursiv mit vertauschten Argumenten aufgerufen.

Andernfalls wird !x<!ygeprüft, ob die Tiefe von x geringer als die von y ist . Wenn es so ist,map(t->x+t,y) bildet x + · über y .

Wenn die Tiefen übereinstimmen, wird ~x<~ygeprüft, ob x kürzer als y ist . Wenn dies der [x;0]+yFall ist, wird + rekursiv aufgerufen, nachdem eine 0 an das linke Argument angehängt wurde.

Wenn schließlich Tiefe und Länge identisch sind, x.+ywird + auf alle Elemente von x und die entsprechenden Elemente von y abgebildet .