Vous recevrez un tableau imbriqué. Votre programme doit visualiser le tableau.

Mais comment?

Par exemple, supposons que nous avons un tableau imbriqué, comme [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Ce tableau imbriqué peut être visualisé comme:

->1
->2
-->1
-->2
->3
>4
---->5
>6

Exemples

Input 1:
["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]
Output 1:
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Input 2:
[["1","2"],["3","4"]]
Output 2:
->1
->2
->3
->4

Règles

• Vous pouvez utiliser une chaîne (ou d'autres types qui fonctionnent comme un tableau imbriqué) en entrée.
• Le niveau maximum de "couches" est de 2 ^ 32-1.

APL, 32 octets

{1=≡⍺:⎕←⍺,⍨⍵↑1↓⍵/'->'⋄⍺∇¨⍵+1}∘0

Tester:

      r
┌────┬─────────────────────────────────────────────────────────────────────────────────────────┐
│Atom│┌──────┬──────────────────────────────┬───────┬────────────────────────────────┬────────┐│
│    ││Proton│┌────────┬────────┬──────────┐│Neutron│┌────────┬──────────┬──────────┐│Electron││
│    ││      ││Up Quark│Up Quark│Down Quark││       ││Up Quark│Down Quark│Down Quark││        ││
│    ││      │└────────┴────────┴──────────┘│       │└────────┴──────────┴──────────┘│        ││
│    │└──────┴──────────────────────────────┴───────┴────────────────────────────────┴────────┘│
└────┴─────────────────────────────────────────────────────────────────────────────────────────┘
      {1=≡⍺:⎕←⍺,⍨⍵↑1↓⍵/'->'⋄⍺∇¨⍵+1}∘0 ⊢ r 
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Explication:

• {... }∘0: exécutez la fonction suivante avec 0lié à ⍵:
  • 1=≡⍺:: si l'entrée a la profondeur 1 (ie un tableau qui ne contient pas d'autres tableaux):
    • ⍵/'->': créer une chaîne contenant ⍵ -s et ⍵ >s,
    • 1↓: déposez le premier élément,
    • ⍵↑: et prenez les premiers ⍵éléments. Il en résulte une chaîne contenant des ⍵-1tirets et un >.
    • ⍺,⍨: ajoutez-y l'entrée,
    • ⎕←: et sortie à l'écran
  • ⋄: autrement,
    • ⍺∇¨⍵+1: ajoutez 1 à ⍵et appliquez la fonction à chaque tableau imbriqué

Mathematica, 58 57 56 octets

Merci à Greg Martin d'avoir économisé 1 octet.

Merci à ngenisis d'avoir sauvé 1 octet.

MapIndexed[Print[Table["-",Tr[1^#2]-1]<>">",#]&,#,{-1}]&

Java 7, 153 141 114 114 octets

String r="";<T,S>S c(S s,T o){for(T x:(T[])o)if(x instanceof Object[])c("-"+s,x);else r+=s+">"+x+"\n";return(S)r;}

-39 octets grâce à @ Barteks2x

Explication:

String r="";                         // Result String outside the method / on class-level
<T,S> S c(S s, T o){                 // Recursive Method with generic String and Object parameters and String return-type
  for(T x : (T[])o)                  //  Loop over the input-array
    if(x instanceof Object[])        //   If the current item is an array itself:
      c("-"+s, x);                   //    Recursive method-call with this array
    else                             //   Else:
      r += s+">"+x+"\n";             //    Append return-String with stripes String-input, ">", current item, and a new-line
                                     //  End of loop (implicit / single-line body)
  return (S)r;                       //  Return the result-String
}                                    // End of method

Code de test:

Essayez-le ici.

class M{
  String r="";<T,S>S c(S s,T o){for(T x:(T[])o)if(x instanceof Object[])c("-"+s,x);else r+=s+">"+x+"\n";return(S)r;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c("", new Object[]{new Object[]{1,2},new Object[]{new Object[]{1,2},3},4,new Object[]{new Object[]{new Object[]{new Object[]{5}}}},6}));
    m.r = "";
    System.out.println(m.c("", new Object[]{"Atom",new Object[]{"Proton",new Object[]{"Up Quark","Up Quark","Down Quark"}},new Object[]{"Neutron",new Object[]{"Up Quark","Up Quark","Down Quark"}},"Electron"}));
  }
}

Production:

->1
->2
-->1
-->2
->3
>4
---->5
>6

>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Up Quark
-->Down Quark
>Electron

PHP, 77 74 73 octets

4 octets enregistrés grâce à @manatwork.

function f($a,$p=">"){foreach($a as$e)"$e"!=$e?f($e,"-$p"):print"$p$e
";}

fonction récursive, nécessite PHP 7.1 ou plus récent pour l'index de chaîne négatif.
^{"$e"est Arraypour les tableaux; c'est "$e"!=$ela même chose que is_array($e).}

• commencer par le préfixe >
• ajouter un -au préfixe pour chaque niveau
• imprimer le préfixe + élément + nouvelle ligne pour les atomes

C99 (CCG), 201 187 140 112 109

f(char*a){for(long d=1,j;j=d+=*++a>90?92-*a:0;)if(*a<35){for(;j||*++a^34;)putchar(j?"->"[!--j]:*a);puts("");}}

forme développée:

f(char*a){
    for(long d=1,j;j=d+=*++a>90?92-*a:0;)
        if(*a<35){
            for(;j||*++a^34;)putchar(j?--j?45:62:*a);
            puts("");
        }
}

Cela prend une chaîne au format correct et se termine lors de la recherche de la dernière correspondance ].

Il n'utilise pas de récursivité et utilise des types longs pour réellement atteindre la deuxième règle: 2 ^ 32-1 niveaux . La plupart des langages de script ont une profondeur de récursivité limitée ou se bloquent simplement lors d'un débordement de pile.

Je n'ai pas l'habitude de jouer au golf en C, toute aide est appréciée :)

Merci à bolov pour ses conseils! Merci particulièrement à Titus qui est toujours partant pour une bonne partie de golf (même en do)!

Encore deux octets économisés par le fait que nous pouvons terminer une fois que nous correspondons au dernier ]et n'avons pas besoin de faire correspondre un caractère nul.

Il peut être testé sur Wandbox .

JavaScript (ES6), 58 51 octets

f=(a,s='>')=>a.map(e=>e.map?f(e,'-'+s):s+e).join`
`

Edit: enregistré 7 octets lorsque @Arnauld a souligné que je pouvais combiner mes deux approches.

PHP, 129 123 112 112 109 95 93 91 octets

for(;a&$c=$argn[++$i];)$c<A?$c<"-"?a&$s?$s=!print"$p>$s
":0:$s.=$c:$p=substr("---$p",$c^i);

solution itérative prend chaîne de STDIN:
Exécuter avec echo '<input>' | php -nR '<code>'ou tester en ligne .

panne

for(;a&$c=$argn[++$i];)     // loop $c through input characters
    $c<A                        // not brackets?
        ?$c<"-"                     // comma or quote?
            ?a&$s?$s=!print"$p>$s\n":0  // if $s not empty, print and clear $s
            :$s.=$c                     // digit: append to $s
        :$p=substr("---$p",$c^i)    // prefix plus or minus one "-"
;

Heureux que les chiffres soient entre guillemets; donc je n'ai besoin que d'une action à la fois.

Violon ASCII

char    ascii   binary/comment
 "       34
 ,       44
 [       91     0101 1011
 ]       93     0101 1101

 A       65     $c<A    true for comma, quote and digits
 -       45     $c<"-"  true for comma and quote

                =0011 1010 -> 50 -> "2"
i^"["   105^91  ^0101 1011
 i      105      0110 1001
i^"]"   105^93  ^0101 1101
                =0011 0100 -> 52 -> "4"

Ajouter 3 tirets $pet en retirer 2 pour [, 4 pour en ]ajoute un pour[ et en supprime un pour ].

Python 2, 65 64 octets

f=lambda o,d=0:o<''and'\n'.join(f(e,d+1)for e in o)or'-'*d+'>'+o

À l'heure actuelle, ma réponse commence systématiquement sans tirets, tout ["foo", "bar"]comme:

>foo
>bar

Perl 5 , 55 octets

53 octets de code + -nldrapeaux.

/"/?print"-"x~-$v.">$_":/]/?$v--:$v++for/]|\[|".*?"/g

Essayez-le en ligne!

Pas optimal pour l'expression régulière en raison de certains cas énervés qui pourraient potentiellement se produire (en particulier, si un élément du tableau contient des crochets à l'intérieur).
Une fonction anonyme récursive serait à peine plus longue (61 octets):

sub f{my$v=pop;map{ref?f(@$_,$v+1):"-"x$v.">$_"}@_}sub{f@_,0}

Essayez-le en ligne!

Mais la façon dont Perl traite les paramètres n'est pas optimale pour les fonctions de golf: aucun paramètre facultatif signifie que je dois faire une deuxième fonction (anonyme) appelant la première, et je dois explicitement obtenir le dernier paramètre avec cette durée my$v=pop.

Rubis, 49 45 46 octets

f=->c,p=?>{c.map{|x|x==[*x]?f[x,?-+p]:p+x}*$/}

Exemple:

puts f[["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]]

>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Explication:

Fonction récursive: si x==[*x]alors x est un tableau, et nous itérons dessus. Sinon, indenter.

Haskell, 104 octets

l@(x:y)#(a:m)|[(h,t)]<-reads$a:m=y++h++l#t|a<'#'=l#m|a<'-'='\n':l#m|a>'['=y#m|q<-'-':l=q#m
l#_=""
(">"#)

Haskell n'a pas de listes imbriquées avec différentes profondeurs, donc je dois analyser la chaîne d'entrée par moi-même. Heureusement, la fonction de bibliothèque readspeut analyser les chaînes (c'est-à-dire la "séquence de caractères fermée), j'ai donc un peu d'aide ici.

Exemple d'utilisation:

*Main> putStrLn $ (">"#) "[[\"1\",\"2\"],[\"3\",\"4\"]]" 
->1
->2
->3
->4

Essayez-le en ligne! .

Comment ça fonctionne:

La fonction #passe par la chaîne char par char et conserve le niveau d'imbrication (le premier paramètre l) sous la forme d'une chaîne -avec une finale >. Si le début de la liste peut être analysé comme une chaîne, prenez let la chaîne suivie d'un appel récursif avec la chaîne supprimée. Si le premier caractère est un espace, sautez-le. Si c'est un ,, prenez une nouvelle ligne et continuez, si c'est le cas ], abaissez le niveau d'imbrication et continuez et sinon (seulement à [gauche) augmentez le niveau d'imbrication et continuez. La récursivité se termine avec la chaîne d'entrée vide. La fonction principale (">"#)définit le niveau d'imbrication sur ">"et appelle #.

SWI-Prolog, 115 octets

p(L):-p(L,[>]).
p([],_):-!.
p([H|T],F):-p(H,[-|F]),p(T,F),!.
p(E,[_|F]):-w(F),w([E]),nl.
w([]).
w([H|T]):-write(H),w(T).

Sauts de ligne ajoutés pour la lisibilité uniquement, non inclus dans le nombre d'octets.

pprédicat traverse récursivement les tableaux, en ajoutant un «-» au préfixe Florsque vous déplacez un niveau plus profondément. west utilisé pour écrire le tableau de préfixes ainsi que l'élément réel dans la sortie.

Exemple:

?- p(["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]).
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Lot, 249 octets

@echo off
set/ps=
set i=
:t
set t=
:l
set c=%s:~,1%
set s=%s:~1%
if "%c%"=="[" set i=-%i%&goto l
if not "%c%"=="]" if not "%c%"=="," set t=%t%%c%&goto l
if not "%t%"=="" echo %i:~1%^>%t%
if "%c%"=="]" set i=%i:~1%
if not "%s%"=="" goto t

Batch ennuyeux a du mal à comparer les virgules. Exemple d'exécution:

[Atom,[Proton,[Up Quark,Up Quark,Down Quark],Neutron,[Up Quark,Down Quark,Down Quark],Electron]]
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Rétine , 63 54 52 octets

Enregistré 2 octets grâce à Martin Ender

.*?".*?"
$`$&¶
T`[] -~`-]_`.(?=.*".*")
-]

-"
>
T`]"

Essayez-le en ligne!

Explication

.*?".*?"
$`$&¶

Tout d'abord, le tableau est divisé en remplaçant chaque chaîne entre guillemets par tout ce qui l'a précédé, plus lui-même, plus une nouvelle ligne. En le décomposant comme ceci, il est possible de trouver les crochets d'ouverture inégalés avant chaque chaîne.

T`[] -~`-]_`.(?=.*".*")

Cette translittération sera remplacée [par -, laissée ]inchangée et supprimera tout autre caractère (  -~est entièrement ASCII imprimable). Cependant, il remplace uniquement les caractères apparaissant avant la chaîne finale sur chaque ligne.

-]

Ensuite, toutes les instances de -]sont supprimées. Celles-ci correspondent à des paires de parenthèses correspondantes, et nous voulons uniquement des parenthèses inégalées. Une fois ceux-ci supprimés, chaque ligne a un nombre de -s égal au nombre de crochets d'ouverture inégalés qui l'ont précédée.

-"
>

Le dernier -avant a "est remplacé par >, pour former les flèches.

T`]"

Enfin, tous les ]s et "s restants sont supprimés.

Röda , 54 octets

f d=""{{|n|{n|f d=`$d-`}if[n is list]else[`$d>$n
`]}_}

Essayez-le en ligne!

C'est une fonction qui lit le tableau d'entrée du flux. Pour chaque élément, il s'appelle récursivement ou imprime l'élément.

Python 3, 80 octets

Les lambdas de Python prennent en charge la récursion, semble-t-il, qui savait?

p=lambda l,d=1:[p(i,d+1)if isinstance(i,list)else print("-"*d+">"+i)for i in l]

Ceci est un contre / compliment à la réponse d' orlp .

Groovy, 92 octets

x={a,b->if(a instanceof List){a.each{x(it,b+1)}}else{y(a,b)}};y={a,b->println("-"*b+">$a")};

Empilé , 27 octets

[@.1-'-'*\'>'\,,out]deepmap

Essayez-le en ligne!

Prend l'entrée du haut de la pile et laisse la sortie sur STDOUT. C'est aussi simple que de faire une carte de profondeur, de répéter des - dtemps, de concaténer avec '>' et l'élément lui-même.

Gema, 63 caractères

\A=@set{i;-1}
[=@incr{i}
]=@decr{i}
"*"=@repeat{$i;-}>*\n
,<s>=

Comme les autres solutions d'analyse, suppose qu'il n'y aura pas de guillemets doubles échappés dans les chaînes.

Exemple d'exécution:

bash-4.3$ gema '\A=@set{i;-1};[=@incr{i};]=@decr{i};"*"=@repeat{$i;-}>*\n;,<s>=' <<< '[["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]'
->1
->2
-->1
-->2
->3
>4
---->5
>6

jq, 70 67 caractères

( 67 commande option de ligne 64 caractères de code + 3 caractères)

def f(i):if type=="array"then.[]|f("-"+i)else i+. end;.[]|f(">")

Exemple d'exécution:

bash-4.3$ jq -r 'def f(i):if type=="array"then.[]|f("-"+i)else i+. end;.[]|f(">")' <<< '[["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]'
->1
->2
-->1
-->2
->3
>4
---->5
>6

Test en ligne