Dada una lista con listas anidadas en su interior, devuelva la lista con los elementos anidados de las listas anidadas.

Entrada

La lista tendrá, como máximo, listas anidadas de 4 profundidades. Cuente todos los 0 dentro de la entrada como un espacio nulo.

Salida

Imprima individualmente cada artículo. No imprima el resultado como una lista. Puede separar cada elemento con cualquier tipo de espacio en blanco.

Casos de ejemplo

[[1, 0], [2, 0], [2, 3]] -> 1 2 2 3
[[[4, 5, 8]], [[5, 6, 20]], [[1, 20, 500]]] -> 4 5 8 5 6 20 1 20 500
[[[1, 0], [0, 0], [0, 0]], [[1, 0], [1, 2], [2, 0]], [[2, 0], [0, 0], [0, 0]]] -> 1 1 1 2 2 2

El código más corto gana.

APL (10)

0~⍨⍎⍞~'[]'

Explicación:

• ⍞~'[]': Entrada del usuario ( ⍞) sin ( ~) los caracteres '[]'
  Esto da algo como'1,2,0,2,3'
• ⍎: Evalúa esta cadena. Sucede que ,es el operador de concatenación, por lo que ahora tenemos una lista: 1 2 0 2 3(las listas APL están separadas por espacios en blanco por defecto)
• 0~⍨: Elimine todos los números 0 de esta lista. (Es una lista de números, no de cadenas, por ahora, por lo que los ceros dentro de los números no se eliminan.
• Este valor se genera (por defecto, porque es el valor de todo el programa, algo así como Golfscript). Las listas APL están separadas por espacios en blanco de forma predeterminada, por lo que se ve exactamente como en la pregunta.

Sed, 20 caracteres

La solución se basa en la expresión regular extendida POSIX.

s;[^0-9]+0|[],[]+;;g

Salida :

bash-3.2$ sed -rf sedFile <<< "[[[4, 5, 8]], [[5, 6, 20]], [[1, 20, 500]]]" 
4 5 8 5 6 20 1 20 500

Editar : POSIX Basic Regular Expression ( solución de @clueless ), 19 caracteres :

s/[^0-9][^1-9]*/ /g

Python, 45

w00, manejo de excepciones en golf!

def d(x):
 try:map(d,x)
 except:print`x`*(x!=0)

Perl, 20 16 13 caracteres

perl -ple 's/\D+0?/ /g'

El -lcambio es necesario para preservar la nueva línea final en la salida.

Aquí hay una versión alternativa que realmente funciona semánticamente con las listas (51 caracteres).

perl -E '$,=$";sub p{map{ref$_?p(@$_):$_||""}@_}say p eval<>'

Ambos programas aprovechan la estipulación del problema de que "puede separar cada elemento con cualquier tipo de espacio en blanco", y reemplaza los ceros con espacios en blanco, en lugar de eliminarlos directamente.

K, 12

{x@?&x:,//x}

.

k){x@?&x:,//x}((1;0);(2;0);(2;3))
1 2 2 3
k){x@?&x:,//x}(((4;5;8));((5;6;20));((1;20;500)))
4 5 8 5 6 20 1 20 500
k){x@?&x:,//x}(((1;0);(0;0);(0;0));((1;0);(1;2);(2;0));((2;0);(0;0);(0;0)))
1 1 1 2 2 2

Perl 13 , 14 caracteres : pcuenta para un carácter

s/\D+|\b0/ /g

uso:

cat '[[1, 0], [2, 0], [2, 3]]' | perl -pe 's/\D+|\b0/ /g'

Ruby, 38 caracteres.

puts eval(gets).flatten.reject &:zero?

Los números se imprimen separados por un salto de línea.

Golfscript 15

~{[]*}4*{},' '*

Entrada

Ejecutar desde la línea de comando, así:

echo [[[1 0] [0 0] [0 0]] [[1 0] [1 2] [2 0]] [[2 0] [0 0] [0 0]]] | ruby golfscript.rb x.gs

(suponiendo que el x.gsarchivo contiene el código presentado anteriormente).

Tenga en cuenta que no hay comas ( ,) al definir las matrices; esa es la sintaxis de Golfscript

Salida

Cuando se emite el comando descrito en la sección Entrada , la salida es:

1 1 1 2 2 2

Python 3, 49 caracteres

import re
print(*re.findall('[1-9]\d*',input()))

Python 2, 58 caracteres

import re
print re.sub('\D[^1-9]*',' ',raw_input())[1:-1]

Japt , 5 bytes

c f ¸

Pruébalo

Explicación

Entrada implícita de matriz U. Acoplar la matriz con c. Filtrarlo fpara eliminar el 0s. Unirlo a una cadena usando espacios con ¸. Salida implícita de la cadena resultante.

Java 10, 106 bytes

void c(Object i){for(var o:(Object[])i)try{System.out.print((int)o>0?o+" ":"");}catch(Exception e){c(o);}}

Entrada anidada Object[], salida impresa en STDOUT.

Pruébalo en línea.

46 bytes

s->s.replaceAll("[^0-9 ]","").replace(" 0","")

Entrada y salida tanto como String.

Pruébalo en línea.

C, 45 caracteres

for(;s=strtok(s,"[], ");s=0)atoi(s)&&puts(s);

Se supone que la entrada se proporciona en un área de memoria modificable señalada por s.

Python, 99 111 caracteres

def d(l):
    if list==type(l):return[y for x in l for y in d(x)]
    return[str(l)]*(l!=0)
print" ".join(d(input()))

Versión anterior de 99 caracteres: falla cuando se incluyen solo listas con ceros:

d=lambda l:list==type(l)and[y for x in l for y in d(x)]or[str(l)]*(l!=0)
print" ".join(d(input()))

d(l)aplana recursivamente la lista l, mientras filtra los ceros y convierte los números en cadenas.

Scala, 42 caracteres

Tokenizó la cadena por no dígitos y no dígitos seguidos de cero.

print(readLine split"\\D|\\b0"mkString" ")

Prólogo (79)

Introduce la lista como un término, por lo que debe poner un '.' después de la lista en la entrada.

En realidad, enumera el aplanamiento.

x([H|T]):-x(H),x(T).
x(0). x([]).
x(M):-write(M),put(32).
:-read(X),x(X),halt.

APL (Dyalog) , 4 bytes

0~⍨∊

Pruébalo en línea!

0~⍨ ceros eliminados de

∊ la ε nlisted (aplanada) de datos

Stax , 2 bytes

$f

Ejecutar y depurarlo

$se aplana. fes filtrar valores de falsey e imprimir en líneas separadas.

Scala 147:

Trabajando en listas reales, no en cadenas:

def f[A](l:List[_]):List[_]=l match{
case Nil=>l
case(l:List[_])::s=>(f(l):::f(s))
case e::s=>e::f(s)}
def p(l:List[_])=f(l)filter(!=0)mkString " "

Ahora los datos de prueba:

val l1 = List (List (1, 0), List (2, 0), List (2, 3))
val l2 = List (List (List (4, 5, 8)), List (List (5, 6, 20)), List (List (1, 20, 500)))
val l3 = List (List (List (1, 0), List (0, 0), List (0, 0)), List (List (1, 0), List (1, 2), List (2, 0)), List (List (2, 0), List (0, 0), List (0, 0)))
val l4 = List (l1, l2, l3)

scala> l4.map(p)
res94: List[String] = List(1 2 2 3, 4 5 8 5 6 20 1 20 500, 1 1 1 2 2 2)

scala> p(l4)
res95: String = 1 2 2 3 4 5 8 5 6 20 1 20 500 1 1 1 2 2 2

bash: 29 caracteres

l=$(echo "[[[1, 0], [0, 0], [0, 0]], [[1, 0], [1, 2], [2, 0]], [[2, 0], [0, 0], [0, 0]]]")
echo $l|tr -d '][,'|sed 's/\b0\b/ /g'
1           1   1 2 2   2          

contando la línea 2 solo sin 'echo $ l |'. Prueba para 3 muestras:

  1    2    2 3
   4 5 8   5 6 20   1 20 500
   1               1    1 2  2     2            

Tcl , 47 bytes

proc D L {concat {*}[concat {*}[concat {*}$L]]}

Pruébalo en línea!

Suponiendo que 4 de profundidad es algo así {{{{5}}}}. Como no hay un ejemplo de tal cosa en los casos de prueba, puede ser algo así {{{5}}}; ¡si es así puedo acortar mi código!

proc D L {lsearch -al -inl -not "[string map {\{ "" \} ""} $L]" 0}

Pruébalo en línea!

Pyth, 5 bytes

jfT.n

Banco de pruebas

R , 29 bytes

function(l)(x=unlist(l))[!!x]

Pruébalo en línea!

unlistconvierte la lista en un atomic vectorrecursivo, por lo que solo necesitamos filtrar los elementos cero.

JavaScript (Node.js) , 53 bytes

function(x){return(','+x+',').replace(/,(0,)*/g,' ')}

Pruébalo en línea!

Brachylog , 8 bytes

ċ∋↰|ℕ₁ẉ⊥

Pruébalo en línea!

Toma la entrada a través de la variable de entrada e imprime la salida separada por nuevas líneas. Por lo general, me quejaría del formato de salida, pero en realidad me ahorró un byte de una manera que no hubiera pensado de otra manera: poner ẉ⊥el final es más corto que envolverlo {}ᶠ.

ċ           If the input is a list,
 ∋          pick some element of it
  ↰         and recur with it as the input.
   |        Otherwise, if the input
    ℕ₁      is a natural number,
      ẉ     print it with a trailing newline
       ⊥    then trigger backtracking.

Si los elementos de la lista no se limitan a ser enteros no negativos:

Brachylog , 11 bytes

ċ!∋↰|0!⊥|ẉ⊥

Pruébalo en línea!

PHP , 70 bytes

function($a){array_walk_recursive($a,function($a){echo$a?"$a ":'';});}

Pruébalo en línea!

¡Esto no va a ser el más corto (ni el más largo), pero pensé que sería una oportunidad de usar array_walk_recursive(), que hasta hoy no puedo pensar en usarlo! Al menos debería poder manejar un nivel arbitrario de listas anidadas profundas.

Wolfram Language (Mathematica) , 37 bytes

Flatten/*DeleteCases[0]/*StringRiffle

Pruébalo en línea!