Sie erhalten ein verschachteltes Array. Ihr Programm muss das Array visualisieren.

Aber wie?

Nehmen wir zum Beispiel an, wir haben ein verschachteltes Array wie [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Dieses verschachtelte Array kann wie folgt dargestellt werden:

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

Beispiele

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

Regeln

• Sie können Zeichenfolgen (oder andere Typen, die wie ein verschachteltes Array funktionieren) als Eingabe verwenden.
• Die maximale Ebene der "Ebenen" ist 2 ^ 32-1.

APL, 32 Bytes

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

Prüfung:

      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

Erläuterung:

• {... }∘0: führe die folgende Funktion aus mit 0gebunden an ⍵:
  • 1=≡⍺:: Wenn die Eingabe Tiefe 1 hat (dh ein Array, das keine anderen Arrays enthält):
    • ⍵/'->': Erstelle einen String mit ⍵ -s und ⍵ >s,
    • 1↓: Lasse das erste Element fallen,
    • ⍵↑: und nimm die ersten ⍵Elemente. Dies führt zu einer Zeichenfolge mit ⍵-1Bindestrichen und einer >.
    • ⍺,⍨: füge die Eingabe hinzu,
    • ⎕←: und gib das auf dem Bildschirm aus
  • ⋄: Andernfalls,
    • ⍺∇¨⍵+1: addiere 1 zu ⍵und wende die Funktion auf jedes verschachtelte Array an

Mathematica, 58 57 56 Bytes

Vielen Dank an Greg Martin für das Speichern von 1 Byte.

Dank an ngenisis für das Speichern von 1 Byte.

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

Java 7, 153 141 114 Bytes

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 Bytes dank @ Barteks2x

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

4 Bytes gespeichert dank @manatwork.

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

rekursive Funktion, benötigt PHP 7.1 oder neuer für den negativen Stringindex.
^{"$e"ist Arrayfür Arrays; so "$e"!=$eist das gleiche wie is_array($e).}

• Beginnen Sie mit dem Präfix >
• stellen Sie -dem Präfix für jede Ebene ein voran
• print Präfix + Element + Newline für Atome

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

erweiterte Form:

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

Dies nimmt eine Zeichenfolge im richtigen Format und endet, wenn die letzte Übereinstimmung gefunden wird ].

Es verwendet keine Rekursion und verwendet lange Typen, um die zweite Regel zu erreichen: 2 ^ 32-1 Ebenen . Die meisten Skriptsprachen haben eine begrenzte Rekursionstiefe oder stürzen einfach beim Stapelüberlauf ab.

Ich bin es nicht gewohnt in C Golf zu spielen, jede Hilfe wird geschätzt :)

Danke an bolov für seine Tipps! Besonders danke an Titus, der immer für eine gute Runde Golf (auch in C) bereit ist!

Weitere zwei Bytes werden durch die Tatsache gespart, dass wir fertig werden können, sobald wir das letzte Zeichen gefunden haben ]und kein Nullzeichen mehr benötigen.

Es kann an der Wandbox getestet werden .

JavaScript (ES6), 58 51 Byte

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

Bearbeiten: 7 Bytes gespart, als @Arnauld darauf hinwies, dass ich meine beiden Ansätze kombinieren könnte.

PHP, 129 123 112 109 95 93 91 Bytes

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

Die iterative Lösung übernimmt die Zeichenfolge von STDIN:
Führen Sie sie mit aus, echo '<input>' | php -nR '<code>'oder testen Sie sie online .

Nervenzusammenbruch

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

Glücklich, dass die Zahlen in Anführungszeichen stehen; Ich brauche also immer nur eine Aktion.

ASCII-Geigen

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"

Hinzufügen von 3 Strichen zu $pund Entfernen von 2 für [, 4 für Hinzufügen von ]einem für [und Entfernen von einem für ].

Python 2, 65 64 Bytes

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

Gerade jetzt meine Antwort beginnt konsequent ohne Bindestriche, so ["foo", "bar"]ist:

>foo
>bar

Perl 5 , 55 Bytes

53 Byte Code + -nlFlags.

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

Probieren Sie es online!

Nicht optimal für reguläre Ausdrücke, da einige unruhige Fälle auftreten können (insbesondere, wenn ein Element des Arrays Klammern enthält).
Eine rekursive anonyme Funktion wäre allerdings kaum länger (61 Bytes):

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

Probieren Sie es online!

Die Art und Weise, wie Perl mit Parametern umgeht, ist jedoch für Golffunktionen nicht optimal: Keine optionalen Parameter bedeuten, dass ich eine zweite Funktion (anonym) ausführen muss, die die erste aufruft, und ich muss den letzten Parameter mit dieser Länge explizit abrufen my$v=pop.

Ruby, 49 45 46 Bytes

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

Beispiel:

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

Erläuterung:

Rekursive Funktion: Wenn x==[*x]dann x ein Array ist, iterieren wir darüber. Wenn nicht, rücken Sie es ein.

Haskell, 104 Bytes

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 hat keine verschachtelten Listen mit unterschiedlichen Tiefen, daher muss ich die Eingabezeichenfolge selbst analysieren. Glücklicherweise kann die Bibliotheksfunktion readsStrings (d. H" -enclosed char sequence) , daher habe ich hier eine kleine Hilfe.

Anwendungsbeispiel:

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

Probieren Sie es online!.

Wie es funktioniert:

Die Funktion #durchläuft die Zeichenfolge char by char und behält die Verschachtelungsebene (den ersten Parameter l) als Zeichenfolge -mit einem Finale bei >. Wenn der Kopf der Liste als String analysiert werden kann, nehmen Sie lund der String gefolgt von einem rekursiven Aufruf, wobei der String entfernt wird. Wenn das erste Zeichen ein Leerzeichen ist, überspringen Sie es. Wenn ,ja, nehmen Sie eine neue Zeile und fahren Sie fort, wenn ja ], senken Sie die Verschachtelungsebene und fahren Sie fort. Andernfalls (nur [links) erhöhen Sie die Verschachtelungsebene und fahren Sie fort. Die Rekursion endet mit der leeren Eingabezeichenfolge. Die Hauptfunktion (">"#)setzt die Verschachtelungsebene auf ">"und ruft auf #.

SWI-Prolog, 115 Bytes

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

Zeilenumbrüche wurden nur zur besseren Lesbarkeit hinzugefügt und sind nicht in der Byteanzahl enthalten.

pDas Prädikat durchläuft die Arrays rekursiv und fügt dem Präfix ein '-' hinzu, Fwenn es eine Ebene tiefer verschoben wird. wwird verwendet, um das Präfix-Array sowie das eigentliche Element in die Ausgabe zu schreiben.

Beispiel:

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

Batch, 249 Bytes

@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

Ärgerlicherweise hat Batch Probleme beim Vergleichen von Kommas. Probelauf:

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

2 Bytes gespart dank Martin Ender

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

-"
>
T`]"

Probieren Sie es online!

Erläuterung

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

Zunächst wird das Array durch Ersetzen der einzelnen Zeichenfolgen in Anführungszeichen durch die vorangegangenen Zeichenfolgen sowie durch eine neue Zeile aufgelöst. Wenn Sie es so aufteilen, ist es möglich, die nicht passenden öffnenden Klammern vor jeder Saite zu finden.

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

Diese Transliteration wird ersetzt [durch -, bleibt ]unverändert und löscht alle anderen Zeichen (  -~alle druckbaren ASCII-Zeichen). Es ersetzt jedoch nur Zeichen, die in jeder Zeile vor der letzten Zeichenfolge stehen.

-]

Als nächstes werden alle Instanzen von -]entfernt. Diese entsprechen übereinstimmenden Klammerpaaren, und wir möchten nur nicht passende Klammern. Nachdem diese entfernt wurden, hat jede Zeile eine Anzahl von -s, die der Anzahl nicht übereinstimmender öffnender Klammern entspricht.

-"
>

Der letzte -vor a "wird durch ersetzt >, um die Pfeile zu bilden.

T`]"

Schließlich werden alle verbleibenden ]s und "s gelöscht.

Röda , 54 Bytes

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

Probieren Sie es online!

Es ist eine Funktion, die das Eingabearray aus dem Stream liest. Für jedes Element ruft es sich entweder selbst rekursiv auf oder druckt das Element aus.

Python 3, 80 Bytes

Pythons Lambdas unterstützen anscheinend die Rekursion, wer wusste das schon?

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

Dies ist ein Gegenstück / Kompliment zu Orlps Antwort.

Groovy, 92 Bytes

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

Gestapelt , 27 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe von der Stapelspitze und lässt die Ausgabe auf STDOUT. Dies ist einfach, indem Sie eine Tiefenkarte erstellen, die - dZeiten wiederholen , mit '>' und dem Element selbst verknüpfen.

Gema, 63 Zeichen

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

Genauso wie bei den anderen Analyselösungen wird davon ausgegangen, dass die Zeichenfolgen keine Anführungszeichen enthalten.

Probelauf:

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 zeichen

( 67 64 Zeichen Code + 3 Zeichen Befehlszeilenoption)

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

Probelauf:

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

Online-Test