Dato un elenco con elenchi nidificati al suo interno, restituisce l'elenco con gli elementi degli elenchi nidificati de-nidificati.

Ingresso

L'elenco avrà, al massimo, elenchi nidificati con profondità 4. Contare tutti gli 0 all'interno dell'input come spazio nullo.

Produzione

Stampa singolarmente ogni articolo. Non stampare l'output come un elenco. Puoi separare ogni oggetto con qualsiasi tipo di spazio bianco.

Casi di esempio

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

Vince il codice più corto.

APL (10)

0~⍨⍎⍞~'[]'

Spiegazione:

• ⍞~'[]': Input dell'utente ( ⍞) senza ( ~) i caratteri '[]'
  Questo dà qualcosa di simile'1,2,0,2,3'
• ⍎: Valuta questa stringa. Accade così che ,sia l'operatore di concatenazione, quindi ora abbiamo un elenco: 1 2 0 2 3(gli elenchi APL sono separati da spazi per impostazione predefinita)
• 0~⍨: Rimuove tutti i numeri 0 da questo elenco. (È un elenco di numeri, non di stringhe, ormai, quindi gli zero all'interno dei numeri non vengono rimossi.
• Questo valore viene generato (per impostazione predefinita, perché è il valore dell'intero programma, un po 'come Golfscript). Gli elenchi APL sono separati da spazi bianchi per impostazione predefinita, quindi appare esattamente come nella domanda.

Sed, 20 caratteri

La soluzione si basa sull'espressione regolare estesa POSIX.

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

Uscita :

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

Modifica : POSIX Basic Regular Expression ( la soluzione di @clueless ), 19 caratteri :

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

Python, 45

w00, gestione delle eccezioni nel golf!

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

Perl, 20 16 13 caratteri

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

Lo -lswitch è necessario per preservare la nuova riga finale nell'output.

Ecco una versione alternativa che funziona effettivamente con le liste semanticamente (51 caratteri).

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

Entrambi questi programmi sfruttano la clausola del problema secondo cui "può separare ogni elemento con qualsiasi tipo di spazio bianco" e sostituisce gli zeri con spazi vuoti, invece di rimuoverli 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 caratteri : pconta per un carattere

s/\D+|\b0/ /g

utilizzo:

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

Rubino, 38 caratteri

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

I numeri vengono stampati separati da un'interruzione di riga.

Golfscript 15

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

Ingresso

Esegui dalla riga di comando, in questo modo:

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

(presupponendo che il x.gsfile contenga il codice presentato sopra).

Si noti che non ci sono virgole ( ,) durante la definizione delle matrici; questa è la sintassi di Golfscript

Produzione

Quando viene emesso il comando descritto nella sezione Input , l'output è:

1 1 1 2 2 2

Python 3, 49 caratteri

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

Python 2, 58 caratteri

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

Japt , 5 byte

c f ¸

Provalo

Spiegazione

Input implicito di array U. Appiattire l'array con c. Filtralo con fper rimuovere la 0s. Uniscilo a una stringa usando gli spazi con ¸. Output implicito della stringa risultante.

Java 10, 106 byte

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

Input come nidificato Object[], output stampato su STDOUT.

Provalo online.

46 byte

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

Input e output sia come String.

Provalo online.

C, 45 caratteri

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

Presuppone che l'ingresso sia dato in un'area di memoria modificabile indicata da s.

Python, 99 111 caratteri

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

Versione precedente di 99 caratteri - ha esito negativo quando sono inclusi elenchi con solo zeri:

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)appiattisce ricorsivamente l'elenco l, filtrando gli zeri e convertendo i numeri in stringhe.

Scala, 42 caratteri

Tokenized la stringa da non cifre e non cifre seguite da zero.

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

Prolog (79)

Inserisce l'elenco come termine, quindi è necessario inserire un '.' dopo l'elenco nell'input.

In realtà elenca l'appiattimento.

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

APL (Dyalog) , 4 byte

0~⍨∊

Provalo online!

0~⍨ zeri rimossi da

∊ i dati ϵ elencati (appiattiti)

Stax , 2 byte

$f

Esegui ed esegui il debug

$è appiattito. fè filtrare i valori di falsi e stampare su righe separate.

Scala 147:

Lavorando su liste reali, non su stringhe:

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

Ora i testdata:

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 caratteri

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 riga 2 solo senza 'echo $ l |'. Test per 3 campioni:

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

Tcl , 47 byte

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

Provalo online!

Supponendo che 4-deep sia qualcosa di simile {{{{5}}}}. Poiché non esiste alcun esempio di tale cosa nei casi di test, potrebbe essere qualcosa del genere {{{5}}}; se è così posso accorciare il mio codice!

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

Provalo online!

Pyth, 5 byte

jfT.n

Suite di test

R , 29 byte

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

Provalo online!

unlistconverte l'elenco in modo atomic vectorricorsivo, quindi dobbiamo solo filtrare gli elementi zero.

JavaScript (Node.js) , 53 byte

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

Provalo online!

Brachylog , 8 byte

ċ∋↰|ℕ₁ẉ⊥

Provalo online!

Prende l'input attraverso la variabile di input e stampa l'output separato da newline. Normalmente mi lamento del formato di output, ma in realtà mi ha salvato un byte in un modo che non avrei potuto pensare diversamente - mettere ẉ⊥alla fine è più breve del confezionarlo {}ᶠ.

ċ           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 gli elementi dell'elenco non sono limitati a numeri interi non negativi:

Brachylog , 11 byte

ċ!∋↰|0!⊥|ẉ⊥

Provalo online!

PHP , 70 byte

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

Provalo online!

Questo non sarà il più breve (né il più lungo), ma ho pensato che sarebbe stata un'occasione per usarlo array_walk_recursive(), che fino ad oggi non riesco a pensare di averne mai usato! Almeno dovrebbe essere in grado di gestire elenchi annidati profondi di livello arbitrario.

Wolfram Language (Mathematica) , 37 byte

Flatten/*DeleteCases[0]/*StringRiffle

Provalo online!