ayrıntılar

Yalnızca tamsayılar içeren bir dizi (veya liste) verilen, tüm alt öğelerin ters çevrildiği bir dizi döndüren veya çıktı veren bir işlev veya program yazın. Yani, en derin dizinin tüm öğelerini, daha sonra ikinci en derin öğeyi vb. Tersine çevirin. Boyutların belirtilmesi gerekmez, ancak işlev veya programın programlama dilinizin yerel biçimindeki tırtıklı diziler için çalışması gerekir .

Örnekler

Bu:

[[1,2], [3,4]]

Bu olur:

[[4,3], [2,1]]

Bu:

[[[ 1, 2, 3], [ 4, 5, 6], [ 7, 8, 9]],
 [[10,11,12], [13,14,15], [16,17,18]],
 [[19,20,21], [22,23,24], [25,26,27]],
 [[28,29,30], [31,32,33], [34,35,36]],
 [[37,38,39], [40,41,42], [43,44,45]],
 [[46,47,48], [49,50,51], [52,53,54]]]

Bu olur:

[[[54,53,52], [51,50,49], [48,47,46]],
 [[45,44,43], [42,41,40], [39,38,37]],
 [[36,35,34], [33,32,31], [30,29,28]],
 [[27,26,25], [24,23,22], [21,20,19]],
 [[18,17,16], [15,14,13], [12,11,10]],
 [[ 9, 8, 7], [ 6, 5, 4], [ 3, 2, 1]]]

Bu:

[[[1,2]],
 [[3,4], [5]],
 [[6,7,8], [9], [10,11]],
 [[[12,13], [14,15]], [16], [17,18,19,20]],
 [21]]

Bu olur:

[[21],
 [[20,19,18,17], [16], [[15,14], [13,12]]],
 [[11,10], [9], [8,7,6]],
 [[5], [4,3]],
 [[2,1]]]

Bonus

Bu, umarım bazı nesne yönelimli programlama dillerinde cevapları teşvik edecektir ...

-50% Bytecount Programınız, çeşitli türdeki üyeleriyle (bunlar nesne şeklinde olabilir) bir dizi (veya liste) girdi olarak alabilir ve tüm dizileri başarıyla tersine çevirebilir.

Bu:

[["Foo",["Bar",1]],
  2,
 ["Baz"],
 [[["Qux"],3],3.14]]

Bu olur:

[[3.14,[3,["Qux"]]],
 ["Baz"],
  2,
 [[1,"Bar"],"Foo"]]

Pyth,% 11 - 50 = 5.5 bayt

L?+IbY_yMbb

Çevrimiçi deneyin: Gösteri veya Test Suite .

Bu bir işlevi tanımlar y. Ek 3 bayt <newline>yQişlevi giriş listesiyle çağırır ve bu nedenle toplam bayt sayısı olarak sayılması gerekmez.

Açıklama:

L?+IbY_yMbb
L             define a function y(b), that returns:
 ?+IbY           if b + [] == b (test if b is a list):
      _yMb           recursively call y on all elements in b, then reverse the list
          b      else: b

Dyalog APL ,% 14-50 = 7 bayt

{∇¨⍣(×|≡⍵)⌽⍵}

⌽⍵argüman
⍣(×|≡⍵)bir atom değilse ters argüman ([mutlak] derinliğin işareti) ...
∇¨... işlevi her öğeye (ters argümanın) uygular.

Eğer ⎕ML←3APL2 göç ettiğini sistemlerde durum olduğunu (IBM tarzı), bir byte kaldırarak kaydedilebilir |.

APL'yi çevrimiçi deneyin .

Merak için, önerilen int ve float tersine çevirme:

{∇¨⍣(×≡⍵){0::⌽⍵⋄⍎⌽⍕⍵}⍵}

İç fonksiyonu:

0::⌽⍵herhangi bir hata oluşursa
⍎⌽⍕, tersine çevrilmiş bağımsız değişkeni make dizesine geri döndürün

Prolog,% 40 - 50 = 20 bayt

a(X,Y):-reverse(X,Z),maplist(a,Z,Y);X=Y.

Bu yinelemeli çağrılar yüklem a/2ile maplist/3değin, listenin her üyesi için, reverse/2başarısız (yani son öğe listesi değildi).

Python 2,40 -% 50 = 20

f=lambda x:map(f,x)[::-1]if"">x>[]else x

Bonusu elde etmek için temel yoldan sadece bazı küçük değişiklikler gerekli. Tüm listelerin boş dizeden küçük ve tüm sayıların boş listeden küçük olduğu gerçeğini kullanır.

Tüm test örnekleri

Emacs Lisp, 46 bayt * 0.5 = 23

(defun g(x)(if(atom x)x(mapcar'g(reverse x))))

Kullanım örneği: (g '((1 2) 3 (four 5)))->((5 four) 3 (2 1))

Klasik özyinelemeli yaklaşım: bağımsız değişken bir liste değilse, değişmeden alın, bir liste ise, işlevi listenin tersine eşleyin.

Mathematica, 34/2 = 17 bayt

Quiet[Reverse//@#]/.Reverse->(#&)&

Ya da sadece Reverse//@#&bir sürü hata ve Reverseher yerde istiyorsanız .

Clojure 43/2 = 21,5 bayt

(defn f[x](if(coll? x)(reverse(map f x))x))

JavaScript ES6,% 42 - 50 = 21 bayt

Puanım pek çok açıdan mükemmel. rKendi girdisinin üyelerine özyinelemeli olarak uygulanan bir işlev uygular.

r=a=>Array.isArray(a)?a.reverse().map(r):a

Hiçbir nesnenin özelliğe sahip olmadığını varsayarsak pop, dev-null sayesinde bu (31 - 50% = 15.5) olur:

r=a=>a.pop?a.reverse().map(r):a

Veya nesnenin aklı başında bir reverseözelliği olduğunu varsayarsak , bunu da yapabiliriz (% 35 - 50 = 17.5):

r=a=>a[R="reverse"]?a[R]().map(r):a

Lua, 111 99 * .5 = 55,5 49,5 bayt

function r(a)local t={}for i,v in next,a do t[#a+1-i]=type(v)=="table"and r(v)or v end return t end

İyi özyineleme

CJam, 20 bayt *% 50 = 10

{_`0='[={W%{F}%}&}:F

FYığının üstündeki bir diziye uygulanabilecek adlandırılmış bloğu tanımlar (veya başka bir şey, bu durumda işlem yok).

Burada test edin.

Brachylog ,% 5 - 50 = 2,5 bayt

ċ↔↰ᵐ|

Çevrimiçi deneyin!

         The input
ċ        which is a list
 ↔       reversed
   ᵐ     with each element
  ↰      passed through this same predicate
    |    is the output. If the input isn't a list,
         it is the output.

Yana ↔kutu da ters dizeleri ve tamsayılar, biz açıkça olmayan listeleri başarısız zorunda ċ.

Wolfram Dili (Mathematica) ,% 23-50 = 11,5 bayt

#/.List->Reverse@*List&

Çevrimiçi deneyin!

ListMathematica ( {...}) içindeki s ile eşdeğerdir List[...]. @*böylece her bir oluşumunu yerine bileşim, operatör, bir Listile Reverse@*Listbir geri dönüş sağlayarak giriş (oluşur, her liste Reverse@*List[...]= Reverse[{...}]).

% 24-50 = 12 bayt

#~Reverse~Range@Depth@#&

Çevrimiçi deneyin!

Sadece Lists üzerinde çalışmaz .

Clojure, 38 bayt

(ve sanırım bir bonus, ama Clojure dinamik bir dildir, bu yüzden ücretsiz gelir)

(fn f[x](if(seq? x)(map f(into()x))x))

Bu iyi bir başlangıçtır ancak şu optimizasyonları kullanmamıştır:

• fnAdlı bir işlev yerine ile anonim bir işlev tanımlamadefn . Ama yine fde özyineleme için "kapsamlı" bir isme ihtiyacımız var
• Girdiyi vektör yerine liste olarak al, sonra kullanabiliriz seq? yerinecoll?
• kullanım (into () ...) kullanınreverse
• xHaritalamadan önce tersine , o kadar fazla alana ihtiyacımız yok

Yakut ,% 32-50 = 16 bayt

Özyinelemeli işlev. Kullanılması rescueyakalamak için NoMethodErrortetikleyiciler olduğu çalışırken reversebir sayı veya mapbir dize 2 giriş üzerinden bir dizidir olmadığını kontrol daha kısa bayt olarak çıkıyor a==[*a].

f=->a{a.reverse.map(&f)rescue a}

Çevrimiçi deneyin!