คุณจะได้รับอาร์เรย์ที่ซ้อนกัน โปรแกรมของคุณจะต้องเห็นภาพอาร์เรย์

แต่ .. ได้อย่างไร

ตัวอย่างเช่นสมมติว่าเรามีอาร์เรย์ที่ซ้อนกันเช่น [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]ตัวอย่างเช่นสมมติว่าเรามีอาร์เรย์ที่ซ้อนกันเช่น

อาร์เรย์ที่ซ้อนกันนี้สามารถมองเห็นได้เป็น:

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

ตัวอย่าง

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

กฎระเบียบ

• คุณสามารถใช้สตริง (หรือประเภทอื่นซึ่งทำงานเหมือนอาร์เรย์ที่ซ้อนกัน) เป็นอินพุต
• ระดับสูงสุดของ "เลเยอร์" คือ 2 ^ 32-1

APL, 32 ไบต์

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

ทดสอบ:

      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

คำอธิบาย:

• {... }∘0: เรียกใช้ฟังก์ชันต่อไปนี้โดย0ผูกกับ⍵:
  • 1=≡⍺:: ถ้าอินพุตมีความลึก 1 (เช่นอาร์เรย์ที่ไม่มีอาร์เรย์อื่น):
    • ⍵/'->': สร้างสตริงที่มี⍵ -s และ⍵ >s
    • 1↓: วางองค์ประกอบแรก
    • ⍵↑: และใช้⍵องค์ประกอบแรก สิ่งนี้ส่งผลให้เป็นสตริงที่มี⍵-1เครื่องหมายขีดกลางและอีก>อัน
    • ⍺,⍨: เพิ่มอินพุตต่อท้าย
    • ⎕←: และส่งออกไปยังหน้าจอ
  • ⋄: มิฉะนั้น,
    • ⍺∇¨⍵+1: เพิ่ม 1 ถึง⍵และใช้ฟังก์ชันกับแต่ละอาร์เรย์ที่ซ้อนกัน

Mathematica, 58 57 56 ไบต์

ขอบคุณ Greg Martin ที่ช่วยประหยัด 1 ไบต์

ขอบคุณ ngenisis สำหรับการบันทึก 1 ไบต์

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

Java 7, 153 141 114 ไบต์

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 ไบต์ขอบคุณ@ Barteks2x

คำอธิบาย:

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

รหัสทดสอบ:

ลองที่นี่

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

เอาท์พุท:

->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 ไบต์

บันทึกได้ 4 ไบต์ขอบคุณ @manatwork

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

ฟังก์ชันเรียกซ้ำต้องการ PHP 7.1 หรือใหม่กว่าสำหรับดัชนีสตริงลบ
^{"$e"คือArrayสำหรับอาร์เรย์; เช่น"$e"!=$eเดียวกับis_array($e)เป็นเช่นเดียวกับ}

• เริ่มต้นด้วยคำนำหน้า >
• เสริม a -คำนำหน้าให้กับแต่ละระดับ
• พิมพ์คำนำหน้า + องค์ประกอบ + บรรทัดใหม่สำหรับอะตอม

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

รูปแบบการขยายตัว:

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

นี่จะเป็นสตริงในรูปแบบที่ถูกต้องและสิ้นสุดลงเมื่อค้นหาการจับคู่ครั้งสุดท้าย ]นี้จะใช้เวลาสตริงในรูปแบบที่ถูกต้องและยุติเมื่อพบการจับคู่ที่ผ่านมา

ไม่ใช้การเรียกซ้ำและใช้ชนิดแบบยาวเพื่อให้ได้ตามกฎข้อที่สอง: 2 ^ 32-1 ระดับระดับ ภาษาสคริปต์ส่วนใหญ่มีความลึกในการเรียกซ้ำ จำกัด หรือเกิดความผิดพลาดจากการโอเวอร์โฟลว์แบบสแต็ก

ฉันไม่คุ้นเคยกับการเล่นกอล์ฟใน C ชื่นชมความช่วยเหลือใด ๆ :)

ขอบคุณที่ bolov สำหรับเคล็ดลับของเขา! ขอขอบคุณเป็นพิเศษสำหรับติตัสผู้ซึ่งพร้อมเสมอสำหรับการเล่นกอล์ฟ (แม้ใน C)!

อีกสองไบต์บันทึกไว้โดยความจริงที่ว่าเราสามารถเสร็จสิ้นเมื่อเราจับคู่สุดท้าย ]และไม่จำเป็นต้องตรงกับตัวละครที่เป็นโมฆะ

สามารถทดสอบได้ที่ Wandbox

JavaScript (ES6), 58 51 ไบต์

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

แก้ไข: บันทึกแล้ว 7 ไบต์เมื่อ @Arnauld ชี้ให้เห็นว่าฉันสามารถรวมสองวิธีเข้าด้วยกัน

PHP, 129 123 112 109 95 93 91 ไบต์

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

วิธีการแก้ปัญหาซ้ำใช้เวลาสตริงจาก STDIN:
ทำงานด้วยecho '<input>' | php -nR '<code>'หรือทดสอบออนไลน์

ชำรุด

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

มีความสุขที่ตัวเลขอยู่ในเครื่องหมายคำพูด; ดังนั้นฉันต้องการเพียงหนึ่งการกระทำในเวลาเดียว

เล่นซอ 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"

การเพิ่มขีดกลาง 3 ไป$pและลบ 2 [, 4 สำหรับ]เพิ่มหนึ่งและลบหนึ่งสำหรับ[]

Python 2, 65 64 ไบต์

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

ตอนนี้คำตอบของฉันเริ่มต้นอย่างต่อเนื่องโดยไม่มีเครื่องหมายขีดคั่นดังนั้น["foo", "bar"]:

>foo
>bar

Perl 5 , 55 ไบต์

53 ไบต์ของรหัส + -nlค่าสถานะ

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

ลองออนไลน์!

ไม่เหมาะสำหรับ regex เนื่องจากบางกรณีที่อาจเกิดขึ้น (โดยเฉพาะถ้าองค์ประกอบของอาร์เรย์มีวงเล็บอยู่ภายใน)
ฟังก์ชั่นไม่ระบุชื่อแบบเรียกซ้ำจะแทบจะนานกว่า (61 ไบต์):

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

ลองออนไลน์!

แต่วิธีที่ Perl เกี่ยวข้องกับพารามิเตอร์นั้นไม่เหมาะสำหรับฟังก์ชั่นการเล่นกอล์ฟ: ไม่มีพารามิเตอร์ทางเลือกหมายความว่าฉันต้องทำฟังก์ชั่นที่สอง (ไม่ระบุชื่อ) เรียกชื่อแรกและฉันต้องรับพารามิเตอร์สุดท้ายด้วยความยาวmy$v=popนั้น

Ruby, 49 45 46 ไบต์

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

ตัวอย่าง:

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

คำอธิบาย:

ฟังก์ชั่นวนซ้ำ: ถ้าx==[*x]งั้น x จะเป็นอาร์เรย์และเราวนซ้ำ ถ้าไม่เยื้องมัน

Haskell, 104 ไบต์

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 ไม่มีรายการซ้อนกันที่มีความลึกแตกต่างกันดังนั้นฉันจึงต้องวิเคราะห์สตริงอินพุตด้วยตัวเอง โชคดีที่ฟังก์ชั่นห้องสมุดreadsสามารถแยกสตริงได้ (เช่น" -enclosed char sequence) ดังนั้นฉันจึงมีความช่วยเหลือเล็กน้อยที่นี่

ตัวอย่างการใช้งาน:

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

ลองออนไลน์!.

มันทำงานอย่างไร:

ฟังก์ชั่น#ผ่านไปถ่านสตริงโดยถ่านและช่วยให้ระดับการซ้อน (พารามิเตอร์แรกl) เป็นสตริงของด้วยเป็นครั้งสุดท้าย- >หากส่วนหัวของรายการสามารถแยกวิเคราะห์เป็นสตริงใช้lและสตริงตามด้วยการเรียกซ้ำด้วยการเอาสตริงออก หากตัวแรกคือช่องว่างให้ข้ามมัน หากเป็น a ,ให้ขึ้นบรรทัดใหม่และดำเนินการต่อไปถ้าเป็น]ให้ลดระดับการซ้อนและดำเนินการต่อไปและอื่น ๆ ( [เหลือเพียงทางเดียว) ยกระดับการทำรังและทำต่อไป การเรียกซ้ำจะสิ้นสุดลงด้วยสตริงอินพุตว่าง ฟังก์ชั่นหลัก(">"#)กำหนดระดับการซ้อนไปและบริการโทร">"#

SWI-Prolog 115 ไบต์

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

เพิ่มตัวแบ่งบรรทัดสำหรับการอ่านเท่านั้นไม่รวมอยู่ในจำนวนไบต์

pเพรดิเคตวนซ้ำ traverses อาร์เรย์เพิ่ม '-' ไปยังคำนำหน้าFเมื่อเลื่อนระดับลึก wใช้ในการเขียนคำนำหน้าอาร์เรย์เช่นเดียวกับองค์ประกอบที่เกิดขึ้นจริงเพื่อการส่งออก

ตัวอย่าง:

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

แบตช์ 249 ไบต์

@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

ชุดที่น่ารำคาญมีปัญหาในการเปรียบเทียบเครื่องหมายจุลภาค วิ่งตัวอย่าง:

[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 ไบต์

บันทึก 2 ไบต์ขอบคุณ Martin Ender

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

-"
>
T`]"

ลองออนไลน์!

คำอธิบาย

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

ขั้นแรกอาร์เรย์จะถูกแยกย่อยโดยแทนที่สตริงที่มีเครื่องหมายคำพูดแต่ละตัวด้วยทุกสิ่งที่อยู่ตรงหน้ามันรวมทั้งตัวมันเองบวกกับการขึ้นบรรทัดใหม่ โดยการแบ่งมันออกเป็นเช่นนี้เป็นไปได้ที่จะหาวงเล็บเปิดที่ไม่ตรงกันก่อนแต่ละสตริง

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

ทับศัพท์นี้จะแทนที่[ด้วย-ออก]ไม่เปลี่ยนแปลงและลบทุกตัวละครอื่น ๆ (  -~เป็น ASCII พิมพ์) อย่างไรก็ตามมันจะแทนที่ตัวละครที่ปรากฏก่อนที่สตริงสุดท้ายในแต่ละบรรทัด

-]

ถัดไปทุกอินสแตนซ์ของ-]จะถูกลบออก สิ่งเหล่านี้สอดคล้องกับคู่ของวงเล็บจับคู่และเราต้องการเพียงวงเล็บเหลี่ยมที่ไม่ตรงกัน หลังจากลบสิ่งเหล่านี้แล้วแต่ละบรรทัดจะมีจำนวน-s เท่ากับจำนวนวงเล็บเปิดที่ไม่มีใครเทียบมาก่อน

-"
>

ครั้งสุดท้าย-ก่อนที่"จะถูกแทนที่ด้วย>เพื่อสร้างลูกศร

T`]"

ในที่สุด]s และ s ที่เหลือทั้งหมด"จะถูกลบ

Röda , 54 ไบต์

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

ลองออนไลน์!

เป็นฟังก์ชันที่อ่านอาร์เรย์อินพุตจากสตรีม สำหรับแต่ละรายการมันอาจเรียกตัวเองซ้ำหรือพิมพ์รายการ

Python 3, 80 ไบต์

Lambdas ของ Python ให้การสนับสนุนการเวียนของมันซ้ำใครจะรู้?

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

นี่คือการตอบโต้ / ชมเชยคำตอบของ orlp

Groovy, 92 ไบต์

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

ซ้อนกัน 27 ไบต์

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

ลองออนไลน์!

รับอินพุตจากด้านบนของสแต็กและปล่อยเอาต์พุตบน STDOUT สิ่งนี้ง่ายเหมือนการทำแผนที่ความลึก- dเวลาทำซ้ำเชื่อมต่อกับ '>' และองค์ประกอบเอง

Gema, 63 ตัวอักษร

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

เช่นเดียวกับโซลูชันการแยกวิเคราะห์อื่น ๆ สมมติว่าจะไม่มีการใส่เครื่องหมายคำพูดคู่ในสตริง

วิ่งตัวอย่าง:

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 ตัวอักษร

( ตัวเลือกบรรทัดคำสั่งรหัส67 64 ตัวอักษร + 3 ตัวอักษร)

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

วิ่งตัวอย่าง:

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

การทดสอบออนไลน์