Dada uma lista com listas aninhadas dentro dela, retorne a lista com os itens das listas aninhadas aninhados.

Entrada

A lista terá, no máximo, listas aninhadas em quatro profundidades. Conte todos os 0 na entrada como um espaço nulo.

Resultado

Imprima individualmente cada item. Não imprima a saída como uma lista. Você pode separar cada item com qualquer tipo de espaço em branco.

Casos de exemplo

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

O código mais curto vence.

APL (10)

0~⍨⍎⍞~'[]'

Explicação:

• ⍞~'[]': Entrada do usuário ( ⍞) sem ( ~) os caracteres '[]'
  Isso fornece algo como'1,2,0,2,3'
• ⍎: Avalie esta sequência. Acontece que ,é o operador de concatenação, agora temos uma lista: 1 2 0 2 3(as listas APL são separadas por espaços em branco por padrão)
• 0~⍨: Remova todos os números 0 desta lista. (Agora é uma lista de números, não de cadeias, portanto os zeros nos números não são removidos.
• Esse valor é gerado (por padrão, porque é o valor de todo o programa, como o Golfscript). As listas de APL são separadas por espaço em branco, por padrão, para que se pareça exatamente com a pergunta.

Sed, 20 caracteres

A solução é baseada na expressão regular estendida POSIX.

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

Saída :

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

Edit : Expressão regular básica POSIX ( solução da @clueless ), 19 caracteres :

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

Python, 45

w00, tratamento de exceções no golfe!

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

Perl, 20 16 13 caracteres

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

A -lopção é necessária para preservar a nova linha final na saída.

Aqui está uma versão alternativa que realmente funciona com as listas semanticamente (51 caracteres).

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

Ambos os programas aproveitam a estipulação do problema de que "pode ​​separar cada item com qualquer tipo de espaço em branco" e substitui os zeros por espaços em branco, em vez de removê-los completamente.

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 char dit: pcount for one char

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?

Os números são impressos separados por uma quebra de linha.

Golfscript 15

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

Entrada

Execute a partir da linha de comando, assim:

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

(supondo que o x.gsarquivo contenha o código apresentado acima).

Observe que não há vírgulas ( ,) ao definir as matrizes; essa é a sintaxe Golfscript

Resultado

Quando o comando descrito na seção Entrada é emitido, a saída é:

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]

Japonês , 5 bytes

c f ¸

Teste-o

Explicação

Entrada implícita da matriz U. Achate a matriz com c. Filtre com fpara remover os 0s. Associe-o a uma string usando espaços com ¸. Saída implícita da sequência 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 como aninhada Object[], saída impressa em STDOUT.

Experimente online.

46 bytes

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

Entrada e saída tanto como String.

Experimente online.

C, 45 caracteres

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

Pressupõe que a entrada seja dada em uma área de memória modificável apontada 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()))

Versão anterior de 99 caracteres - falha quando listas apenas com zeros estão incluídas:

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)recursivamente nivela a lista l, enquanto filtra zeros e converte números em seqüências de caracteres.

Scala, 42 caracteres

Tokenizou a sequência por dígitos e por dígitos seguidos de zero.

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

Prolog (79)

Ele insere a lista como um termo, então você precisa colocar um '.' após a lista na entrada.

Na verdade, lista o achatamento.

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~⍨∊

Experimente online!

0~⍨ zeros removidos de

∊ o ε nlisted dados (achatada)

Stax , 2 bytes

$f

Execute e depure

$está achatado. fé filtrar valores falsey e imprimir em linhas separadas.

Scala 147:

Trabalhando em listas reais, não em strings:

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

Agora os dados do teste:

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 a linha 2 apenas sem 'eco $ l |'. Teste para 3 amostras:

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

Experimente online!

Assumindo 4-deep é algo parecido {{{{5}}}}. Como não há exemplo disso nos casos de teste, pode ser algo como {{{5}}}; se for, posso diminuir meu código!

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

Experimente online!

Pitão, 5 bytes

jfT.n

Suíte de teste

R , 29 bytes

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

Experimente online!

unlistconverte a lista em um atomic vectorrecursivamente, então precisamos filtrar os elementos zero.

JavaScript (Node.js) , 53 bytes

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

Experimente online!

Braquilog , 8 bytes

ċ∋↰|ℕ₁ẉ⊥

Experimente online!

Leva a entrada através da variável de entrada e imprime a saída separada por novas linhas. Normalmente, eu reclamava do formato de saída, mas na verdade ele me salvou um byte de uma maneira que eu não pensaria de outra forma - colocar ẉ⊥o final é mais curto do que envolvê-lo {}ᶠ.

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

Se os itens da lista não estiverem restritos a números inteiros não negativos:

Braquilog , 11 bytes

ċ!∋↰|0!⊥|ẉ⊥

Experimente online!

PHP , 70 bytes

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

Experimente online!

Isso não será o mais curto (nem o mais longo), mas achei que seria uma chance de usar array_walk_recursive(), que até hoje não consigo pensar em usá-lo! Pelo menos, ele deve ser capaz de lidar com listas aninhadas profundas de nível arbitrário.

Wolfram Language (Mathematica) , 37 bytes

Flatten/*DeleteCases[0]/*StringRiffle

Experimente online!