Arka fon

Jelly'in aritmetik atomları otomatik olarak vektörleşir. Aslında, burada x + y , iyi tanımlanmış zaman olan X ve Y sayıların ya da sayıların düzensiz dizilerdir. Jelly'in kaynak kodu bu davranışı genel bir vectorizer kullanarak uygular, ancak bu meydan okuma için yalnızca tamsayıların ve iç içe tamsayı dizilerinin eklenmesini ele alacağız.

Tanımlar

Derinliğini tanımlar x olarak 0 ise X gibi bir tam sayı olduğu 1 bu bir tamsayı (muhtemelen boş) düz dizi ve sanki n + 1 , en azından bir derinlik elemanı içeriyorsa , n ve derinlik herhangi bir öğe k> n .

Bu şekilde, 1 derinliği 0 , [] ve [1] ve [1, 1] derinliği 1 , [[], []] ve [[1], [1]] ve [[1]] ve [1 , []] derinliğe 2 , [1, [1, [1]]] derinliğe 3 vb. sahiptir .

X + y işlemi aşağıdaki gibi tanımlanır.

1. Eğer x ve y derinliğe sahip 0 , bunların toplamı döndürür.

2. Eğer x ve y eşit ama olumlu derinlikleri var, yinelemeli uygulamak + tüm öğelere x ve karşılık gelen öğeler y .

   Eğer x ve y farklı uzunluklara sahip, toplamlar dizisine uzun dizinin kuyruk ekleyin.

   Sonucu döndür.

3. Eğer x 'in derinlik daha sıkı küçüktür y kullanıcısının derinliği, yinelemeli uygulamak + için x ve tüm kalemlerin y , ve sonucu döndürür.

   Eğer tersini yapın y 'nin derinliği daha sıkı küçüktür x s'.

Örneğin, [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] işlemlerini düşünün .

• Sol değişken derinliği 2 doğru değişken derinliği ise, 3 biz hesaplamak, yani [[2, 3], [4] 1] + [[10, 20], [30], 40, 50 ] ve [1, [2, 3], [4]] + 60 .

  • [1, [2, 3], [4]] ve [[10, 20], [30], 40, 50] derinlik 2'ye sahip , bu nedenle 1 + [10, 20] , [2, 3] hesaplıyoruz + [30] ve [4] + 40 .

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

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

      Eşleşen bir elemanı olmadığı için 3'ün dokunulmadan kaldığını unutmayın .

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

    
    50 sonucudur, yani bir uygun elemanına sahip değildir [[[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]] ile sonuçlanan [61, [62, 63], [64]] .

• Nihai sonuç [[[11, 21], [32, 3], [44], 50], [61, [62, 63], [64]]] .

Görev

Giriş olarak iki tamsayı, iki iç içe tamsayı dizisi veya bunların bir kombinasyonunu alan ve yukarıda tanımlandığı gibi toplamlarını döndüren bir program veya işlev yazın.

Dilinizde birden çok dizi benzeri tür (liste, tuples, vektör, vb.) Varsa, yanıtınız için bunlardan herhangi birini seçebilirsiniz. Dönüş türü, bağımsız değişken türüyle eşleşmelidir.

Bir dilin bu kadar kesin olması durumunda, sıkıcı ve rakipsiz çözümleri önlemek için yerleşik olarak olarak işlem varsa, o dili kullanamayabilirsiniz.

Diğer tüm dillerin yerleşiklerine izin verilir. Tercih ettiğiniz dil buna izin veriyorsa, dahili eklentiyi aşırı yükleyebilir ve / veya yeniden tanımlayabilirsiniz.

Bu kod golfüdür , bu nedenle bayttaki en kısa kod kazanır.

Test senaryoları

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

Daha fazla test örneği oluşturmak için bu Jelly programını kullanabilirsiniz .

Pyth, 42 bayt

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

Test odası

Son 4 bayt girişteki işlevi çalıştırır.

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 bayt

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

APL'ler +diziler üzerinde de dağıtılır, ancak bunun gerçekten kullanılamayacağı kadar farklı bir şekilde. Ancak, yerleşik bir derinlik işlevi ( ≡) vardır.

Açıklama:

• 1=≡⍺⍵:⍺+⍵: derinliklerinin ⍺ ⍵her ikisi de sıfırsa (ve bu nedenle derinliği ⍺ ⍵1 ise) bunları ekleyin.
• ∆←|≡¨⍺⍵: her ikisinin de derinliğini mutlak alın ⍺ ve ⍵onları depolamak ∆. ( ≡tüm öğeler aynı derinliğe sahip değilse negatif bir değer verir.)
• =/∆: aynı derinliğe sahiplerse:
  • ↓↑⍺⍵: daha uzun diziyle eşleşmek için en kısa diziyi sıfırlarla doldur
  • ⊃∇¨/: işlevi her iki diziye de dağıtır
• </∆: derinliği ⍺ aşağıdakilerden daha azsa ⍵:
  • ⍺∘∇¨⍵: bağlama ⍺ve ardından eşleme⍵
• ⍵∇⍺: başka bir şey yoksa (bundan ⍵daha derin değilse ⍺), argümanları değiştirin ve tekrar deneyin.

Mathematica, 122 bayt

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

fToplamı hesaplayan özyinelemeli bir işlevi tanımlar . Mathematica'nın desen eşleşmesini kullanarak, bu işlev dört ayrı tanımdan oluşur:

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

Eğer derinliği xbundan daha büyükse y, argümanları sadece bir yönde (toplamanın değişmeli olduğu için yapabiliriz) işlemek zorunda kalacağız.

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

Derinliği ise xdaha az olduğu thann olduğu y, her bir değeri değiştirmek #içinde yolan f[x,#]eşitsiz derinlik argümanlar için dağıtım ilgilenir.

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

Aksi takdirde, bir argüman bir listeyse (diğerinin de bir liste olduğunu ima eder, aynı derinliğe sahip olduklarını bildiğimiz için), her iki argümanı da bir listeye koyarız, bunları aynı uzunlukta PadRight[..., Automatic]doldururuz ( dikdörtgen yapmak için sıfırlarla düzensiz dizi) ve ardından iki listeden karşılık gelen çiftlere MapThreaduygulamak fiçin kullanın .

Ve son olarak, temel durum:

x_~f~y_=x+y

Diğer kalıpların hiçbiri eşleşmezse, iki sayı eklemeye çalışmalıyız, bu yüzden bunu yapıyoruz.

Haskell, 150 bayt

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

açıklama

Birinci çizgi, cebirsel veri tipini tanımlar Lya da a,, Scalar (bir içeren Int) ya da bir Vector (bir listesini içeren Lbir kayıt getter kullanılarak erişilebilen s, vkısmi bir fonksiyondur, L → [L].)

İkinci çizgi derinlik fonksiyonunu tanımlar : bir Vector derinliği bir artı maksimum derinliğidir. Ben S 0vektördeki değerlerin önüne, yani depth [] == 1 + maximum [depth (S 0)] == 1. “Başka her şeyin” (skaler) derinliği 0.

Üçüncü satır !(toplama fonksiyonu) için temel durumu tanımlar : skalerlerin toplamı sadece bir skalerdir.

Beşinci satır, zipWith (!)bunlardan biri boş olduğunda en uzun listeden öğe seçen bir varyantı tanımlar .

Dördüncü satır üç durumda ayrılmıştır:

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

• Derinliği ise xkesinlikle az derinliğinden daha y, harita (x!)elemanlarını üzerinde y. (Kullanımının vgeçerli olduğu garanti edilmektedir d(y) ≥ 1.)

• Derinliği xkesinlikle daha büyükse, argümanları çevirin ve yeniden başlatın.

• Derinlikleri eşitse, argümanları ile birlikte sıkıştırın (!). ( vDavanın d(x) = d(y) = 0temel dava olarak ele alındığı için, kullanımının geçerli olacağı garanti edilmektedir .)

Test senaryoları

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

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

Java, 802 794 754 746 bayt

Muhtemelen "çok karmaşık" çünkü "son çare" olarak dizeleri üzerinde çalışmak için @ Dennis ♦ almaya karar verdi. Ayrıca, en kötü dilde golf.

Girişteki diziler virgülle ayrılır, köşeli parantezlerle çevrelenir ve boşluk içermez.

Bir sınıfa sarılmış fonksiyonlara ve test senaryolarına sahip tam program

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

Daha sonra bu C ++ 'a taşıyabilirim çünkü pürüzlü dizileri desteklemediğini bildiğim diğer dil, çünkü bu cevaptan daha kısa olacağından eminim . Bu çoğunlukla bir kavram kanıtıydı, ancak herhangi bir golf ipucu hala takdir edilecektir!

@ User902383'ten -31 bayt, dönüştürülmüş bir karakter dizisi üzerinde bir foreach kullanmayı önerir ve daha sonra son kısımdaki if bloklarını yeniden düzenlemekten biraz daha tasarruf ettim.

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

FGITW önemsiz çözüm

EDIT: Tabii ki @Dennis yener

@LeakyNun, lambda ifadeleriyle ilgili ipuçları ile 57 bayt ve gereksiz parantezlerden 2 bayt kaydettiği için teşekkürler.

@Adnan'a, typeyerine önerisi nedeniyle 4 bayt için teşekkürlerisinstance

7 bytes için @Lynn'e -~vemap

İçin @FryAmTheEggman sayesinde z>=[]yerinetype

Lambda'yı başka bir duruma dönüştürmek ve büyük bir hatayı düzeltmek için +12 bayt

@Kevin Lau sayesinde -16 bayt - Kenny değil

Çevrimiçi deneyin

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 bayt

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 üzerinde test edin .

Nasıl çalışır

Python 2'de, tüm tamsayılar tüm sözlüklerden daha azdır, ancak tüm listeler daha büyüktür. d , tamsayılar için 0 veya elemanlarının derinliklerinin artırılmış maksimumu ve 0 değerini geri döndürerek t derinliğini tekrar eder . boş listenin özel olarak kaydedilmesini önler.t+[0]

s , x ve y'nin Jelly toplamını özyineli olarak hesaplar .

Eğer Y 'in derinliği aşan X ' in, s(y,x)çağrılar s emin olduğu takas bağımsız değişken ile D (x) ≤ d (y) .

Eğer y derinliği pozitifse map(s,(x,[x]*len(y))[d(x)<d(y)],y), aşağıdakileri yapar.

• Eğer X 'in ve y ' nin derinlikleri neticesinde, yürütür map(s,x,y), eşleme s tüm elemanları üzerinde x ve karşılık gelen elemanları y .

  Farklı uzunluklarda listeleri halinde, harita geçecek Hiçbiri kısa listede eksik unsurları sağ veya sol argüman olarak.

• Eğer X 'in derinliği daha düşük olan y ' nin, bu çalıştırır map(s,[x]*len(y),y), harita s (x, ·) üzerinde y .

Eğer Y (ve bu nedenle, X ) derinliği 0 , (x or 0)+(y or 0)falsy bağımsız değişkenleri (yerine Yok ya da 0 sıfır ve getiri elde edilen sayının toplamı ile).

JavaScript (ES6), 152 bayt

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>

Yakut 2.3, 143 145 148 149 bayt

Ruby, zipfarklı uzunluktaki dizilerle ve mapçoklu argüman işlevleriyle nasıl çalıştığına dair tüm bu küçük tuhaflıklara sahip , bu da golf oynamak için oldukça eğlenceli.

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 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

~=endof

endof için bir dizinin uzunluğunu döndüren 1 baytlık bir diğer ad oluşturur .

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

Bir derinlik fonksiyonunu tanımlar. T derinliği, yalnızca 0t == 0 ise sıfırdır . Değilse, t bir dizidir ve derinliği, öğelerinin derinliklerinin artırılmış maksimum değeri ve 0 olarak hesaplanır . t dizisine [t;0]bir 0 ekler , böylece boş diziyi özel durumdan kaçınmaya gerek kalmaz.

Julia'nın yerleşik toplamı + argümanlarından biri (veya her ikisi) bir tamsayı ise Jelly'in toplamı gibi davranır. Bununla birlikte, iki dizinin ( + ) toplamı aynı şekildeki dizileri gerektirir ve vektörize edilmiş toplam ( . + ) Ortak bir şekle yayınlanabilen diziler gerektirir.

Tanımlanarak + diziler bir çift için yoluyla

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

Bu, tamsayı / tamsayı, dizi / tamsayı veya tamsayı / dizi bağımsız değişkenleri için + tanımını etkilemez .

(!x,~x)>(!y,~y)sözlükbilimsel olarak her iki x'in derinlik ve uzunluk çiftlerini karşılaştırır ve y . Eğer X 'in derinlik aşan y s' ya da bunların derinliği maç ve eğer X 'in uzunluğu aşan y s,' y+xyinelemeli çağrı + takas argüman.

Aksi halde, x derinliğinin y'den düşük !x<!yolup olmadığını test eder . Öyleyse, x + · y üzerinden eşler .map(t->x+t,y)

Derinlikler eşleşirse, x'in y'den kısa ~x<~yolup olmadığını test eder . Öyleyse , sol bağımsız değişkene 0 ekledikten sonra + işaretini tekrar tekrar arar .[x;0]+y

Son olarak, hem derinlikler hem de uzunluklar aynı ise, x.+yharitalar x'in tüm öğeleri ve y'nin karşılık gelen öğeleri üzerinde + .