Otrzymasz zagnieżdżoną tablicę. Twój program musi wizualizować tablicę.

Ale jak?

Załóżmy na przykład, że mamy zagnieżdżoną tablicę, np [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Tę zagnieżdżoną tablicę można wizualizować jako:

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

Przykłady

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

Zasady

• Możesz użyć ciągu znaków (lub innych typów, które działają jak tablica zagnieżdżona) jako danych wejściowych.
• Maksymalny poziom „warstw” wynosi 2 ^ 32-1.

APL, 32 bajty

{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

Wyjaśnienie:

• {... }∘0: uruchom następującą funkcję 0związaną z ⍵:
  • 1=≡⍺:: jeśli wejście ma głębokość 1 (tj. tablica, która nie zawiera innych tablic):
    • ⍵/'->': utwórz ciąg zawierający ⍵ -s i ⍵ >s,
    • 1↓: upuść pierwszy element,
    • ⍵↑: i weź pierwsze ⍵elementy. Daje to ciąg zawierający ⍵-1myślniki i jeden >.
    • ⍺,⍨: dołącz do niego dane wejściowe,
    • ⎕←: i wyślij to na ekran
  • ⋄: Inaczej,
    • ⍺∇¨⍵+1: dodaj 1 ⍵i zastosuj funkcję do każdej zagnieżdżonej tablicy

Mathematica, 58 57 56 bajtów

Dziękujemy Gregowi Martinowi za uratowanie 1 bajtu.

Dzięki ngenisis za oszczędność 1 bajtu.

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

Java 7, 153 141 114 bajtów

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 bajtów dzięki @ Barteks2x

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wynik:

->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 bajtów

4 bajty zapisane dzięki @manatwork.

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

funkcja rekurencyjna, wymaga PHP 7.1 lub nowszego dla indeksu ciągu ujemnego.
^{"$e"jest Arraydla tablic; więc "$e"!=$ejest taki sam jak is_array($e).}

• zacznij od przedrostka >
• dodawaj a -do prefiksu dla każdego poziomu
• wydrukuj prefiks + element + nowa linia dla atomów

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

rozszerzona forma:

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

Pobiera ciąg w prawidłowym formacie i kończy się po znalezieniu ostatniego dopasowania ].

Nie używa rekurencji i używa długich typów do faktycznie osiągnąć drugą zasadę: 2 ^ 32-1 poziomy . Większość języków skryptowych ma ograniczoną głębokość rekurencji lub po prostu ulega awarii przy przepełnieniu stosu.

Nie jestem przyzwyczajony do gry w golfa w C jakakolwiek pomoc jest mile widziana :)

Dzięki w bolovie za jego wskazówki! Szczególnie dzięki Titusowi, który zawsze jest gotowy na dobrą rundę gry w golfa (nawet w C)!

Kolejne dwa bajty zapisane dzięki temu, że możemy skończyć, gdy dopasujemy ostatni ] i nie musimy dopasowywać znaku zerowego.

Można to przetestować w Wandbox .

JavaScript (ES6), 58 51 bajtów

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

Edycja: Zapisano 7 bajtów, gdy @Arnauld wskazał, że mogę połączyć moje dwa podejścia.

PHP, 129 123 112 109 95 93 91 bajtów

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

iteracyjne rozwiązanie pobiera ciąg znaków ze STDIN:
Uruchom go echo '<input>' | php -nR '<code>'lub przetestuj online .

awaria

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

Szczęśliwy, że liczby są w cudzysłowie; więc potrzebuję tylko jednej akcji na raz.

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

Dodanie 3 myślników $pi usunięcie 2 dla [, 4 dla ]dodaje jeden dla [i usuwa jeden dla ].

Python 2, 65 64 bajtów

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

W tej chwili moja odpowiedź konsekwentnie zaczyna się bez myślników, więc ["foo", "bar"]jest to:

>foo
>bar

Perl 5 , 55 bajtów

53 bajty kodu + -nlflagi.

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

Wypróbuj online!

Nie jest optymalny dla wyrażenia regularnego z powodu pewnych ostrych przypadków, które mogą potencjalnie wystąpić (w szczególności, jeśli element tablicy zawiera nawiasy wewnątrz).
Rekurencyjna funkcja anonimowa byłaby jednak niewiele dłuższa (61 bajtów):

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

Wypróbuj online!

Ale sposób, w jaki Perl radzi sobie z parametrami, nie jest optymalny dla funkcji golfowych: brak parametrów opcjonalnych oznacza, że ​​muszę wykonać drugą funkcję (anonimową), wywołując pierwszą i muszę jawnie uzyskać ostatni parametr o takiej długości my$v=pop.

Rubin, 49 45 46 bajtów

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

Przykład:

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

Wyjaśnienie:

Funkcja rekurencyjna: jeśli x==[*x]wtedy x jest tablicą i iterujemy nad nią. Jeśli nie, wcięcie.

Haskell, 104 bajty

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 nie ma zagnieżdżonych list o różnych głębokościach, więc muszę samodzielnie parsować łańcuch wejściowy. Na szczęście funkcja biblioteki readsmoże analizować ciągi znaków (tj" parsować ciągi znaków Zamknięta sekwencja znaków), więc mam tutaj małą pomoc.

Przykład użycia:

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

Wypróbuj online!.

Jak to działa:

Funkcja #przechodzi przez ciąg char przez char i utrzymuje poziom zagnieżdżenia (pierwszy parametrl ) jako ciąg -z końcowym >. Jeśli nagłówek listy można przeanalizować jako ciąg, weź li ciąg, a następnie wywołanie rekurencyjne z usuniętym ciągiem. Jeśli pierwszym znakiem jest spacja, pomiń go. Jeśli tak ,, weź nowy wiersz i kontynuuj, jeśli tak ], obniż poziom zagnieżdżania i idź dalej, a także (tylko w [lewo) podnieś poziom zagnieżdżania i kontynuuj. Rekurencja kończy się pustym ciągiem wejściowym. Główna funkcja (">"#)ustawia poziom zagnieżdżenia na ">"i wywołuje #.

SWI-Prolog, 115 bajtów

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

Dodano podział wiersza tylko dla czytelności, nieuwzględniony w liczbie bajtów.

ppredykat rekurencyjnie przechodzi przez tablice, dodając przedrostek „-”, Fgdy poziom jest głębszy. wsłuży do zapisu tablicy wyjściowej, a także rzeczywistego elementu na wyjściu.

Przykład:

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

Partia, 249 bajtów

@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

Irytujące Batch ma problem z porównywaniem przecinków. Przykładowy przebieg:

[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

Siatkówka , 63 54 52 bajtów

Zaoszczędzono 2 bajty dzięki Martinowi Enderowi

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

-"
>
T`]"

Wypróbuj online!

Wyjaśnienie

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

Po pierwsze, tablica jest dzielona przez zamianę każdego cytowanego łańcucha na wszystko, co było przed nim, a także na samą siebie i na nową linię. Dzieląc go w ten sposób, można znaleźć niedopasowane nawiasy otwierające przed każdym ciągiem.

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

Ta transliteracja zamieni [się na -, pozostawi ]niezmienioną i usunie co drugi znak (  -~wszystkie ASCII można wydrukować). Zastępuje jednak tylko znaki pojawiające się przed końcowym ciągiem w każdej linii.

-]

Następnie wszystkie wystąpienia -]są usuwane. Odpowiadają one pasującym parom nawiasów i chcemy tylko niedopasowanych nawiasów. Po ich usunięciu każda linia ma liczbę -s równą liczbie niepasujących nawiasów otwierających poprzedzających ją.

-"
>

Ostatni -przed a "zastępuje się >, tworząc strzałki.

T`]"

Wreszcie, wszystkie pozostałe ]s i "s są usuwane.

Röda , 54 bajty

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

Wypróbuj online!

Jest to funkcja, która odczytuje tablicę wejściową ze strumienia. Dla każdego elementu wywołuje się rekurencyjnie lub drukuje element.

Python 3, 80 bajtów

Wydaje się, że lambda Pythona wspierają rekursję, kto wiedział?

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

Jest to kontrapunkt / komplement dla odpowiedzi orlp .

Groovy, 92 bajty

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

Ułożone , 27 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe z góry stosu i pozostawia dane wyjściowe w STDOUT. Jest to proste, jak robienie mapy głębokości, powtarzanie - dczasów, łączenie z „>” i samym elementem.

Gema, 63 znaki

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

Podobnie jak inne rozwiązania analizujące, zakłada się, że w ciągach znaków nie będzie żadnych podwójnych cudzysłowów.

Przykładowy przebieg:

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 znaków

( 67 64-znakowy kod + 3 znaki w wierszu poleceń)

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

Przykładowy przebieg:

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