Вам буде наданий вкладений масив. Ваша програма повинна візуалізувати масив.

Але як?

Наприклад, припустимо, у нас є вкладений масив, як [["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 до ⍵та застосуйте функцію до кожного вкладеного масиву

Математика, 58 57 56 байт

Дякуємо Грегу Мартіну за збереження 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).}

• почати з префікса >
• додайте -до префікса для кожного рівня
• друк префікса + елемент + новий рядок для атомів

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 рівні . Більшість мов сценаріїв мають обмежену глибину рекурсії або просто забиваються під час переповнення стека.

Я не звик до гольфу в С, будь-яка допомога вдячна :)

Дякую болову за його поради! Особливо дякую Тіту, який завжди готовий до хорошого раунду з гольфу (навіть у С)!

Ще два байти, врятовані тим, що ми можемо закінчити, як тільки ми порівняємо останній ] і не потрібно відповідати нульовому знаку.

Його можна перевірити на 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

Спробуйте в Інтернеті!

Не є оптимальним для регулярного вираження через деякі різкі випадки, які потенційно можуть статися (зокрема, якщо елемент масиву містить дужки всередині).
Рекурсивна анонімна функція була б ледь довшою (61 байт):

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

Спробуйте в Інтернеті!

Але те, як Perl має справу з параметрами, не є оптимальним для функцій гольфу: жодні необов'язкові параметри не означають, що я повинен виконувати другу функцію (анонімний), викликаючи першу, і я повинен явно отримати останній параметр з таким довгим my$v=pop.

Рубі, 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може проаналізувати рядки (тобто" закрита послідовність знаків), тому я маю тут невелику допомогу.

Приклад використання:

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

Спробуйте в Інтернеті!.

Як це працює:

Функція #проходить через рядок char за допомогою char і зберігає рівень введення (перший параметр l) у вигляді рядка -з остаточним >. Якщо заголовок списку можна проаналізувати як String, дістаньте lі String, після чого слід рекурсивний виклик із видаленою String. Якщо перший знак - пробіл, пропустіть його. Якщо це " ,візьміть", візьміть новий рядок і продовжуйте, якщо він є ], знизьте рівень гніздування і продовжуйте, а ще (лише [зліва) підніміть рівень гніздування і продовжуйте. Рекурсія закінчується порожнім вхідним рядком. Основна функція (">"#)встановлює рівень гніздування ">"та викликає #.

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предикат рекурсивно обходить масиви, додаючи префікс '-' 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

Дратівливо Batch має проблеми з порівнянням коми. Проба зразка:

[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

Сітківка , 63 54 52 байти

Збережено 2 байти завдяки Мартіну Ендеру

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

-"
>
T`]"

Спробуйте в Інтернеті!

Пояснення

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

По-перше, масив розбивається, замінюючи кожний рядок, що цитується, на все, що було до нього, плюс на себе, плюс новий рядок. Розбивши його таким чином, можна знайти незрівняні дужки відкриття перед кожною струною.

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

Ця транслітерації замінить [з -, залишити ]без змін, а також видалити будь-який інший символ (  -~всі печатки ASCII). Однак він замінює лише символи, що з’являються перед заключним рядком у кожному рядку.

-]

Далі всі екземпляри -]видаляються. Вони відповідають збіжним дужкам пар, і ми хочемо лише незрівняних дужок. Після їх вилучення кожен рядок має число -s, рівне кількості неперевершених дужок відкриття перед ним.

-"
>

Останній -перед a "замінюється на> , утворюючи стрілки.

T`]"

Нарешті всі решта ]s і "s видаляються.

Рода , 54 байти

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

Спробуйте в Інтернеті!

Це функція, яка зчитує вхідний масив з потоку. Для кожного елемента він або називає себе рекурсивно, або надрукує елемент.

Пітон 3, 80 байт

Лямбди Пітона підтримують рекурсію. Здається, хто знав?

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часи, поєднуючись з '>' та самим елементом.

Гема, 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

Онлайн-тест