Anda akan diberi array bersarang. Program Anda harus memvisualisasikan array.

Tapi bagaimana caranya?

Misalnya, mari kita asumsikan kita memiliki array bertingkat, seperti [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Array bersarang ini dapat divisualisasikan sebagai:

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

Contohnya

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

Aturan

• Anda dapat menggunakan string (atau tipe lain yang berfungsi seperti array bersarang) sebagai input.
• Level maksimum "lapisan" adalah 2 ^ 32-1.

APL, 32 byte

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

Uji:

      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

Penjelasan:

• {... }∘0: jalankan fungsi berikut dengan 0terikat ke ⍵:
  • 1=≡⍺:: jika input memiliki kedalaman 1 (yaitu array yang tidak mengandung array lain):
    • ⍵/'->': buat string yang mengandung ⍵ -s dan ⍵ >s,
    • 1↓: jatuhkan elemen pertama,
    • ⍵↑: dan ambil ⍵elemen pertama . Ini menghasilkan string yang berisi ⍵-1tanda hubung dan satu >.
    • ⍺,⍨: tambahkan input ke dalamnya,
    • ⎕←: dan output ke layar
  • ⋄: jika tidak,
    • ⍺∇¨⍵+1: tambahkan 1 ke ⍵dan terapkan fungsi ke setiap array bersarang

Mathematica, 58 57 56 byte

Terima kasih kepada Greg Martin untuk menghemat 1 byte.

Terima kasih kepada ngenisis karena telah menghemat 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 terima kasih kepada @ Barteks2x

Penjelasan:

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

Kode uji:

Coba di sini.

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

Keluaran:

->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 disimpan berkat @manatwork.

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

fungsi rekursif, membutuhkan PHP 7.1 atau lebih baru untuk indeks string negatif.
^{"$e"adalah Arrayuntuk array; begitu "$e"!=$ejuga dengan is_array($e).}

• mulai dengan awalan >
• tambahkan lebih dulu a - ke awalan untuk setiap level
• cetak awalan + elemen + baris baru untuk atom

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

formulir diperluas:

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

Ini mengambil string dalam format yang benar dan berakhir ketika menemukan pencocokan terakhir ] .

Itu tidak menggunakan rekursi dan menggunakan tipe panjang untuk benar - benar mencapai aturan kedua: 2 ^ 32-1 level . Sebagian besar bahasa scripting memiliki kedalaman rekursi terbatas atau hanya crash pada stack overflow.

Saya tidak terbiasa bermain golf di C, bantuan apa pun dihargai :)

Terima kasih di bolov untuk tipsnya! Terima kasih khusus kepada Titus yang selalu siap untuk bermain golf (bahkan di C)!

Dua byte lainnya disimpan oleh fakta bahwa kita dapat menyelesaikan setelah kita mencocokkan yang terakhir ]dan tidak perlu mencocokkan char null.

Itu dapat diuji di Wandbox .

JavaScript (ES6), 58 51 byte

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

Sunting: Disimpan 7 byte ketika @Arnauld menunjukkan bahwa saya dapat menggabungkan dua pendekatan saya.

PHP, 129 123 112 109 95 95 91 byte

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

solusi iteratif mengambil string dari STDIN:
Jalankan dengan echo '<input>' | php -nR '<code>'atau coba online .

kerusakan

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

Senang bahwa jumlahnya ada dalam tanda kutip; jadi saya hanya perlu satu tindakan pada satu waktu.

ASCII mengutak-atik

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"

Menambahkan 3 tanda hubung ke $pdan menghapus 2 untuk [, 4 untuk ]menambahkan satu untuk [dan menghapus satu untuk ].

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

Right now my answer consistently starts with no dashes, so ["foo", "bar"] is:

>foo
>bar

Perl 5, 55 bytes

53 bytes of code + -nl flags.

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

Try it online!

Not optimal for regex because of some edgy cases that could potentially occur (in particular, if an element of the array contains brackets inside).
A recursive anonymous function would be barely longer though (61 bytes):

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

Try it online!

But the way Perl deals with parameters isn't optimal for golfing functions: no optional parameters means I have to do a second function (anonymous) calling the first one, and I have to explicitly get the last parameter with that long my$v=pop.

Ruby, 49 45 46 bytes

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

Example:

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

Explanation:

Recursive function: if x==[*x] then x is an array, and we iterate over it. If not, indent it.

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 doesn't have nested lists with different depths, so I have to parse the input string on my own. Luckily the library function reads can parse Strings (i.e. "-enclosed char sequence), so I have a little help here.

Usage example:

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

Try it online!.

How it works:

The function # goes through the string char by char and keeps the nesting level (the first parameter l) as a string of - with a final >. If the head of the list can be parsed as a String, take l and the String followed by recursive call with the String removed. If the first char is a Space, skip it. If it's a ,, take a newline and go on, if it's ], lower the nesting level and go on and else (only [ left) raise the nesting level and go on. Recursion ends with the empty input string. The main function (">"#) sets the nesting level to ">" and calls #.

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

Jeda baris ditambahkan hanya untuk keterbacaan, tidak termasuk dalam jumlah byte.

ppredikat secara rekursif melintasi array, menambahkan '-' ke awalan Fsaat memindahkan level lebih dalam. wdigunakan untuk menulis array awalan serta elemen aktual ke output.

Contoh:

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

Mengganggu Batch mengalami kesulitan membandingkan koma. Contoh dijalankan:

[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

Disimpan 2 byte berkat Martin Ender

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

-"
>
T`]"

Cobalah online!

Penjelasan

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

Pertama, array dipecah dengan mengganti setiap string yang dikutip dengan semua yang datang sebelumnya, ditambah dirinya sendiri, ditambah dengan baris baru. Dengan memecahnya seperti ini, dimungkinkan untuk menemukan kurung pembuka yang tidak cocok sebelum setiap string.

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

Transliterasi ini akan diganti [dengan -, biarkan ]tidak berubah, dan hapus semua karakter lain (  -~semuanya dapat dicetak ASCII). Namun, itu hanya menggantikan karakter yang muncul sebelum string terakhir pada setiap baris.

-]

Selanjutnya semua instance -]dihapus. Ini sesuai dengan pasangan braket yang cocok, dan kami hanya ingin tanda kurung yang tidak cocok. Setelah ini dihapus, setiap baris memiliki jumlah -s sama dengan berapa banyak kurung pembuka yang tidak cocok datang sebelum itu.

-"
>

Terakhir -sebelum a "diganti dengan >, untuk membentuk panah.

T`]"

Akhirnya, semua yang tersisa ]dan "s akan dihapus.

Röda , 54 byte

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

Cobalah online!

Ini adalah fungsi yang membaca array input dari aliran. Untuk setiap item, ia memanggil dirinya sendiri secara rekursif atau mencetak item.

Python 3, 80 Bytes

Lambda Python mendukung rekursi, siapa tahu?

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

Ini adalah balasan / pujian untuk jawaban 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")};

Ditumpuk , 27 byte

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

Cobalah online!

Mengambil input dari atas tumpukan dan membiarkan output pada STDOUT. Ini sederhana seperti melakukan peta kedalaman, mengulangi - dwaktu, menyatu dengan '>' dan elemen itu sendiri.

Gema, 63 karakter

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

Seperti solusi penguraian lainnya, anggap tidak akan ada tanda kutip ganda yang lolos.

Contoh dijalankan:

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 karakter

( 67 64 karakter kode + 3 opsi opsi baris perintah)

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

Contoh dijalankan:

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

Tes online