Bạn sẽ được cung cấp một mảng lồng nhau. Chương trình của bạn phải trực quan hóa mảng.

Nhưng bằng cách nào?

Ví dụ: giả sử chúng ta có một mảng lồng nhau, như thế nào [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Mảng lồng nhau này có thể được hình dung như sau:

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

Ví dụ

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

Quy tắc

• Bạn có thể sử dụng chuỗi (hoặc các loại khác hoạt động như một mảng lồng nhau) làm đầu vào.
• Mức "lớp" tối đa là 2 ^ 32-1.

APL, 32 byte

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

Kiểm tra:

      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

Giải trình:

• {... }∘0: Chạy chức năng sau với 0ràng buộc ⍵:
  • 1=≡⍺:: nếu đầu vào có độ sâu 1 (tức là một mảng không chứa các mảng khác):
    • ⍵/'->': tạo một chuỗi chứa ⍵ -s và ⍵ >s,
    • 1↓: thả phần tử đầu tiên,
    • ⍵↑: và lấy các ⍵yếu tố đầu tiên . Điều này dẫn đến một chuỗi chứa ⍵-1dấu gạch ngang và một >.
    • ⍺,⍨: nối thêm đầu vào cho nó,
    • ⎕←: và xuất nó ra màn hình
  • ⋄: nếu không thì,
    • ⍺∇¨⍵+1: thêm 1 vào ⍵và áp dụng hàm cho từng mảng lồng nhau

Toán học, 58 57 56 byte

Cảm ơn Greg Martin đã tiết kiệm 1 byte.

Cảm ơn ngenisis vì đã tiết kiệm 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 nhờ @ Barteks2x

Giải trình:

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

Mã kiểm tra:

Hãy thử nó ở đây.

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

Đầu ra:

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

Lưu 4 byte nhờ @manatwork.

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

Hàm đệ quy, yêu cầu PHP 7.1 hoặc mới hơn cho chỉ mục chuỗi âm.
^{"$e"là Arrayđối với mảng; như vậy "$e"!=$elà giống như is_array($e).}

• bắt đầu bằng tiền tố >
• thêm một -tiền tố cho mỗi cấp
• in tiền tố + phần tử + dòng mới cho các nguyên tử

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

hình thức mở rộng:

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

Điều này có một chuỗi trong định dạng chính xác và chấm dứt khi tìm kết quả khớp cuối cùng ].

Nó không sử dụng đệ quy và sử dụng các loại dài để thực sự đạt được quy tắc thứ hai: 2 ^ 32-1 cấp . Hầu hết các ngôn ngữ kịch bản lệnh có độ sâu đệ quy giới hạn hoặc đơn giản là sự cố khi tràn ngăn xếp.

Tôi không quen chơi golf ở C, mọi sự giúp đỡ đều được đánh giá cao :)

Cảm ơn tại bolov cho lời khuyên của mình! Đặc biệt cảm ơn Titus, người luôn sẵn sàng cho một vòng golf tốt (ngay cả trong C)!

Hai byte khác được lưu bởi thực tế là chúng ta có thể kết thúc một khi chúng ta khớp cuối cùng ]và không cần khớp với char char.

Nó có thể được thử nghiệm tại Wandbox .

JavaScript (ES6), 58 51 byte

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

Chỉnh sửa: Đã lưu 7 byte khi @Arnauld chỉ ra rằng tôi có thể kết hợp hai cách tiếp cận của mình.

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

giải pháp lặp lấy chuỗi từ STDIN:
Chạy với echo '<input>' | php -nR '<code>'hoặc kiểm tra trực tuyến .

phá vỡ

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

Hạnh phúc vì những con số được trích dẫn; vì vậy tôi chỉ cần một hành động tại một thời điểm

Câu đố 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"

Thêm 3 dấu gạch ngang vào $pvà xóa 2 cho [, 4 cho ]thêm một cho [và xóa một cho ].

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

Ngay bây giờ câu trả lời của tôi luôn bắt đầu mà không có dấu gạch ngang, đó ["foo", "bar"]là:

>foo
>bar

Perl 5 , 55 byte

53 byte mã + -nlcờ.

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

Hãy thử trực tuyến!

Không tối ưu cho regex vì một số trường hợp sắc nét có khả năng xảy ra (đặc biệt, nếu một phần tử của mảng chứa dấu ngoặc bên trong).
Hàm ẩn danh đệ quy sẽ chỉ dài hơn (61 byte):

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

Hãy thử trực tuyến!

Nhưng cách Perl xử lý các tham số không tối ưu cho các chức năng chơi gôn: không có tham số tùy chọn nào có nghĩa là tôi phải thực hiện chức năng thứ hai (ẩn danh) gọi hàm đầu tiên và tôi phải nhận được tham số cuối cùng với thời gian dài đó my$v=pop.

Ruby, 49 45 46 byte

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

Thí dụ:

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

Giải trình:

Hàm đệ quy: if x==[*x]thì x là một mảng và chúng ta lặp lại trên nó. Nếu không, thụt lề nó.

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 không có các danh sách lồng nhau với các độ sâu khác nhau, vì vậy tôi phải tự phân tích chuỗi đầu vào. May mắn thay, chức năng thư viện readscó thể phân tích các chuỗi (tức là "chuỗi char đã được thêm vào), vì vậy tôi có một chút trợ giúp ở đây.

Ví dụ sử dụng:

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

Hãy thử trực tuyến! .

Làm thế nào nó hoạt động:

Hàm #đi qua chuỗi char bằng char và giữ mức lồng nhau (tham số đầu tiên l) dưới dạng chuỗi -với cuối cùng >. Nếu phần đầu của danh sách có thể được phân tích cú pháp dưới dạng Chuỗi, hãy lấy lvà Chuỗi theo sau là cuộc gọi đệ quy với Chuỗi bị xóa. Nếu char đầu tiên là Space, hãy bỏ qua nó. Nếu đó là một ,, hãy lấy một dòng mới và tiếp tục, nếu đó là ], hạ thấp mức lồng và tiếp tục và nếu không (chỉ [còn lại) nâng mức lồng và tiếp tục. Đệ quy kết thúc với chuỗi đầu vào trống. Hàm chính (">"#)đặt mức lồng nhau ">"và các cuộc gọi #.

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

Ngắt dòng được thêm vào chỉ để dễ đọc, không bao gồm trong số byte.

p vị ngữ đi qua đệ quy các mảng, thêm '-' vào tiền tố F khi di chuyển một mức sâu hơn. wđược sử dụng để ghi mảng tiền tố cũng như phần tử thực tế vào đầu ra.

Thí dụ:

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

Mẻ, 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

Annoyingly Batch gặp khó khăn khi so sánh dấu phẩy. Chạy mẫu:

[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

Võng mạc , 63 54 52 byte

Đã lưu 2 byte nhờ Martin Ender

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

-"
>
T`]"

Hãy thử trực tuyến!

Giải trình

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

Đầu tiên, mảng được chia nhỏ bằng cách thay thế từng chuỗi được trích dẫn bằng mọi thứ xuất hiện trước nó, cộng với chính nó, cộng với một dòng mới. Bằng cách phá vỡ nó như thế này, bạn có thể tìm thấy dấu ngoặc mở chưa từng có trước mỗi chuỗi.

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

Phiên âm này sẽ thay thế [bằng -, ]không thay đổi và xóa mọi ký tự khác (  -~là tất cả ASCII có thể in được). Tuy nhiên, nó chỉ thay thế các ký tự xuất hiện trước chuỗi cuối cùng trên mỗi dòng.

-]

Tiếp theo tất cả các trường hợp -]được loại bỏ. Chúng tương ứng với các cặp ngoặc phù hợp và chúng tôi chỉ muốn các dấu ngoặc không khớp. Sau khi những cái này bị xóa, mỗi dòng có một số -s bằng với bao nhiêu dấu ngoặc mở chưa từng có trước nó.

-"
>

Cái cuối cùng -trước khi a "được thay thế bằng >, để tạo thành các mũi tên.

T`]"

Cuối cùng, tất cả các ]s và s còn lại "sẽ bị xóa.

Röda , 54 byte

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

Hãy thử trực tuyến!

Đây là một chức năng đọc mảng đầu vào từ luồng. Đối với mỗi mục, nó tự gọi đệ quy hoặc in mục đó.

Python 3, 80 byte

Dường như lambdas hỗ trợ đệ quy, ai biết?

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

Đây là một phản biện / khen ngợi câu trả lời của 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")};

Xếp chồng lên nhau , 27 byte

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

Hãy thử trực tuyến!

Lấy đầu vào từ đầu ngăn xếp và để lại đầu ra trên STDOUT. Điều này đơn giản như thực hiện bản đồ độ sâu, lặp lại - dthời gian, nối với '>' và chính phần tử.

Gema, 63 ký tự

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

Giống như các giải pháp phân tích cú pháp khác, giả sử sẽ không có dấu ngoặc kép nào thoát trong chuỗi.

Chạy mẫu:

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 ký tự

( 67 mã 64 ký tự + tùy chọn dòng lệnh 3 ký tự)

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

Chạy mẫu:

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

Bài kiểm tra trực tuyến