Détails

Écrivez une fonction ou un programme qui, étant donné un tableau (ou une liste), contenant uniquement des entiers, retourne ou génère un tableau avec tous les sous-éléments inversés. Autrement dit, inversez tous les éléments du tableau le plus profond, puis le deuxième le plus profond, etc. Les dimensions n'ont pas besoin d'être spécifiées, mais la fonction ou le programme doit fonctionner pour les tableaux irréguliers au format natif de votre langage de programmation.

Exemples

Cette:

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

Deviendrait ceci:

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

Cette:

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

Deviendrait ceci:

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

Cette:

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

Deviendrait ceci:

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

Prime

Cela nous espérons encourager les réponses dans certains langages de programmation orientés objet ...

-50% Bytecount Si votre programme peut prendre en entrée un tableau (ou une liste) avec ses membres de différents types (ceux-ci peuvent être sous la forme d'objets) et inverser avec succès tous les tableaux.

Cette:

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

Deviendrait ceci:

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

Pyth, 11 - 50% = 5,5 octets

L?+IbY_yMbb

Essayez-le en ligne: démonstration ou suite de tests .

Cela définit une fonction y. Les 3 octets supplémentaires <newline>yQappellent simplement la fonction avec la liste d'entrée et n'ont donc pas besoin d'être comptés dans le total des octets.

Explication:

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 octets

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

⌽⍵argument inverse
⍣(×|≡⍵)si l'argument n'est pas un atome (signe de la profondeur [absolue]) ...
∇¨... applique la fonction à chaque élément (de l'argument inversé).

Si ⎕ML←3(style IBM), ce qui est le cas sur les systèmes ayant migré depuis APL2, un octet peut être enregistré en le supprimant |.

Essayez APL en ligne.

Par curiosité, les int et float proposés s'inversent:

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

La fonction intérieure:

0::⌽⍵si une erreur se produit, il suffit de renvoyer l'argument revesed
⍎⌽⍕make into string, reverse, make into number

Prolog, 40 - 50% = 20 octets

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

Cela appelle récursivement un prédicat a/2avec maplist/3, pour chaque membre de la liste, jusqu'à ce qu'il reverse/2échoue (c'est-à-dire que le dernier élément n'était pas une liste).

Python 2, 40 - 50% = 20

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

Seules quelques modifications mineures nécessaires par rapport à la méthode de base pour le faire sont nécessaires pour obtenir le bonus. Utilise le fait que toutes les listes sont inférieures à la chaîne vide et que tous les nombres sont inférieurs à la liste vide.

Tous les cas de test

Emacs Lisp, 46 octets * 0,5 = 23

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

Exemple d'utilisation: (g '((1 2) 3 (four 5)))->((5 four) 3 (2 1))

Approche récursive classique: si l'argument n'est pas une liste, ne le modifiez pas, s'il s'agit d'une liste, mappez la fonction sur l'inverse de la liste.

Mathematica, 34/2 = 17 octets

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

Ou tout simplement Reverse//@#&si vous voulez une tonne d'erreurs et de Reversepartout.

Clojure 43/2 = 21,5 octets

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

JavaScript ES6, 42 - 50% = 21 octets

Mon score est parfait à bien des égards. Implémente une fonction rqui s'applique récursivement aux membres de son entrée.

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

Si nous supposons qu'aucun objet n'a la propriété pop, cela devient (31 - 50% = 15,5), grâce à dev-null:

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

Ou, si nous supposons que l'objet a une reversepropriété saine , nous pourrions également le faire (35 - 50% = 17,5):

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

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

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

Bon peu de récursivité

CJam, 20 octets * 50% = 10

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

Définit le bloc nommé Fqui peut être appliqué à un tableau au-dessus de la pile (ou toute autre chose, auquel cas il s'agit d'un no-op).

Testez-le ici.

Brachylog , 5 - 50% = 2,5 octets

ċ↔↰ᵐ|

Essayez-le en ligne!

         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.

Puisque ↔peut également inverser des chaînes et des entiers, nous devons explicitement échouer les non-listes avec ċ.

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

#/.List->Reverse@*List&

Essayez-le en ligne!

Lists dans Mathematica ( {...}) sont équivalents à List[...]. @*est l'opérateur de composition, donc remplacer chaque occurrence de Listpar Reverse@*Listinverse chaque liste qui se produit dans l'entrée ( Reverse@*List[...]=Reverse[{...}] ).

24 à 50% = 12 octets

#~Reverse~Range@Depth@#&

Essayez-le en ligne!

Ne fonctionne pas seulement sur l' Listal.

Clojure, 38 octets

(et un bonus je suppose, mais Clojure est un langage dynamique donc il est gratuit)

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

Cette un bon début, mais je n'ai pas utilisé ces optimisations:

• Définissez une fonction anonyme avec fnau lieu d'une fonction nommée avecdefn . Mais nous avons encore besoin d'un nom "scoped"f pour la récursivité
• Prenez l'entrée comme une liste au lieu de vecteur, alors nous pouvons utiliser seq?au lieu decoll?
• Utiliser (into () ...)au lieu dereverse
• Inverser xavant la cartographie, nous n'avons donc pas besoin d'autant d'espaces

Rubis , 32 - 50% = 16 octets

Fonction récursive. Utiliser rescuepour attraper le NoMethodErrorqui se déclenche lorsque vous essayez de saisir reverseun nombre ou mapune chaîne s'avère être 2 octets plus court que de vérifier si l'entrée est un tableau via a==[*a].

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

Essayez-le en ligne!