Se le dará una matriz anidada. Su programa tiene que visualizar la matriz.

¿Pero cómo?

Por ejemplo, supongamos que tenemos una matriz anidada, como [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"].

Esta matriz anidada se puede visualizar como:

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

Ejemplos

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

Reglas

• Puede usar una cadena (u otros tipos que funcionan como una matriz anidada) como entrada.
• El nivel máximo de "capas" es 2 ^ 32-1.

APL, 32 bytes

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

Prueba:

      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

Explicación:

• {... }∘0: ejecuta la siguiente función 0vinculada a ⍵:
  • 1=≡⍺:: si la entrada tiene profundidad 1 (es decir, una matriz que no contiene otras matrices):
    • ⍵/'->': crea una cadena que contiene ⍵ -sy ⍵ >s,
    • 1↓: suelte el primer elemento,
    • ⍵↑: y toma los primeros ⍵elementos. Esto da como resultado una cadena que contiene ⍵-1guiones y uno >.
    • ⍺,⍨: agregarle la entrada,
    • ⎕←: y enviarlo a la pantalla
  • ⋄: de lo contrario,
    • ⍺∇¨⍵+1: agregue 1 ⍵y aplique la función a cada matriz anidada

Mathematica, 58 57 56 bytes

Gracias a Greg Martin por guardar 1 byte.

Gracias a ngenisis por guardar 1 byte.

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

Java 7, 153 141 114 bytes

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 bytes gracias a @ Barteks2x

Explicación:

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

Código de prueba:

Pruébalo aquí.

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

Salida:

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

4 bytes guardados gracias @manatwork.

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

función recursiva, requiere PHP 7.1 o posterior para el índice de cadena negativo.
^{"$e"es Arraypara matrices; entonces "$e"!=$ees lo mismo que is_array($e).}

• comenzar con el prefijo >
• anteponer un - al prefijo para cada nivel
• prefijo de impresión + elemento + nueva línea para átomos

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

forma expandida:

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

Esto toma una cadena en el formato correcto y termina cuando encuentra la última coincidencia ].

No usa recursividad y usa tipos largos para lograr la segunda regla: 2 ^ 32-1 niveles . La mayoría de los lenguajes de script tienen una profundidad de recursión limitada o simplemente se bloquean en el desbordamiento de la pila.

No estoy acostumbrado al golf en C, se agradece cualquier ayuda :)

¡Gracias a bolov por sus consejos! ¡Especialmente gracias a Titus que siempre está listo para una buena ronda de golf (incluso en C)!

Otros dos bytes guardados por el hecho de que podemos terminar una vez que coincidamos con el último ] y no sea necesario que coincida con un carácter nulo.

Se puede probar en Wandbox .

JavaScript (ES6), 58 51 bytes

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

Editar: Guarde 7 bytes cuando @Arnauld señaló que podía combinar mis dos enfoques.

PHP, 129 123 112 109 95 93 91 bytes

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

La solución iterativa toma una cadena de STDIN:
Ejecutar echo '<input>' | php -nR '<code>'o probar en línea .

Descompostura

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

Feliz de que los números estén entre comillas; así que solo necesito una acción a la vez.

Violín 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"

Agregar 3 guiones $py eliminar 2 para [, 4 para ]agrega uno para [y elimina uno para ].

Python 2, 65 64 bytes

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

En este momento mi respuesta comienza constantemente sin guiones, por lo que ["foo", "bar"]es:

>foo
>bar

Perl 5 , 55 bytes

53 bytes de código + -nlbanderas.

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

Pruébalo en línea!

No es óptimo para la expresión regular debido a algunos casos nerviosos que podrían ocurrir (en particular, si un elemento de la matriz contiene corchetes en su interior).
Sin embargo, una función anónima recursiva sería apenas más larga (61 bytes):

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

Pruébalo en línea!

Pero la forma en que Perl maneja los parámetros no es óptima para las funciones de golf: sin parámetros opcionales significa que tengo que hacer una segunda función (anónima) llamando a la primera, y tengo que obtener explícitamente el último parámetro con ese tiempo my$v=pop.

Ruby, 49 45 46 bytes

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

Ejemplo:

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

Explicación:

Función recursiva: si x==[*x]entonces x es una matriz, e iteramos sobre ella. Si no, sangrarlo.

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 no tiene listas anidadas con diferentes profundidades, por lo que tengo que analizar la cadena de entrada por mi cuenta. Afortunadamente, la función de biblioteca readspuede analizar cadenas (es decir, "secuencia de caracteres incluida), por lo que tengo un poco de ayuda aquí.

Ejemplo de uso:

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

Pruébalo en línea! .

Cómo funciona:

La función #pasa por la cadena char por char y mantiene el nivel de anidamiento (el primer parámetro l) como una cadena de -con un final >. Si el encabezado de la lista se puede analizar como una Cadena, tome ly la Cadena seguida de una llamada recursiva con la Cadena eliminada. Si el primer carácter es un espacio, sáltelo. Si es a ,, tome una nueva línea y continúe, si es así ], baje el nivel de anidación y continúe y de lo contrario (solo a la [izquierda) aumente el nivel de anidación y continúe. La recursión termina con la cadena de entrada vacía. La función principal (">"#)establece el nivel de anidamiento ">"y las llamadas #.

SWI-Prolog, 115 bytes

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

Se agregaron saltos de línea solo para facilitar la lectura, no incluidos en el recuento de bytes.

pel predicado atraviesa recursivamente las matrices, agregando un '-' al prefijo Fcuando se mueve un nivel más profundo.wse usa para escribir la matriz de prefijos, así como el elemento real en la salida.

Ejemplo:

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

Lote, 249 bytes

@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

Molesto, Batch tiene problemas para comparar comas. Ejecución de muestra:

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

Guardado 2 bytes gracias a Martin Ender

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

-"
>
T`]"

Pruébalo en línea!

Explicación

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

Primero, la matriz se divide reemplazando cada cadena entrecomillada con todo lo que vino antes, más ella misma, más una nueva línea. Al dividirlo de esta manera, es posible encontrar los corchetes de apertura inigualables antes de cada cadena.

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

Esta transliteración reemplazará [con -, dejará ]sin cambios y eliminará cualquier otro carácter (  -~es todo ASCII imprimible). Sin embargo, solo reemplaza los caracteres que aparecen antes de la cadena final en cada línea.

-]

A continuación, -]se eliminan todas las instancias de . Estos corresponden a pares de corchetes coincidentes, y solo queremos corchetes no coincidentes. Después de que se eliminen, cada línea tiene un número de -s igual a la cantidad de paréntesis de apertura que no coinciden .

-"
>

El último -antes de a "se reemplaza por >, para formar las flechas.

T`]"

Finalmente, todos los ]sys restantes "se eliminan.

Röda , 54 bytes

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

Pruébalo en línea!

Es una función que lee la matriz de entrada de la secuencia. Para cada elemento, se llama a sí mismo de forma recursiva o imprime el elemento.

Python 3, 80 bytes

Parece que las lambdas de Python respaldan la recursividad, ¿quién sabía?

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

Este es un contador / cumplido a la respuesta de orlp .

Groovy, 92 bytes

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

Apilado , 27 bytes

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

Pruébalo en línea!

Toma la entrada desde la parte superior de la pila y deja la salida en STDOUT. Esto es simple como hacer un mapa de profundidad, repetir- d tiempos, concatenar con '>' y el elemento en sí.

Gema, 63 personajes

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

Al igual que las otras soluciones de análisis, se supone que no habrá comillas dobles escapadas en las cadenas.

Ejecución de muestra:

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 caracteres

( 67 código de 64 caracteres + opción de línea de comando de 3 caracteres)

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

Ejecución de muestra:

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

Prueba en línea