Einzelheiten

Schreiben Sie eine Funktion oder ein Programm, das bei einem Array (oder einer Liste), das nur Ganzzahlen enthält, ein Array mit allen umgekehrten Unterelementen zurückgibt oder ausgibt. Das heißt, kehren Sie alle Elemente des tiefsten Arrays um, dann das zweittiefste usw. Die Dimensionen müssen nicht angegeben werden, aber die Funktion oder das Programm muss für gezackte Arrays im nativen Format Ihrer Programmiersprache funktionieren .

Beispiele

Diese:

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

Würde dies werden:

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

Diese:

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

Würde dies werden:

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

Diese:

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

Würde dies werden:

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

Bonus

Dies wird hoffentlich zu Antworten in einigen objektorientierten Programmiersprachen führen ...

-50% Bytecount Wenn Ihr Programm ein Array (oder eine Liste) mit seinen Mitgliedern verschiedener Typen (diese können in Form von Objekten vorliegen) als Eingabe verwenden und alle Arrays erfolgreich umkehren kann.

Diese:

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

Würde dies werden:

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

Pyth, 11 - 50% = 5,5 Bytes

L?+IbY_yMbb

Probieren Sie es online aus: Demonstration oder Test Suite .

Dies definiert eine Funktion y. Die zusätzlichen 3 Bytes <newline>yQrufen einfach die Funktion mit der Eingabeliste auf und müssen daher nicht auf die Bytesumme angerechnet werden.

Erläuterung:

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 Bytes

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

⌽⍵umgekehrtes Argument,
⍣(×|≡⍵)wenn das Argument kein Atom ist (Vorzeichen der [absoluten] Tiefe) ...
∇¨... die Funktion auf jedes Element (des umgekehrten Arguments) anwenden.

If ⎕ML←3(IBM-Stil), wie dies bei Systemen der Fall ist, die von APL2 migriert wurden, kann ein Byte durch Entfernen gespeichert werden |.

Probieren Sie APL online aus.

Aus Neugierde die vorgeschlagene Umkehrung von int und float:

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

Die innere Funktion:

0::⌽⍵Wenn ein Fehler auftritt, geben Sie einfach das revesed-Argument
⍎⌽⍕make in string, reverse, make in number zurück

Prolog, 40 - 50% = 20 Bytes

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

Dies ruft rekursiv Prädikat a/2mit maplist/3für jedes Mitglied der Liste auf, bis ein reverse/2Fehler auftritt (dh das letzte Element war keine Liste).

Python 2, 40 - 50% = 20

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

Es sind nur einige geringfügige Änderungen erforderlich, um den Bonus zu erhalten. Verwendet die Tatsache, dass alle Listen kleiner als die leere Zeichenfolge sind und alle Zahlen kleiner als die leere Liste sind.

Alle Testfälle

Emacs Lisp, 46 Bytes * 0,5 = 23

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

Anwendungsbeispiel: (g '((1 2) 3 (four 5)))->((5 four) 3 (2 1))

Klassischer rekursiver Ansatz: Wenn das Argument keine Liste ist, nehmen Sie es unverändert. Wenn es eine Liste ist, ordnen Sie die Funktion der Rückseite der Liste zu.

Mathematica, 34/2 = 17 Bytes

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

Oder nur, Reverse//@#&wenn Sie eine Menge Fehler und Reverses überall wollen.

Clojure 43/2 = 21,5 Bytes

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

JavaScript ES6, 42 - 50% = 21 Byte

Meine Punktzahl ist in vielerlei Hinsicht perfekt. Implementiert eine Funktion, rdie sich rekursiv auf die Mitglieder ihrer Eingabe anwendet.

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

Wenn wir annehmen, dass kein Objekt die Eigenschaft hat pop, wird dies dank dev-null (31 - 50% = 15,5):

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

Wenn wir davon ausgehen, dass das Objekt eine vernünftige reverseEigenschaft hat, können wir dies auch tun (35 - 50% = 17,5):

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

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

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

Gutes Stück Rekursion

CJam, 20 Bytes * 50% = 10

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

Definiert den benannten Block, Fder auf ein Array oben auf dem Stapel angewendet werden kann (oder auf alles andere, in diesem Fall ist es ein No-Op).

Testen Sie es hier.

Brachylog , 5 - 50% = 2,5 Bytes

ċ↔↰ᵐ|

Probieren Sie es online aus!

         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.

Da ↔auch Zeichenfolgen und Ganzzahlen umgekehrt werden können, müssen wir Nicht-Listen mit explizit fehlschlagen ċ.

Wolfram Language (Mathematica) , 23 - 50% = 11,5 Bytes

#/.List->Reverse@*List&

Probieren Sie es online aus!

Lists in Mathematica ( {...}) sind äquivalent zu List[...]. @*ist der Kompositionsoperator. Wenn Sie also jedes Vorkommen von Listdurch ersetzen, wird Reverse@*Listjede Liste, die in der Eingabe auftritt, umgekehrt ( Reverse@*List[...]= Reverse[{...}]).

24 -50% = 12 Bytes

#~Reverse~Range@Depth@#&

Probieren Sie es online aus!

Funktioniert nicht nur bei Lists.

Clojure, 38 Bytes

(und ein Bonus, denke ich, aber Clojure ist eine dynamische Sprache, daher ist sie kostenlos)

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

Dies ist ein guter Anfang, hat aber diese Optimierungen nicht angewendet:

• Definieren Sie eine anonyme Funktion mit fnanstelle einer benannten mit defn. fFür die Rekursion benötigen wir jedoch noch einen Namen mit "Gültigkeitsbereich"
• Nehmen Sie die Eingabe als Liste anstelle des Vektors, dann können wir seq?anstelle von verwendencoll?
• Verwenden Sie (into () ...)anstelle vonreverse
• Umkehren , xbevor Mapping, wir brauchen nicht so viele Felder dann

Ruby , 32 - 50% = 16 Bytes

Rekursive Funktion. Die Verwendung rescuezum Abfangen der NoMethodErrorTrigger, die beim Versuch reverseeiner Zahl oder mapeines Strings ausgelöst werden, ist 2 Byte kürzer als die Überprüfung, ob die Eingabe ein Array über ist a==[*a].

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

Probieren Sie es online aus!