Contexte
Les atomes arithmétiques de Jelly se vectorisent automatiquement. En fait, x + y est bien défini chaque fois que x et y sont des nombres ou des tableaux irréguliers de nombres. Le code source de Jelly implémente ce comportement à l'aide d'un vectoriseur générique, mais pour ce défi, nous ne considérerons que l'ajout d'entiers et de tableaux d'entiers imbriqués.
Définitions
Définissez la profondeur de x comme 0 si x est un entier, comme 1 s'il s'agit d'un tableau plat (éventuellement vide) d'entiers, et comme n + 1 s'il contient au moins un élément de profondeur n et aucun élément de profondeur k> n .
De cette façon, 1 a la profondeur 0 , [] et [1] et [1, 1] ont la profondeur 1 , [[], []] et [[1], [1]] et [[1]] et [1 , []] a la profondeur 2 , [1, [1, [1]]] a la profondeur 3 , etc.
L'opération x + y est définie comme suit.
Si x et y ont une profondeur de 0 , renvoyez leur somme.
Si x et y ont des profondeurs égales mais positives, appliquer récursivement + à tous les éléments de x et aux éléments correspondants de y .
Si x et y ont des longueurs différentes, ajoutez la queue du tableau le plus long au tableau des sommes.
Renvoie le résultat.
Si la profondeur de x est strictement inférieure à la profondeur de y , appliquez récursivement + à x et à tous les éléments de y , et retournez le résultat.
Faire le contraire si y « s profondeur est strictement inférieure à x » s.
Par exemple, considérons l'opération [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] .
La profondeur de l'argument de gauche est 2 , tandis que la profondeur de l'argument de droite est 3 , donc nous calculons [1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ] et [1, [2, 3], [4]] + 60 .
[1, [2, 3], [4]] et [[10, 20], [30], 40, 50] ont tous deux la profondeur 2 , nous calculons donc 1 + [10, 20] , [2, 3] + [30] et [4] + 40 .
1 + [10, 20] = [1 + 10, 1 + 20] = [11, 21]
[2, 3] + [30] = [2 + 30, 3] = [32, 3]
Notez que 3 reste intact, car il n'a pas d'élément correspondant.
[4] + 40 = [4 + 40] = [44]
50 n'a pas un élément d'adaptation, de sorte que le résultat est [[[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]] , ce qui donne [61, [62, 63], [64]] .
Le résultat final est [[[11, 21], [32, 3], [44], 50], [61, [62, 63], [64]]] .
Tâche
Écrivez un programme ou une fonction qui prend en entrée deux entiers, deux tableaux imbriqués d'entiers ou une combinaison de ceux-ci et renvoie leur somme, comme défini ci-dessus.
Si votre langue a plusieurs types de tableaux (listes, tuples, vecteurs, etc.), vous pouvez choisir l'un d'eux pour votre réponse. Le type de retour doit correspondre au type d'argument.
Pour éviter des solutions ennuyeuses et imbattables, si une langue a cette opération exacte en tant que intégré, vous ne pouvez pas utiliser cette langue.
Toutes les intégrations de toutes les autres langues sont autorisées. Si la langue de votre choix le permet, vous pouvez surcharger et / ou redéfinir l'ajout intégré.
Il s'agit de code-golf , donc le code le plus court en octets l'emporte.
Cas de test
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]]]]
Pour générer plus de cas de test, vous pouvez utiliser ce programme Jelly .