Bei einer Liste mit darin verschachtelten Listen geben Sie die Liste mit den Elementen der verschachtelten Listen zurück, die nicht verschachtelt sind.

Eingang

Die Liste enthält höchstens 4 tief verschachtelte Listen. Zählen Sie alle Nullen in der Eingabe als Null-Leerzeichen.

Ausgabe

Drucken Sie jeden Artikel einzeln aus. Drucken Sie die Ausgabe nicht als Liste aus. Sie können jedes Element mit einem beliebigen Leerzeichen trennen.

Beispielfälle

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

Der kürzeste Code gewinnt.

APL (10)

0~⍨⍎⍞~'[]'

Erläuterung:

• ⍞~'[]': Benutzereingabe ( ⍞) ohne ( ~) die Zeichen '[]'
  Dies ergibt so etwas wie'1,2,0,2,3'
• ⍎: Bewerten Sie diese Zeichenfolge. Es kommt also vor, dass ,es sich um den Verkettungsoperator handelt. Jetzt haben wir eine Liste: 1 2 0 2 3(APL-Listen sind standardmäßig durch Leerzeichen getrennt.)
• 0~⍨: Entfernen Sie alle Nummern 0 aus dieser Liste. (Es handelt sich derzeit um eine Liste von Zahlen, nicht von Zeichenfolgen. Nullen in Zahlen werden daher nicht entfernt.
• Dieser Wert wird ausgegeben (standardmäßig, da es sich um den Wert des gesamten Programms handelt, ähnlich wie bei Golfscript). APL-Listen sind standardmäßig durch Leerzeichen getrennt, sodass sie genau wie in der Frage aussehen.

Sed, 20 Zeichen

Die Lösung basiert auf POSIX Extended Regular Expression.

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

Ausgabe :

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 ( @clueless 's Lösung), 19 Zeichen :

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

Python, 45

W00, Ausnahmebehandlung im Golf!

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

Perl, 20 16 13 Zeichen

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

Der -lSchalter ist erforderlich, um die letzte neue Zeile in der Ausgabe beizubehalten.

Hier ist eine alternative Version, die tatsächlich semantisch mit den Listen arbeitet (51 Zeichen).

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

Beide Programme nutzen die Bedingung des Problems, dass "jedes Element durch ein beliebiges Leerzeichen getrennt werden kann", und ersetzen die Nullen durch Leerzeichen, anstatt sie direkt zu entfernen.

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: pZähle für ein Zeichen

s/\D+|\b0/ /g

Verwendung:

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

Ruby, 38 Zeichen

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

Die Zahlen werden durch einen Zeilenumbruch getrennt gedruckt.

Golfscript 15

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

Eingang

Führen Sie in der Befehlszeile Folgendes aus:

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

(vorausgesetzt, die x.gsDatei enthält den oben dargestellten Code).

Beachten Sie, dass ,beim Definieren der Arrays keine Kommas ( ) verwendet werden. Das ist die Golfscript-Syntax

Ausgabe

Wenn der im Abschnitt Eingabe beschriebene Befehl ausgegeben wird, lautet die Ausgabe:

1 1 1 2 2 2

Python 3, 49 Zeichen

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

Python 2, 58 Zeichen

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

Japt , 5 Bytes

c f ¸

Probier es aus

Erläuterung

Implizite Eingabe eines Arrays U. Reduzieren Sie das Array mit c. Filtern Sie es mit f, um das 0s zu entfernen . Fügen Sie ihn mit Leerzeichen zu einer Zeichenfolge hinzu ¸. Implizite Ausgabe der resultierenden Zeichenfolge.

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

Eingabe als verschachtelt Object[], Ausgabe als STDOUT gedruckt.

Probieren Sie es online aus.

46 Bytes

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

Ein- und Ausgabe sowohl als String.

Probieren Sie es online aus.

C 45 Zeichen

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

Es wird davon ausgegangen, dass die Eingabe in einem veränderbaren Speicherbereich erfolgt, auf den durch gezeigt wird s.

Python, 99 111 Zeichen

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

Vorherige Version mit 99 Zeichen - schlägt fehl, wenn nur Listen mit Nullen enthalten sind:

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)Reduziert die Liste rekursiv l, filtert Nullen und konvertiert Zahlen in Zeichenfolgen.

Scala, 42 Zeichen

Tokenized die Zeichenfolge durch Nicht-Ziffern und Nicht-Ziffern, gefolgt von Null.

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

Prolog (79)

Die Liste wird als Begriff eingegeben, daher müssen Sie ein '.' nach der Liste in der Eingabe.

Tatsächlich wird die Liste abgeflacht.

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

Probieren Sie es online!

0~⍨ Nullen entfernt von

∊ die ϵ nlisted (abgeflachten) Daten

Stax , 2 Bytes

$f

Führen Sie es aus, und debuggen Sie es

$ist abgeflacht. fist, falsche Werte herauszufiltern und in separaten Zeilen zu drucken.

Scala 147:

Arbeiten an realen Listen, nicht an Zeichenfolgen:

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

Nun die Testdaten:

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 Zeichen

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          

Zähle Zeile 2 nur ohne 'echo $ l |'. Test für 3 Proben:

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

Probieren Sie es online!

Angenommen, 4-deep ist so etwas wie {{{{5}}}}. Da es in Testfällen kein Beispiel dafür gibt, kann es so etwas sein {{{5}}}; wenn es so ist, kann ich meinen Code kürzer machen!

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

Probieren Sie es online!

Pyth, 5 Bytes

jfT.n

Testsuite

R 29 Bytes

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

Probieren Sie es online!

unlistkonvertiert die Liste in eine atomic vectorrekursive, sodass wir nur die Nullelemente herausfiltern müssen.

JavaScript (Node.js) , 53 Byte

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

Probieren Sie es online!

Brachylog , 8 Bytes

ċ∋↰|ℕ₁ẉ⊥

Probieren Sie es online!

Übernimmt die Eingabe über die Eingabevariable und druckt die Ausgabe durch Zeilenumbrüche getrennt. Normalerweise würde ich über das Ausgabeformat beschweren, aber es hat mich gerettet tatsächlich ein Byte in einer Art und Weise könnte ich nicht anders gedacht haben - setzen ẉ⊥am Ende kürzer ist als es in Verpackung {}ᶠ.

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

Wenn die Listenelemente nicht auf nicht negative Ganzzahlen beschränkt sind:

Brachylog , 11 Bytes

ċ!∋↰|0!⊥|ẉ⊥

Probieren Sie es online!

PHP , 70 Bytes

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

Probieren Sie es online!

Dies wird nicht die kürzeste (und auch nicht die längste) sein, aber array_walk_recursive()ich dachte, es wäre eine Chance, sie zu nutzen , was ich mir bis heute nicht vorstellen kann, jemals eine Verwendung dafür zu finden! Zumindest sollte es in der Lage sein, beliebig tief verschachtelte Listen zu verarbeiten.

Wolfram-Sprache (Mathematica) , 37 Byte

Flatten/*DeleteCases[0]/*StringRiffle

Probieren Sie es online!