给定一个列表，该列表中嵌套有列表，请返回该列表，其中嵌套列表的项目已取消嵌套。

输入值

该列表最多具有4个深度的嵌套列表。将输入中的所有0计数为空空间。

输出量

分别打印出每个项目。不要将输出作为列表打印。您可以使用任何类型的空格分隔每个项目。

案例案例

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

最短的代码获胜。

杀伤人员地雷（10）

0~⍨⍎⍞~'[]'

说明：

• ⍞~'[]'：用户输入（⍞）无（~）人物'[]'
  这给像'1,2,0,2,3'
• ⍎：评估此字符串。碰巧,是串联运算符，所以现在我们有了一个列表：1 2 0 2 3（APL列表默认情况下用空格分隔）
• 0~⍨：从该列表中删除所有数字0。（到目前为止，这是一个数字列表，而不是字符串列表，因此不会删除数字中的零。
• 输出该值（默认情况下，因为它是整个程序的值，有点像Golfscript）。APL列表默认情况下用空格分隔，因此看起来与问题中的样子完全一样。

Sed，20个字符

解决方案基于POSIX扩展正则表达式。

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

输出：

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

编辑：POSIX基本正则表达式（@clueless的解决方案），19个字符：

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

Python，45岁

w00，高尔夫中的异常处理！

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

Perl，20 16 13个字符

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

-l必须使用该开关才能在输出中保留最后的换行符。

这是一个实际使用语义列表的替代版本（51个字符）。

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

这两个程序都利用了问题的规定，即“可以用任何一种空格分隔每个项目”，并用空格代替零，而不是直接删除它们。

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：p算一个字符

s/\D+|\b0/ /g

用法：

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

Ruby，38个字符

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

数字以换行符分隔打印。

高尔夫脚本15

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

输入值

从命令行运行，如下所示：

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

（假设x.gs文件包含上面提供的代码）。

请注意，,定义数组时没有逗号（）；这是Golfscript语法

输出量

发出“ 输入”部分中描述的命令时，输出为：

1 1 1 2 2 2

Python 3，49个字符

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

Python 2，58个字符

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

Japt，5个字节

c f ¸

测试一下

说明

数组的隐式输入U。用展平数组c。进行过滤f以删除0。使用空格将其连接到字符串¸。隐式输出结果字符串。

Java 10，106个字节

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

输入为嵌套Object[]，输出打印到STDOUT。

在线尝试。

46个字节

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

输入和输出均为String。

在线尝试。

C，45个字符

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

假定输入在指向的可修改存储区域中给出s。

Python，99 111个字符

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

以前的99个字符的版本-仅包含零列表时失败：

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)递归拉平list l，同时过滤零并将数字转换为字符串。

Scala，42个字符

用非数字和非数字后跟零来标记字符串。

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

前言（79）

它输入列表作为术语，因此您需要输入“。”。在输入列表之后。

实际上确实列表变平。

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

APL（Dyalog），4个字节

0~⍨∊

在线尝试！

0~⍨ 从中删除零

∊ 的ε nlisted（平坦化）的数据

Stax，2个字节

$f

运行并调试

$展平。 f过滤掉假值并在单独的行上打印。

Scala 147：

处理实际列表，而不处理字符串：

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

现在测试数据：

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个字符

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          

仅在不使用“ echo $ l |”的情况下计数第2行。测试3个样本：

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

Tcl，47个字节

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

在线尝试！

假设4深是类似的东西{{{{5}}}}。由于在测试用例上没有这样的例子，可能是像这样{{{5}}}; 如果是这样，我可以使代码更短！

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

在线尝试！

Pyth，5个字节

jfT.n

测试套件

R，29个字节

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

在线尝试！

unlist将列表atomic vector递归转换，因此我们只需要过滤掉零个元素。

JavaScript（Node.js），53字节

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

在线尝试！

Brachylog，8个字节

ċ∋↰|ℕ₁ẉ⊥

在线尝试！

通过输入变量获取输入，并以换行符打印输出。通常，我会抱怨输出格式，但是实际上它以某种我可能不会想到的方式为我节省了一个字节-放在ẉ⊥最后比将它包装起来要短{}ᶠ。

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

如果列表项不限于非负整数：

Brachylog，11个字节

ċ!∋↰|0!⊥|ẉ⊥

在线尝试！

PHP，70字节

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

在线尝试！

这不会是最短的（也不会是最长的），但是它认为这将是一个可以使用的机会array_walk_recursive()，直到今天我再也没有想过要使用它了！至少它应该能够处理任意级别的深层嵌套列表。

Wolfram语言（Mathematica），37个字节

Flatten/*DeleteCases[0]/*StringRiffle

在线尝试！