Lý lịch

Các nguyên tử số học của Jelly tự động hóa vector. Trong thực tế, x + y được xác định rõ bất cứ khi nào x và y là các số hoặc các mảng số bị rách. Mã nguồn của Jelly thực hiện hành vi này bằng cách sử dụng một vectơ chung, nhưng đối với thử thách này, chúng tôi sẽ chỉ xem xét bổ sung các số nguyên và mảng số nguyên lồng nhau.

Các định nghĩa

Xác định độ sâu của x là 0 nếu x là số nguyên, vì 1 nếu đó là một mảng số nguyên phẳng (có thể trống) và là n + 1 nếu nó chứa ít nhất một phần tử có độ sâu n và không có phần tử nào có độ sâu k> n .

Theo cách này, 1 có độ sâu 0 , [] và [1] và [1, 1] có độ sâu 1 , [[], []] và [[1], [1]] và [[1]] và [1 , []] có độ sâu 2 , [1, [1, [1]]] có độ sâu 3 , v.v.

Thao tác x + y được định nghĩa như sau.

1. Nếu x và y có độ sâu 0 , trả về tổng của chúng.

2. Nếu x và y có độ sâu bằng nhau nhưng dương, áp dụng đệ quy + cho tất cả các mục của x và các mục tương ứng của y .

   Nếu x và y có độ dài khác nhau, nối phần đuôi của mảng dài hơn vào mảng tổng.

   Trả lại kết quả.

3. Nếu độ sâu của x nhỏ hơn độ sâu của y , hãy áp dụng đệ quy + cho x và tất cả các mục của y và trả về kết quả.

   Làm ngược lại nếu độ sâu của y nhỏ hơn hoàn toàn so với x .

Ví dụ: xem xét thao tác [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] .

• Độ sâu của đối số bên trái là 2 , trong khi độ sâu của đối số bên phải là 3 , vì vậy chúng tôi tính toán [1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ] và [1, [2, 3], [4]] + 60 .

  • [1, [2, 3], [4]] và [[10, 20], [30], 40, 50] đều có độ sâu 2 , vì vậy chúng tôi tính 1 + [10, 20] , [2, 3] + [30] và [4] + 40 .

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

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

      Lưu ý rằng 3 vẫn chưa được xử lý, vì nó không có yếu tố phù hợp.

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

    
    50 không có một yếu tố phù hợp, vì vậy kết quả là [[[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]] , dẫn đến [61, [62, 63], [64]] .

• Kết quả cuối cùng là [[[11, 21], [32, 3], [44], 50], [61, [62, 63], [64]]] .

Bài tập

Viết chương trình hoặc hàm lấy hai số nguyên, hai mảng số nguyên lồng nhau hoặc kết hợp chúng làm đầu vào và trả về tổng của chúng, như được định nghĩa ở trên.

Nếu ngôn ngữ của bạn có nhiều loại giống như mảng (danh sách, bộ dữ liệu, vectơ, v.v.), bạn có thể chọn bất kỳ loại nào cho câu trả lời của mình. Kiểu trả về phải khớp với kiểu đối số.

Để ngăn chặn các giải pháp nhàm chán và không thể đánh bại, nếu một ngôn ngữ có hoạt động chính xác này dưới dạng tích hợp, bạn không được sử dụng ngôn ngữ đó.

Tất cả các ngôn ngữ tích hợp của tất cả các ngôn ngữ khác đều được cho phép. Nếu ngôn ngữ bạn chọn cho phép điều này, bạn có thể quá tải và / hoặc xác định lại bổ sung tích hợp.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm

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

Để tạo thêm các trường hợp thử nghiệm, bạn có thể sử dụng chương trình Jelly này .

Bình thường, 42 byte

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

Bộ kiểm tra

4 byte cuối cùng chỉ đơn giản là chạy chức năng trên đầu vào.

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 byte

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

APL cũng +phân phối trên các mảng, nhưng theo một cách khác đủ để điều này thực sự không thể được sử dụng. Tuy nhiên, có một hàm độ sâu tích hợp ( ≡).

Giải trình:

• 1=≡⍺⍵:⍺+⍵: nếu độ sâu của ⍺ ⍵cả hai đều bằng không (và do đó độ sâu ⍺ ⍵là 1), hãy thêm chúng.
• ∆←|≡¨⍺⍵: Lấy tuyệt đối của độ sâu của cả hai ⍺và ⍵và lưu trữ chúng trong ∆. ( ≡đưa ra một giá trị âm nếu không phải tất cả các phần tử có cùng độ sâu.)
• =/∆: nếu chúng có cùng độ sâu:
  • ↓↑⍺⍵: đệm mảng ngắn nhất với số 0 để khớp với mảng dài hơn
  • ⊃∇¨/: phân phối hàm trên cả hai mảng
• </∆: nếu độ sâu của ⍺nhỏ hơn độ sâu của ⍵:
  • ⍺∘∇¨⍵: liên kết ⍺và sau đó ánh xạ qua⍵
• ⍵∇⍺: nếu không có gì khác (vì vậy ⍵sâu hơn ⍺), trao đổi các đối số và thử lại.

Toán học, 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

Xác định hàm đệ quy ftính tổng. Sử dụng phương thức khớp mẫu của Mathicala, hàm này được tạo thành từ bốn định nghĩa riêng biệt:

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

Nếu độ sâu xlớn hơn độ sâu y, hoán đổi các đối số để chúng ta chỉ phải xử lý phân phối theo một hướng (mà chúng ta có thể làm, vì phép cộng là giao hoán).

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

Nếu độ sâu của xít Thann của y, thay thế mỗi giá trị #trong yvới f[x,#], mà sẽ chăm sóc của các phân phối cho các đối số của chiều sâu bất bình đẳng.

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

Mặt khác, nếu một đối số là một danh sách (ngụ ý rằng đối số kia cũng là một danh sách, vì chúng ta biết chúng có cùng độ sâu), chúng ta đặt cả hai đối số vào một danh sách, đệm chúng theo cùng một chiều dài PadRight[..., Automatic](chỉ đơn giản là lấp đầy một mảng ragged với các số không để làm cho nó hình chữ nhật), và sau đó sử dụng MapThreadđể áp dụng fcho các cặp tương ứng từ hai danh sách.

Và cuối cùng, trường hợp cơ sở:

x_~f~y_=x+y

Nếu không có mẫu nào khác khớp, chúng ta phải cố gắng thêm hai số, vì vậy chúng ta chỉ cần làm điều đó.

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

Giải trình

Dòng đầu tiên xác định một kiểu dữ liệu đại số L, là một Scalar (chứa một Int) hoặc một Vector (chứa một danh sách Ls, được truy cập bằng cách sử dụng một getter record v, là một hàm một phần L → [L].)

Dòng thứ hai xác định hàm độ sâu : độ sâu của Vector là một cộng với độ sâu tối đa của nó. Tôi chuẩn bị S 0cho các giá trị trong vector, vì vậy mà depth [] == 1 + maximum [depth (S 0)] == 1. Độ sâu của bất cứ thứ gì khác khác (một vô hướng) là0 .

Dòng thứ ba định nghĩa trường hợp cơ sở cho !(hàm cộng): tổng vô hướng chỉ đơn giản là vô hướng.

Dòng thứ năm định nghĩa một biến thể zipWith (!)chỉ chọn các phần tử từ danh sách dài nhất khi một trong số chúng trống.

Dòng thứ tư được chia thành ba trường hợp:

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

• Nếu độ sâu của xhoàn toàn nhỏ hơn độ sâu y, ánh xạ (x!)qua các yếu tố của y. (Việc sử dụng vđược đảm bảo là hợp lệ, như d(y) ≥ 1.)

• Nếu độ sâu của xnghiêm ngặt lớn hơn, lật các đối số và khởi động lại.

• Nếu độ sâu của chúng bằng nhau, hãy nén các đối số cùng với (!). (Việc sử dụng vđược đảm bảo là hợp lệ, vì trường hợp d(x) = d(y) = 0được xử lý như trường hợp cơ sở.)

Các trường hợp thử nghiệm

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

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

Java, 802 794 754 746 byte

Tôi quyết định chấp nhận @ Dennis ♦ cho thử thách vận hành trên dây "như là phương sách cuối cùng" bởi vì nó có thể "quá phức tạp". Ngoài ra, trong ngôn ngữ tồi tệ nhất để chơi golf.

Các mảng trong đầu vào được phân tách bằng dấu phẩy, được bao quanh bằng dấu ngoặc vuông và không có khoảng trắng.

Chương trình đầy đủ với các chức năng được bao bọc trong một lớp và với các trường hợp thử nghiệm

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

Tôi có thể chuyển nó sang C ++ sau vì đây là ngôn ngữ khác mà tôi biết không hỗ trợ mảng bị rách, vì tôi khá chắc chắn rằng nó sẽ ngắn hơn câu trả lời này. Đây chủ yếu là một bằng chứng về khái niệm nhưng bất kỳ mẹo chơi golf nào vẫn sẽ được đánh giá cao!

-31 byte từ @ user902383 đề xuất sử dụng một foreach trên một mảng ký tự được chuyển đổi, và sau đó tôi đã tiết kiệm thêm một chút từ việc sắp xếp lại các khối if trong phần cuối cùng.

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

Giải pháp tầm thường FGITW

EDIT: Tất nhiên @Dennis đánh bại nó

Cảm ơn @LeakyNun vì đã lưu 57 byte với các mẹo về biểu thức lambda và 2 byte từ dấu ngoặc không cần thiết.

Cảm ơn @Adnan cho 4 byte do đề xuất sử dụng typethay vìisinstance

Cảm ơn @Lynn cho 7 byte với -~vàmap

Cảm ơn @FryAmTheEggman z>=[]thay vìtype

+12 byte để chuyển đổi lambda sang if khác và sửa một lỗi lớn

-16 byte nhờ @Kevin Lau - không phải Kenny

Dùng thử trực tuyến

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Trong Python 2, tất cả các số nguyên ít hơn tất cả các từ điển, nhưng tất cả các danh sách đều lớn hơn. d tính toán đệ quy độ sâu của t bằng cách trả về 0 cho số nguyên hoặc mức tăng tối đa của độ sâu của các phần tử của nó và 0 . t+[0]tránh đặc biệt vỏ bọc danh sách trống.

s tính toán đệ quy tổng Jelly của x và y .

Nếu độ sâu của y vượt quá x , hãy s(y,x)gọi s với các đối số được hoán đổi, đảm bảo rằng d (x) d (y) .

Nếu y có độ sâu dương, map(s,(x,[x]*len(y))[d(x)<d(y)],y)làm như sau.

• Nếu độ sâu của x và y khớp với nhau, nó sẽ thực thi map(s,x,y), ánh xạ s trên tất cả các phần tử của x và các phần tử tương ứng của y .

  Trong trường hợp danh sách có độ dài khác nhau, bản đồ sẽ chuyển Không có đối số bên trái hoặc bên phải cho các thành phần bị thiếu trong danh sách ngắn hơn.

• Nếu độ sâu của x thấp hơn y , nó sẽ thực thi map(s,[x]*len(y),y), ánh xạ s (x, ·) qua y .

Nếu y (và, do đó, x ) có độ sâu 0 , (x or 0)+(y or 0)thay thế các đối số giả ( Không hoặc 0 ) bằng các số 0 và trả về tổng của các số nguyên kết quả.

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 byte

Ruby có tất cả những điều kỳ quặc này trong cách ziphoạt động với các mảng có độ dài khác nhau và mapvới các hàm đa đối số, làm cho điều này trở nên khá thú vị khi chơi gôn.

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

~=endof

tạo bí danh 1 byte cho endof , trả về độ dài của mảng.

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

định nghĩa một hàm độ sâu. Độ sâu của t bằng 0 khi và chỉ khi 0t == 0 . Nếu không, t là một mảng và độ sâu của nó được tính bằng mức tăng tối đa của độ sâu của các phần tử và 0 . [t;0]nối 0 vào mảng t , do đó tránh trường hợp đặc biệt là mảng trống.

Tổng hợp tích hợp của Julia + đã hoạt động giống như tổng của Jelly nếu một trong hai (hoặc cả hai) đối số của nó là một số nguyên. Tuy nhiên, tổng của hai mảng ( + ) yêu cầu các mảng có cùng hình dạng và thậm chí là tổng vectơ ( . + mảng bắt buộc được ) Có thể được phát thành hình dạng chung.

Chúng tôi xác định lại + cho một cặp mảng thông qua

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

Điều này không ảnh hưởng đến định nghĩa + cho các đối số nguyên / số nguyên, mảng / số nguyên hoặc số nguyên / mảng.

(!x,~x)>(!y,~y)từ vựng so sánh các cặp độ sâu và độ dài của cả x và y . Nếu độ sâu của x vượt quá y , hoặc nếu độ sâu của chúng khớp và độ dài của x vượt quá y , hãy y+xgọi đệ quy + với các đối số được hoán đổi.

Mặt khác, !x<!ykiểm tra nếu độ sâu của x thấp hơn y . Nếu có, map(t->x+t,y)ánh xạ x + · qua y .

Nếu độ sâu khớp, ~x<~ykiểm tra nếu x ngắn hơn y . Nếu đúng, [x;0]+ygọi đệ quy + sau khi nối 0 vào đối số bên trái.

Cuối cùng, nếu cả độ sâu và độ dài là giống hệt nhau, x.+yánh xạ + trên tất cả các phần tử của x và các phần tử tương ứng của y .