배경

젤리 의 산술 원자는 자동으로 벡터화됩니다. 실제로 x + y 는 x 또는 y 가 숫자 또는 비정형 숫자 배열 일 때마다 잘 정의 됩니다. Jelly의 소스 코드는 일반 벡터 라이저를 사용하여이 동작을 구현하지만이 문제를 해결하기 위해 정수 및 중첩 정수 배열 만 추가하는 것을 고려할 것입니다.

정의

깊이 정의 X를 같이 0 경우 X는 같은 정수 (1) 은 정수 (비어) 평면 배열하고, 경우로서 N + 1 는 적어도 하나 개의 깊이의 원소가 포함되어있는 경우 , N 및 깊이없이 소자 (k)를> n .

이 방법은, 1 깊이 가지고 0 , [] 및 [1] 및 [1,1]을 깊이있는 1 , [[] [] 및 [1] [1] 과 [1] 및 [(1) , []]의 깊이는 2입니다 . [1, [1, [1]]]의 깊이는 3입니다 .

x + y 연산 은 다음과 같이 정의됩니다.

1. 경우 X 와 Y는 깊이가 0 , 그 합을 반환합니다.

2. 경우 X 및 Y는 동일하지만, 긍정적 인 깊이를 가지고 반복적으로 적용 + 모든 항목 (X) 과의 대응하는 항목 예 .

   경우 X 와 Y는 서로 다른 길이를 가지고, 합계의 배열에 이상 배열의 꼬리를 추가합니다.

   결과를 돌려줍니다.

3. 경우 X 의 깊이가보다 엄격 작은 Y의 깊이, 재귀 적으로 적용 + 에 X 와의 모든 항목 Y , 그 결과를 반환합니다.

   y 의 깊이가 x 의 깊이보다 작 으면 반대의 작업을 수행하십시오 .

예를 들어, 작업 [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60]을 고려하십시오 .

• 왼쪽 인수의 깊이는 2 이고 오른쪽 인수의 깊이는 3 이므로 [1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ] 및 [1, [2, 3], [4]] + 60 입니다.

  • [1, [2, 3], [4]] 및 [[10, 20], [30], 40, 50]의 깊이는 모두 2 이므로 1 + [10, 20] , [2, 3] + [30] 및 [4] + 40 .

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

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

      참고 3 개 가 일치하는 요소를 가지고 있지 않기 때문에, 남아 그대로.

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

    
    50 결과가되도록, 정합 소자가없는 [[[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]] , [61, [62, 63], [64]]로 나타납니다 .

• 최종 결과는 [[[11, 21], [32, 3], [44], 50], [61, [62, 63], [64]]] 입니다.

직무

두 개의 정수, 두 개의 중첩 된 정수 배열 또는 이들의 조합을 입력으로 사용하여 위에서 정의한대로 합계를 리턴하는 프로그램 또는 함수를 작성하십시오.

언어에 여러 배열 유형 (목록, 튜플, 벡터 등)이있는 경우 답을 위해 원하는 언어를 선택할 수 있습니다. 반환 유형은 인수 유형과 일치해야합니다.

지루하고 탁월한 솔루션을 방지하기 위해 언어가 내장 언어로 정확하게 작동하는 경우 해당 언어를 사용하지 못할 수 있습니다.

다른 모든 언어의 모든 내장 기능이 허용됩니다. 선택한 언어로이 기능이 허용되는 경우 내장 추가 기능을 과부하 및 / 또는 재정의 할 수 있습니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례

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

더 많은 테스트 사례를 생성하려면 이 Jelly 프로그램을 사용할 수 있습니다 .

Pyth, 42 바이트

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

테스트 스위트

마지막 4 바이트는 단순히 입력에서 함수를 실행합니다.

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 바이트

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

APL은 +어레이에도 분산되어 있지만 실제로는 사용할 수 없을 정도로 다른 방식으로 배포됩니다. 그러나 내장 깊이 기능 ( ≡)이 있습니다.

설명:

• 1=≡⍺⍵:⍺+⍵: 깊이 ⍺ ⍵가 모두 0 인 경우 (따라서 깊이 ⍺ ⍵가 1 인 경우) 추가하십시오.
• ∆←|≡¨⍺⍵: 모두의 깊이의 절대을 ⍺하고 ⍵그들을에 저장합니다 ∆. ( ≡모든 요소의 깊이가 같지 않은 경우 음수 값을 제공합니다.)
• =/∆: 깊이가 같은 경우 :
  • ↓↑⍺⍵: 더 긴 배열과 일치하도록 가장 짧은 배열을 0으로 채 웁니다.
  • ⊃∇¨/: 두 배열에 함수를 분배
• </∆:의 깊이가 다음의 깊이 ⍺보다 작은 경우 ⍵:
  • ⍺∘∇¨⍵: 바인딩 ⍺후 매핑⍵
• ⍵∇⍺: (다른 ⍵것보다 깊지 않은 경우 ⍺) 인수를 바꾸고 다시 시도하십시오.

수학, 122 바이트

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

f합계를 계산 하는 재귀 함수 를 정의합니다 . Mathematica의 패턴 매칭을 사용하여이 기능은 다음과 같은 네 가지 정의로 구성됩니다.

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

의 깊이가의 깊이 x보다 크면 y인수를 바꾸어 한 방향으로 만 분포를 처리하면됩니다 (추가는 교환 형이므로 수행 할 수 있음).

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

깊이가의 깊이 x보다 작 으면 y각 값 #을 y로 바꾸십시오.이 값 은 f[x,#]깊이가 다른 인수에 대한 분포를 처리합니다.

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

그렇지 않으면, 하나의 인자가리스트라면 (다른 인자도 같은 깊이를 가지고 있기 때문에 다른리스트이기도 함을 의미합니다), 우리는리스트에 두 인자를 모두 넣고 같은 길이로 PadRight[..., Automatic]채 웁니다. 배열을 0으로 정렬하여 사각형으로 만든 다음 두 목록에서 해당 쌍 MapThread에 적용하는 f데 사용 합니다.

마지막으로 기본 사례는 다음과 같습니다.

x_~f~y_=x+y

다른 패턴과 일치하는 것이 없으면 두 개의 숫자를 더하려고 시도해야합니다.

하스켈, 150 바이트

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

설명

첫 번째 줄은 대수적 데이터 유형을 정의합니다 L. 이는 SCalar (포함 Int) 또는 Vector ( Ls 목록 포함 v, 부분 함수 인 레코드 getter를 사용하여 액세스 L → [L])입니다.

두 번째 줄은 깊이 기능을 정의합니다 . Vector 의 깊이 는 1에 최대 깊이를 더한 값입니다. 나는 S 0벡터의 값 앞에 붙 습니다 depth [] == 1 + maximum [depth (S 0)] == 1. “다른 것”(스칼라)의 깊이는 0입니다.

세 번째 줄은 !(더하기 함수) 의 기본 사례를 정의합니다 . 스칼라의 합은 단순히 스칼라입니다.

다섯 번째 줄은 그 zipWith (!)중 하나가 비어있을 때 가장 긴 목록에서 요소를 선택 하는 변형을 정의합니다 .

네 번째 줄은 세 가지 경우로 나뉩니다.

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

• 의 깊이 x가의 깊이보다 엄격히 작은 경우 의 요소 위에 y매핑 (x!)하십시오 y. (의 사용은 다음 v과 같이 유효합니다 d(y) ≥ 1.)

• 깊이가 x 가 엄격히 크면 인수를 뒤집고 다시 시작하십시오.

• 깊이가 같으면 인수를와 함께 압축하십시오 (!). v사례 d(x) = d(y) = 0가 기본 사례로 처리되었으므로 사용이 유효합니다 .

테스트 사례

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

그런 다음 show (lArg ! rArg) == "[[11,[21]],[[12,[22]],[13,[24]]]]".

자바, 802 794 754 746 바이트

"Dennis ♦"를 "최후의 수단으로"문자열을 조작하는 것이 "너무 복잡"했기 때문에 @ Dennis ♦를 사용하기로 결정했습니다. 또한 최악의 언어로 골프를칩니다.

입력의 배열은 쉼표로 구분되고 대괄호로 묶고 공백이 없습니다.

클래스에 랩핑 된 함수와 테스트 케이스가있는 완전한 프로그램

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

나는 난 이후, 나는 그 자릴 배열을 지원하지 않습니다 알고있는 다른 언어의 후기 이후 ++이 C에 포트 수도 확신 이이 대답보다 짧은 수 있습니다 거의 확실. 이것은 대부분 개념 증명이지만 모든 골프 팁은 여전히 ​​높이 평가됩니다!

@ user902383의 -31 바이트는 변환 된 문자 배열에 foreach를 사용하도록 제안한 다음 마지막 부분에서 if 블록을 다시 정렬하여 조금 더 절약했습니다.

파이썬 2.7 261 209 202 198 191 185 197 181 바이트

FGITW 사소한 솔루션

편집 : 물론 @ Dennis가 이겼습니다.

람다 식에 대한 팁과 57 바이트를 저장하고 불필요한 괄호에서 2 바이트를 저장 한 @LeakyNun에게 감사합니다.

type대신에 사용 제안으로 인해 4 바이트의 @Adnan 덕분 에isinstance

7 바이트 @Lynn에 감사 -~하고map

z>=[]대신 @FryAmTheEggman에게 감사합니다.type

람다를 다른 경우로 변환하고 주요 버그를 수정하려면 +12 바이트

Kenny가 아닌 @Kevin Lau 덕분에 -16 바이트

온라인으로 사용해보십시오

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]

파이썬 2, 145136 바이트

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)

Ideone에서 테스트 .

작동 원리

Python 2에서 모든 정수는 모든 사전보다 작지만 모든 목록이 더 큽니다. D는 재귀 깊이 계산 t를 반환하여 0 정수 또는 원소 및 깊이의 증가 된 최대 0 . t+[0]빈 목록을 특수하게 구분하지 않습니다.

s 는 x 와 y 의 젤리 합계를 재귀 적으로 계산합니다. .

경우 Y 의 깊이를 초과 X 의, s(y,x)전화 의 확인하고 교환 인수, 즉 D (X) ≤ D (Y) .

y 에 양의 깊이가 있으면 map(s,(x,[x]*len(y))[d(x)<d(y)],y)다음을 수행합니다.

• 경우] X 'S 및 Y 의 깊이가 일치, 그것은 실행 map(s,x,y)맵핑 들 모두 위에 소자 (X) 과의 대응 요소 (Y) .

  길이가 다른 목록의 경우 맵 은 짧은 목록에서 누락 된 요소에 대해 왼쪽 또는 오른쪽 인수로 없음 을 전달 합니다.

• 경우 X 의 깊이보다 작은 Y 의 그것이 실행 map(s,[x]*len(y),y)매핑 S (X, ...) 을 통해 Y .

경우 Y (그리고, 따라서, x는 ) 깊이를 가지고 0 , (x or 0)+(y or 0)falsy 인수 (대체 없음 또는 0 제로 복귀 얻어진 정수 합을 함께 참조).

자바 스크립트 (ES6), 152 바이트

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>

루비 2.3 143 145 148 149 바이트

루비는 zip길이가 다른 배열과 map다중 인수 기능 을 사용하는 방식 에있어 이러한 작은 단점을 모두 가지고 있어 골프를 즐기기에 매우 재미 있습니다.

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

줄리아, 113 바이트

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

온라인으로 사용해보십시오!

작동 원리

~=endof

endof 에 대한 1 바이트 별명을 작성 하여 배열의 길이를 리턴합니다.

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

깊이 함수를 정의합니다. 0t == 0 인 경우에만 t 의 깊이는 0 입니다. 그렇지 않은 경우 t 는 배열이며, 깊이는 요소 깊이의 증분 최대 값과 0으로 계산됩니다 . 배열 t에 0 을 [t;0]추가 하므로 빈 배열을 특수하게 처리 할 필요가 없습니다.

Julia의 내장 합계 + 는 인수 중 하나 (또는 ​​둘 다)가 정수인 경우 이미 Jelly의 합계처럼 동작합니다. 그러나 두 배열의 합 ( + )에는 같은 모양의 배열과 벡터화 된 합 ( . + )도 공통 모양으로 브로드 캐스트 할 수있는 배열이 필요합니다.

우리는 통해 한 쌍의 배열에 대해 + 를 재정의합니다.

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

이것은 + 의 정의에 영향을 미치지 않습니다 정수 / 정수, 배열 / 정수 또는 정수 / 배열 인수에 대한 .

(!x,~x)>(!y,~y)사 전적으로 x 와 y 의 깊이와 길이 쌍을 비교합니다 . 경우 X 의 깊이를 초과 Y 들 ', 또는 깊이 일치하고있는 경우 X 의 길이를 초과하는 Y 의' y+x재귀 적으로 호출 + 스왑 인수를.

그렇지 않으면 x 의 깊이가 y 보다 낮은 지 !x<!y테스트합니다 . 이 경우, 매핑 · X + 를 통해 Y .map(t->x+t,y)

깊이가 일치 ~x<~y하면 x 가 y 보다 짧은 지 테스트합니다 . 이 경우 왼쪽 인수에 0 을 추가 한 후 [x;0]+y재귀 적으로 + 를 호출합니다 .

마지막으로, 깊이와 길이가 모두 동일한 경우 x의 모든 요소 와 y 의 해당 요소에 + 를 x.+y매핑 합니다.