Étant donné une liste avec des listes imbriquées à l'intérieur, renvoyez la liste avec les éléments des listes imbriquées dé-imbriqués.

Contribution

La liste aura, au plus, des listes imbriquées de 4 profonds. Comptez tous les 0 dans l'entrée comme un espace nul.

Production

Imprimez individuellement chaque article. N'imprimez pas la sortie sous forme de liste. Vous pouvez séparer chaque élément avec n'importe quel type d'espace.

Exemples de cas

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

Le code le plus court gagne.

APL (10)

0~⍨⍎⍞~'[]'

Explication:

• ⍞~'[]': Saisie utilisateur ( ⍞) sans ( ~) les caractères '[]'
  Cela donne quelque chose comme'1,2,0,2,3'
• ⍎: Évaluer cette chaîne. Il se trouve que ,c'est l'opérateur de concaténation, alors maintenant nous avons une liste: 1 2 0 2 3(les listes APL sont séparées par des espaces par défaut)
• 0~⍨: Supprimez tous les chiffres 0 de cette liste. (Il s'agit d'une liste de nombres, pas de chaînes, pour le moment, donc les zéros dans les nombres ne sont pas supprimés.
• Cette valeur est sortie (par défaut, car c'est la valeur de tout le programme, un peu comme Golfscript). Les listes APL sont séparées par des espaces par défaut, donc cela ressemble exactement à la question.

Sed, 20 caractères

La solution est basée sur l'expression régulière étendue POSIX.

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

Sortie :

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 : POSIX Basic Regular Expression ( solution @clueless ), 19 caractères :

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

Python, 45

w00, gestion des exceptions dans le golf!

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

Perl, 20 16 13 caractères

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

Le -lcommutateur est nécessaire pour conserver la nouvelle ligne finale dans la sortie.

Voici une version alternative qui fonctionne réellement avec les listes sémantiquement (51 caractères).

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

Ces deux programmes profitent de la stipulation du problème qu'il "peut séparer chaque élément avec n'importe quel type d'espace blanc", et remplace les zéros par des blancs, au lieu de les supprimer purement et simplement.

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: pcompte pour un char

s/\D+|\b0/ /g

usage:

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

Ruby, 38 caractères

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

Les numéros sont imprimés séparés par un saut de ligne.

Golfscript 15

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

Contribution

Exécutez à partir de la ligne de commande, comme ceci:

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

(en supposant que le x.gsfichier contient le code présenté ci-dessus).

Notez qu'il n'y a pas de virgule ( ,) lors de la définition des tableaux; c'est la syntaxe Golfscript

Production

Lorsque la commande décrite dans la section Entrée est émise, la sortie est:

1 1 1 2 2 2

Python 3, 49 caractères

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

Python 2, 58 caractères

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

Japt , 5 octets

c f ¸

Essaye-le

Explication

Entrée implicite du tableau U. Aplatissez le tableau avec c. Filtrez-le avec fpour supprimer le 0s. Joignez-le à une chaîne en utilisant des espaces avec ¸. Sortie implicite de la chaîne résultante.

Java 10, 106 octets

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

Entrée imbriquée Object[], sortie imprimée sur STDOUT.

Essayez-le en ligne.

46 octets

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

Entrée et sortie en tant que String.

Essayez-le en ligne.

C, 45 caractères

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

Il suppose que l'entrée est donnée dans une zone mémoire modifiable pointée par s.

Python, 99 111 caractères

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

Version précédente à 99 caractères - échoue lorsque des listes contenant uniquement des zéros sont incluses:

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)aplatit récursivement la liste l, tout en filtrant les zéros et en convertissant les nombres en chaînes.

Scala, 42 caractères

Tokenized la chaîne par des non chiffres et des non-chiffres suivis de zéro.

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

Prologue (79)

Il saisit la liste en tant que terme, vous devez donc mettre un '.' après la liste en entrée.

En fait, aplatit la liste.

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

APL (Dyalog) , 4 octets

0~⍨∊

Essayez-le en ligne!

0~⍨ zéros supprimés de

∊ l' ε nlisted (aplatie) des données

Stax , 2 octets

$f

Exécuter et déboguer

$est aplati. fconsiste à filtrer les valeurs de falsey et à imprimer sur des lignes distinctes.

Scala 147:

Travailler sur de vraies listes, pas sur des chaînes:

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

Maintenant, les données de test:

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 caractères

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          

compter la ligne 2 uniquement sans 'echo $ l |'. Test pour 3 échantillons:

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

Tcl , 47 octets

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

Essayez-le en ligne!

En supposant que 4 profonds est quelque chose comme {{{{5}}}}. Comme il n'y a aucun exemple d'une telle chose sur les cas de test, cela peut être quelque chose comme {{{5}}}; si c'est le cas, je peux raccourcir mon code!

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

Essayez-le en ligne!

Pyth, 5 octets

jfT.n

Suite de tests

R , 29 octets

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

Essayez-le en ligne!

unlistconvertit la liste en un atomic vectorrécursif, nous avons donc juste besoin de filtrer les éléments zéro.

JavaScript (Node.js) , 53 octets

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

Essayez-le en ligne!

Brachylog , 8 octets

ċ∋↰|ℕ₁ẉ⊥

Essayez-le en ligne!

Prend l'entrée via la variable d'entrée et imprime la sortie séparée par des retours à la ligne. Habituellement, je me plaindrais du format de sortie, mais cela m'a en fait sauvé un octet d'une manière que je n'aurais pas pensé autrement - mettre ẉ⊥la fin est plus court que de l'envelopper {}ᶠ.

ċ           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 les éléments de la liste ne sont pas limités à des entiers non négatifs:

Brachylog , 11 octets

ċ!∋↰|0!⊥|ẉ⊥

Essayez-le en ligne!

PHP , 70 octets

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

Essayez-le en ligne!

Ce ne sera pas le plus court (ni le plus long), mais array_walk_recursive()je me suis dit que ce serait une chance de l'utiliser , ce qui jusqu'à aujourd'hui, je ne pense pas avoir un usage! Au moins, il devrait être capable de gérer des listes imbriquées profondes de niveau arbitraire.

Wolfram Language (Mathematica) , 37 octets

Flatten/*DeleteCases[0]/*StringRiffle

Essayez-le en ligne!