Marmelade nicht so hinzufügen

16

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

Dennis
quelle
Was ist, wenn unsere Sprache keine zerlumpten Arrays unterstützt? Dürfen wir die Eingabe umstrukturieren oder sollten wir unregelmäßige Arrays implementieren? Oder vielleicht einfach eine andere Sprache verwenden?
Meilen
Was meinen Sie mit Umstrukturierung des Inputs ?
Dennis
Wenn ich weiter darüber nachdenke, stelle ich fest, dass es nicht funktionieren würde, die Eingabe neu zu strukturieren, aber ich werde trotzdem zusammenfassen, was ich vorher gemeint habe. Ich habe darüber nachgedacht, einen Füllwert zum Auffüllen zu verwenden, der einige Arbeiten überflüssig macht, aber auch ein anderes Problem aufwirft (wahrscheinlich ein anderes als Ihre beabsichtigte Frage), aber jetzt ist mir klar, dass Ihre Testfälle auch negative Zahlen enthalten.
Meilen
Die Arrays können auch heterogen sein, sodass Füllwerte nicht ausreichen, um sie rechteckig zu machen. Als letztes Mittel gibt es immer die Möglichkeit, Zeichenfolgen zu bearbeiten, aber das ist wahrscheinlich zu kompliziert.
Dennis
3
Hey, schöner Titel! .. jetzt, wo Google mir geholfen hat :-)
Luis Mendo

Antworten:

3

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

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.
Marinus
quelle
3
Manchmal denke ich, dass ich APL gut kenne. Dann sehe ich ein Meisterwerk wie dieses und merke, dass ich es kaum kenne.
Alex A.
Zählen APL-Zeichen wirklich als Bytes?
Metalim
@metalim APL verfügt über ältere Codepages, die einige Jahrzehnte älter sind als Unicode. In diesen ist jedes Zeichen ein einzelnes Byte.
Dennis
Dann sollte der Codierungstyp mit der Lösung versehen werden. Nur IMO.
Metalim
@metalim Ich habe einen Link hinzugefügt.
Adám
5

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.

Martin Ender
quelle
5

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

Lynn
quelle
Ich habe das auch gerade behoben ^^ (Ich hatte die Zeilen für die Lesbarkeit vertauscht, aber ich habe es falsch gemacht ...) Das importliegt daran, dass Ideone einen alten Haskell-Compiler hat. Moderne Versionen von GHC <$>wurden eingeführt Prelude, sodass Sie Control.Applicativeheutzutage keinen Import mehr benötigen, um es zu verwenden.
Lynn
Zu viele Bearbeitungen gleichzeitig mit meinen anderen Aktionen: P Und sicher, jetzt scheint es in Ordnung zu sein, aber ich finde es ziemlich seltsam, dass dies einen Kompilierungsfehler verursacht. Müssen alle Mustervergleichsbits einer Funktion aufeinander folgen?
FryAmTheEggman
Das ist genau richtig
Lynn
Okay, danke für all deine Hilfe :) "Ich werde eines Tages die Sprache verstehen" - FryAmTheEggman vor 7 Jahren.
FryAmTheEggman
4

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.

Wert Tinte
quelle
Das ist beeindruckend.
Dennis
Ich denke, wenn Sie Ihre Schleifen durch foreach-Schleifen durch char-Array ersetzen, das aus string erhalten wird, können Sie ziemlich viele Bytes sparen.
user902383
1
Errr ... Java unterstützt unregelmäßige Arrays. Ich bin mir nicht sicher, was du damit meinst. Verwenden Sie Object[], die entweder verschachtelte Object[]oder enthält Integer. Oder einfach eine nicht generische Liste.
Robert Fraser
4

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]
Blau
quelle
Es ist noch kürzer, zu Python 2.7 zu wechseln und zu schreibenz==[]or`z`>']'and ...
Lynn
Außerdem denke ich, dass das Ersetzen max(d(a)+1for a in z)mit -~max(d(a)for a in z)ein Byte spart (weil Sie den Raum vorher entfernen können max). Welches ist dann gerade -~max(map(d,z)).
Lynn
Die Umstellung auf Python 2 spart noch mehr, dass Sie ändern können , [p(a,b)for a,b in zip(x,y)]in map(p,x,y). Sie können dies immer noch in 3 tun, aber Sie müssen einen Anruf hinzufügen list. Ich denke, Sie könnten auch Lynns Vorschlag verbessern z>=[]. Unabhängig davon sollten Sie auch die typeVergleichsreihenfolge austauschen können, um Platz zu sparen.
FryAmTheEggman
Äh, ich meinte or`z`>'['natürlich, aber ich kann meinen Kommentar nicht mehr ändern. Ist aber in der Tat z>[]noch kürzer (der ==Fall ist schon erledigt)!
Lynn
@FryAmTheEggman-Map funktioniert nicht, wenn die Listen unterschiedlich groß sind. zip richtig abgeschnitten. Ich werde mit der Liste überprüfen tho
Blue
3

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.

Dennis
quelle
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
quelle
1

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]]}
Wert Tinte
quelle
Das ist sehr interessant - ich habe diesen Fehler noch nie für diese Funktion gesehen. Ich habe immer noch einige Dinge wegen anderer Bugs geflickt, aber ansonsten funktioniert es für mich (aber auf ideone scheitert es immer noch). Ich denke, das liegt daran, dass ideone 2.1 ausführt und ich 2.3 habe. Daher kann 2.1 möglicherweise nicht einfach mapmit einer Zwei-Argument-Funktion ausgeführt werden, wie ich sie am Ende eingerichtet habe. Hier ist eine für 2.1 bearbeitete Version, die funktioniert und den mapAufruf am Ende optimiert .ideone.com/q1jqTA
Value Ink
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 .

Dennis
quelle