Ti verrà dato un array nidificato. Il tuo programma deve visualizzare l'array.

Ma come?

Ad esempio, supponiamo di avere un array nidificato, come [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Questo array nidificato può essere visualizzato come:

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

Esempi

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

Regole

• È possibile utilizzare una stringa (o altri tipi che funzionano come una matrice nidificata) come input.
• Il livello massimo di "livelli" è 2 ^ 32-1.

APL, 32 byte

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

Test:

      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

Spiegazione:

• {... }∘0: esegui la seguente funzione 0associata a ⍵:
  • 1=≡⍺:: se l'ingresso ha profondità 1 (ovvero un array che non contiene altri array):
    • ⍵/'->': crea una stringa contenente ⍵ -s e ⍵ >s,
    • 1↓: rilascia il primo elemento,
    • ⍵↑: e prendi i primi ⍵elementi. Ciò si traduce in una stringa contenente ⍵-1trattini e uno >.
    • ⍺,⍨: aggiungi l'input ad esso,
    • ⎕←: e l'output sullo schermo
  • ⋄: altrimenti,
    • ⍺∇¨⍵+1: aggiungi 1 a ⍵e applica la funzione a ciascun array nidificato

Mathematica, 58 57 56 byte

Grazie a Greg Martin per aver salvato 1 byte.

Grazie a ngenisis per il salvataggio di 1 byte.

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

Java 7, 153 141 114 byte

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 byte grazie a @ Barteks2x

Spiegazione:

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

Codice di prova:

Provalo qui.

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

Produzione:

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

4 byte salvati grazie a @manatwork.

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

funzione ricorsiva, richiede PHP 7.1 o versione successiva per l'indice di stringa negativo.
^{"$e"è Arrayper array; così "$e"!=$eè lo stesso di is_array($e).}

• inizia con il prefisso >
• anteponi -a al prefisso per ogni livello
• stampa prefisso + elemento + newline per gli atomi

C99 (GCC), 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("");}}

forma estesa:

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("");
        }
}

Questo prende una stringa nel formato corretto e termina quando trova l'ultima corrispondenza ].

Non utilizza la ricorsione e utilizza tipi lunghi per ottenere effettivamente la seconda regola: livelli 2 ^ 32-1 . La maggior parte dei linguaggi di scripting ha una profondità di ricorsione limitata o semplicemente si blocca in caso di overflow dello stack.

Non sono abituato a giocare a golf in C qualsiasi aiuto è apprezzato :)

Grazie a Bolov per i suoi consigli! Soprattutto grazie a Titus che è sempre pronto per una buona partita di golf (anche in C)!

Altri due byte salvati dal fatto che possiamo terminare una volta abbinato l'ultimo ]e non è necessario che corrisponda a un carattere nullo.

Può essere testato su Wandbox .

JavaScript (ES6), 58 51 byte

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

Modifica: salvato 7 byte quando @Arnauld ha sottolineato che potrei combinare i miei due approcci.

PHP, 129 123 112 109 95 93 91 byte

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

soluzione iterativa prende stringa da STDIN:
Eseguire con echo '<input>' | php -nR '<code>'o prova online .

abbattersi

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

Felice che i numeri siano tra virgolette; quindi ho bisogno solo di un'azione alla volta.

ASCII giocherellare

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"

Aggiungendo 3 trattini a $pe rimuovendo 2 per [, 4 per ]aggiunge uno per [e rimuove uno per ].

Python 2, 65 64 byte

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

In questo momento la mia risposta inizia costantemente senza trattini, quindi ["foo", "bar"]è:

>foo
>bar

Perl 5 , 55 byte

53 byte di codice + -nlflag.

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

Provalo online!

Non ottimale per regex a causa di alcuni casi spigolosi che potrebbero potenzialmente verificarsi (in particolare, se un elemento dell'array contiene parentesi all'interno).
Una funzione anonima ricorsiva sarebbe a malapena più lunga (61 byte):

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

Provalo online!

Ma il modo in cui Perl gestisce i parametri non è ottimale per le funzioni del golf: nessun parametro facoltativo significa che devo fare una seconda funzione (anonima) che chiama la prima, e devo ottenere esplicitamente l'ultimo parametro con quel tempo my$v=pop.

Rubino, 49 45 46 byte

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

Esempio:

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

Spiegazione:

Funzione ricorsiva: se x==[*x]allora x è un array, e lo ripetiamo. Altrimenti, rientralo.

Haskell, 104 byte

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 non ha elenchi nidificati con profondità diverse, quindi devo analizzare la stringa di input da sola. Fortunatamente la funzione di libreria readspuò analizzare le stringhe (es" sequenza di caratteri chiusa), quindi ho un piccolo aiuto qui.

Esempio di utilizzo:

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

Provalo online!.

Come funziona:

La funzione #passa attraverso il carattere stringa per carattere e mantiene il livello di annidamento (il primo parametro l) come una stringa di -con un finale >. Se la testa dell'elenco può essere analizzata come una stringa, prendere le la stringa seguita da una chiamata ricorsiva con la stringa rimossa. Se il primo carattere è uno spazio, saltalo. Se è un ,, prendi una nuova riga e vai avanti, se lo è ], abbassa il livello di nidificazione e vai avanti, altrimenti (solo a [sinistra) aumenta il livello di nidificazione e continua. La ricorsione termina con la stringa di input vuota. La funzione principale (">"#)imposta il livello di annidamento su ">"e chiama #.

SWI-Prolog, 115 byte

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).

Le interruzioni di riga sono state aggiunte solo per la leggibilità, non incluse nel conteggio dei byte.

pIl predicato attraversa ricorsivamente gli array, aggiungendo un "-" al prefisso Fquando si sposta un livello più in profondità. wviene utilizzato per scrivere l'array prefisso e l'elemento reale nell'output.

Esempio:

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

Lotto, 249 byte

@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 ha fastidiosi problemi nel confrontare le virgole. Esecuzione di esempio:

[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

Retina , 63 54 52 byte

Salvato 2 byte grazie a Martin Ender

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

-"
>
T`]"

Provalo online!

Spiegazione

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

Innanzitutto, l'array viene suddiviso sostituendo ogni stringa tra virgolette con tutto ciò che lo precede, più se stesso e una nuova riga. Spezzandolo in questo modo, è possibile trovare le parentesi di apertura senza pari prima di ogni stringa.

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

Questo traslitterazione sostituirà [con -, lasciare ]invariato, ed eliminare tutti gli altri personaggi (  -~è tutto ASCII stampabile). Tuttavia, sostituisce solo i caratteri che appaiono prima della stringa finale su ogni riga.

-]

Successivamente -]vengono rimosse tutte le istanze di . Questi corrispondono a coppie di parentesi corrispondenti e desideriamo solo parentesi senza pari. Dopo che questi sono stati rimossi, ogni riga ha un numero di -s pari a quante parentesi di apertura non corrispondenti sono state precedute.

-"
>

L'ultimo -prima di a "viene sostituito da >, per formare le frecce.

T`]"

Infine, tutti i restanti ]s e "s vengono cancellati.

Röda , 54 byte

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

Provalo online!

È una funzione che legge l'array di input dal flusso. Per ogni articolo, si chiama ricorsivamente o stampa l'elemento.

Python 3, 80 byte

Sembra che l'agnello di Python sostenga la ricorsione, chi lo sapeva?

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

Questo è un contatore / complimento per la risposta di orlp .

Groovy, 92 byte

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

Impilato , 27 byte

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

Provalo online!

Prende input dalla parte superiore dello stack e lascia l'output su STDOUT. Questo è semplice come fare una mappa di profondità, ripetere i - dtempi, concatenarsi con '>' e l'elemento stesso.

Gema, 63 caratteri

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

Come le altre soluzioni di analisi, presuppone che non ci siano doppie virgolette di escape nelle stringhe.

Esecuzione di esempio:

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 caratteri

( 67 codice 64 caratteri + opzione riga comandi 3 caratteri)

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

Esecuzione di esempio:

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 online