Size iç içe bir dizi verilecektir. Programınız diziyi görselleştirmelidir.

Ama nasıl?

Örneğin, diyelim ki yuvalanmış bir dizimiz var [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Bu iç içe dizi şu şekilde görselleştirilebilir:

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

Örnekler

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

kurallar

• Girdi olarak dize (veya iç içe dizi gibi çalışan başka türler) kullanabilirsiniz.
• "Katmanların" maksimum seviyesi 2 ^ 32-1'dir.

APL, 32 bayt

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

Ölçek:

      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

Açıklama:

• {... }∘0: aşağıdakine 0bağlı olarak aşağıdaki işlevi çalıştırır ⍵:
  • 1=≡⍺:: giriş derinliği 1 ise (diğer bir diziyi içermeyen bir dizi):
    • ⍵/'->': ⍵ -s ve ⍵ >s içeren bir dize oluşturun ,
    • 1↓: ilk öğeyi bırak,
    • ⍵↑: ve ilk ⍵unsurları ele alalım . Bu, ⍵-1tire ve bir içeren bir dize ile sonuçlanır >.
    • ⍺,⍨: girişi ona ekleyin,
    • ⎕←: ve bunu ekrana çıktılar
  • ⋄: aksi takdirde,
    • ⍺∇¨⍵+1: ⍵her iç içe diziye 1 ekleyin ve işlevi uygulayın

Mathematica, 58 57 56 bayt

1 bayt kaydettiği için Greg Martin'e teşekkürler.

1 bayt tasarruf için ngenisis'e teşekkürler.

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

Java 7, 153 141 114 bayt

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

@ Barteks2x sayesinde -39 bayt

Açıklama:

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

Test kodu:

Burada deneyin.

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

Çıktı:

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

@Manatwork sayesinde 4 bayt kurtarıldı.

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

özyinelemeli işlev, negatif dize dizini için PHP 7.1 veya daha yenisini gerektirir.
^{"$e"olan Arraydiziler için; böylece "$e"!=$eaynıdır is_array($e).}

• önek ile başla >
• başına a -her seviye için önekin
• atomlar için önek + eleman + yeni satır yazdır

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

Genişletilmiş biçim:

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

Bu, doğru biçimde bir dize alır ve son eşleşmeyi bulurken sona erer ].

Özyineleme kullanmaz ve ikinci kuralı gerçekleştirmek için uzun türleri kullanır : 2 ^ 32-1 seviyeleri . Komut dosyası oluşturma dillerinin çoğunun sınırlı bir yineleme derinliği vardır veya yığın taşması sırasında çöker.

C golf için alışkın değilim herhangi bir yardım takdir :)

Onun ipuçları için bolov teşekkürler! Özellikle her zaman iyi bir golf turu (C'de bile) olan Titus'a teşekkürler!

Son iki eşleştikten sonra bitirebileceğimiz ]ve boş bir karakterle eşleşmemiz gerekmediği gerçeğiyle kaydedilen iki bayt daha .

Wandbox'ta test edilebilir .

JavaScript (ES6), 58 51 bayt

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

Düzenleme: @Arnauld benim iki yaklaşım birleştirebilir işaret ettiğinde 7 bayt kaydedildi.

PHP, 129123121105 95 93 91 bayt

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

yinelemeli çözüm dizeyi STDIN'den alır: Çevrimiçi olarak
çalıştırın echo '<input>' | php -nR '<code>'veya test edin .

Yıkmak

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

Mutlu sayılar tırnak içinde; bu yüzden her seferinde sadece bir eyleme ihtiyacım var.

ASCII ile mücadele

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"

İçin 3 tire ekleyerek $p2 için [, 4 için ]bir tire ekler [ve için bir tire ekler ].

Python 2, 65 64 bayt

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

Şu anda cevabım sürekli olarak tire olmadan başlıyor, yani ["foo", "bar"]:

>foo
>bar

Perl 5 , 55 bayt

53 bayt kod + -nlbayrak.

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

Çevrimiçi deneyin!

Potansiyel olarak meydana gelebilecek bazı sinirli durumlar nedeniyle regex için optimal değildir (özellikle, dizinin bir öğesi içinde köşeli ayraçlar varsa).
Yinelemeli bir anonim işlev ancak 61 bayt kadar uzun olamaz:

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

Çevrimiçi deneyin!

Ancak Perl'in parametrelerle uğraşma şekli golf işlevleri için en uygun değildir: isteğe bağlı parametreler yok, ilkini çağıran ikinci bir işlev (anonim) yapmak zorunda olduğum anlamına gelir ve son parametreyi açıkça bu kadar uzun süre almak zorundayım my$v=pop.

Yakut, 49 45 46 bayt

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

Misal:

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

Açıklama:

Özyinelemeli işlev: eğer x==[*x]o zaman x bir dizi ise ve onu tekrar ederiz. Değilse, girinti yapın.

Haskell, 104 bayt

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'in farklı derinliklere sahip iç içe listeleri yok, bu yüzden girdi dizesini kendi başıma ayrıştırmam gerekiyor. Neyse ki kütüphane işlevi readsDizeleri (yani- "kapalı char dizisi) ayrıştırabilir , bu yüzden burada biraz yardım var.

Kullanım örneği:

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

Çevrimiçi deneyin! .

Nasıl çalışır:

İşlevi #char ile karakter dizisinden geçer ve iç içe geçme düzeyini (ilk parametre l) -final içeren bir dize olarak tutar >. Listenin başı Dize olarak ayrıştırılabilirse l, Dize alındıktan sonra Dize'yi alıp ardından özyinelemeli çağrı gelir. İlk karakter bir Boşluk ise, atlayın. A ise ,, bir satırsonu alın ve devam edin, eğer varsa ], yuvalama seviyesini düşürün ve devam edin ve başka (sadece [solda) yuvalama seviyesini yükseltin ve devam edin. Özyineleme, boş giriş dizesiyle biter. Ana işlev (">"#), iç içe geçme seviyesini ">"ve çağrılarını ayarlar #.

SWI-Prolog, 115 bayt

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

Bayt sayısına dahil edilmeyen yalnızca okunabilirlik için satır sonları eklendi.

pyüklem, dizileri yinelemeli olarak tarar ve Fbir düzey daha derine giderken önek için bir '-' ekler .wçıktıya önek dizisini ve gerçek öğeyi yazmak için kullanılır.

Misal:

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

Toplu, 249 bayt

@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

Can sıkıcı bir şekilde, Batch virgül karşılaştırma konusunda sorun yaşıyor. Örnek çalışma:

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

Martin Ender sayesinde 2 bayt tasarruf edildi

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

-"
>
T`]"

Çevrimiçi deneyin!

açıklama

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

Birincisi, dizi, alıntı yapılan her bir dizeyi kendisinden önce gelen her şeyle artı kendisinin yanı sıra bir yeni satırla değiştirerek parçalanır. Bu şekilde parçalayarak, her dizeden önce eşsiz açılış köşeli parantezlerini bulmak mümkündür.

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

Yerini alacak Bu harf çevirisi [ile -, ayrılmak ]değişmeden, ve diğer her karakteri silin (  -~tüm yazdırılabilir ASCII) olduğunu. Ancak, yalnızca her satırdaki son dizeden önce görünen karakterlerin yerini alır.

-]

Sonra, tüm örnekleri -]kaldırılır. Bunlar eşleşen braket çiftlerine karşılık gelir ve biz sadece eşsiz braketler isteriz. Bunlar kaldırıldıktan sonra, her satırdan -önce eşleşmeyen kaç açılış köşeli parantezine eşit sayıda s vardır.

-"
>

A'dan -önceki son "ile >oklar oluşturulur.

T`]"

Son olarak, kalan tüm ]s ve "s silinir.

Röda , 54 bayt

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

Çevrimiçi deneyin!

Akıştan girdi dizisini okuyan bir işlevdir. Her öğe için, kendini özyinelemeli olarak çağırır veya öğeyi yazdırır.

Python 3, 80 Bayt

Python'un lambdasları özyinelemeyi destekliyor gibi görünüyor, kim biliyordu?

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

Bu, orlp'nin cevabına bir karşı / iltifattır .

Groovy, 92 bayt

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

Yığılmış , 27 bayt

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

Çevrimiçi deneyin!

Yığının üstünden girdi alır ve çıktıyı STDOUT'ta bırakır. Bu, derinlik haritası yapmak, - dsüreleri tekrarlamak , '>' ve öğenin kendisi ile birleştirmek kadar basittir .

Gema, 63 karakter

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

Diğer ayrıştırma çözümleri gibi, dizelerde kaçan çift tırnak olmayacağını varsayar.

Örnek çalışma:

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 kod + 3 karakter komut satırı seçeneği)

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

Örnek çalışma:

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

Çevrimiçi test