Если у вас есть список со вложенными списками, верните список с вложенными списками.

вход

Список будет содержать не более 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

Самый короткий код выигрывает.

APL (10)

0~⍨⍎⍞~'[]'

Объяснение:

• ⍞~'[]': Пользовательский ввод ( ⍞) без ( ~) символов '[]'
  Это дает что-то вроде'1,2,0,2,3'
• ⍎: Оценить эту строку. Так получилось, что ,это оператор конкатенации, так что теперь у нас есть список: 1 2 0 2 3(списки APL по умолчанию разделены пробелами)
• 0~⍨: Удалить все цифры 0 из этого списка. (Это список чисел, а не строк, поэтому нули в числах не удаляются.
• Это значение выводится (по умолчанию, потому что это значение всей программы, вроде как Golfscript). Списки APL по умолчанию разделены пробелами, поэтому они выглядят так же, как в вопросе.

Сед, 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<>'

Обе эти программы используют условие задачи, заключающееся в том, что они «могут разделять каждый элемент любым пробелом» и заменяют нули пробелами, вместо того, чтобы удалять их полностью.

К, 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 символов : pсчитать за один символ

s/\D+|\b0/ /g

использование:

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

Рубин, 38 знаков

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

Числа печатаются через разрыв строки.

Golfscript 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чтобы удалить 0s. Присоедините его к строке, используя пробелы с ¸. Неявный вывод результирующей строки.

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.

Попробуйте онлайн.

С, 45 символов

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

Предполагается, что ввод дается в изменяемой области памяти, на которую указывает s.

Питон, 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)рекурсивно выравнивает список l, фильтруя нули и преобразовывая числа в строки.

Скала, 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 (Дьялог) , 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

Баш: 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          

считая только строку 2 без 'echo $ l |'. Тест на 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,' ')}

Попробуйте онлайн!

Брахилог , 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.

Если элементы списка не ограничены неотрицательными целыми числами:

Брахилог , 11 байт

ċ!∋↰|0!⊥|ẉ⊥

Попробуйте онлайн!

PHP , 70 байт

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

Попробуйте онлайн!

Это не будет самым коротким (и не самым длинным), но я подумал, что это будет шанс получить использование array_walk_recursive(), которое до сегодняшнего дня я не могу себе представить, чтобы когда-либо использовать его! По крайней мере, он должен быть в состоянии обрабатывать вложенные списки произвольного уровня.

Wolfram Language (Mathematica) , 37 байт

Flatten/*DeleteCases[0]/*StringRiffle

Попробуйте онлайн!