Đưa ra một danh sách với các danh sách được lồng bên trong nó, trả về danh sách với các mục được liệt kê lồng nhau.

Đầu vào

Danh sách này sẽ có nhiều nhất là các danh sách lồng nhau 4 sâu. Đếm tất cả 0 trong đầu vào dưới dạng khoảng trắng.

Đầu ra

Cá nhân in ra từng mục. Không in ra đầu ra dưới dạng một danh sách. Bạn có thể tách riêng từng mục với bất kỳ loại khoảng trắng nào.

Ví dụ trường hợp

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

Mã ngắn nhất sẽ thắng.

APL (10)

0~⍨⍎⍞~'[]'

Giải trình:

• ⍞~'[]': Người dùng nhập ( ⍞) không có ( ~) các ký tự '[]'
  Điều này mang lại một cái gì đó như'1,2,0,2,3'
• ⍎: Đánh giá chuỗi này. Nó thực sự ,là toán tử ghép, vì vậy bây giờ chúng ta có một danh sách: 1 2 0 2 3(Các danh sách APL được phân tách bằng khoảng trắng theo mặc định)
• 0~⍨: Xóa tất cả các số 0 khỏi danh sách này. (Bây giờ, nó là một danh sách các số, không phải là các chuỗi, vì vậy các số 0 trong các số không bị xóa.
• Giá trị này là đầu ra (theo mặc định, vì đó là giá trị của toàn bộ chương trình, giống như Golfscript). Các danh sách APL được phân tách theo khoảng trắng theo mặc định để nó trông giống hệt như trong câu hỏi.

Sed, 20 ký tự

Giải pháp dựa trên biểu thức chính quy mở rộng POSIX.

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

Đầu ra :

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

Chỉnh sửa : Biểu thức chính quy cơ bản POSIX ( giải pháp của @cluless ), 19 ký tự :

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

Con trăn, 45

w00, xử lý ngoại lệ trong golf!

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

Perl, 20 16 13 ký tự

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

Việc -lchuyển đổi là cần thiết để duy trì dòng mới cuối cùng trong đầu ra.

Đây là một phiên bản thay thế thực sự hoạt động với các danh sách về mặt ngữ nghĩa (51 ký tự).

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

Cả hai chương trình này đều tận dụng quy định của vấn đề rằng nó "có thể phân tách từng mục bằng bất kỳ khoảng trắng nào" và thay thế các số không bằng các khoảng trống, thay vì loại bỏ chúng hoàn toàn.

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: ptính cho một char

s/\D+|\b0/ /g

sử dụng:

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

Ruby, 38 ký tự

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

Các số được in cách nhau bởi một ngắt dòng.

Golf 15

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

Đầu vào

Chạy từ dòng lệnh, như vậy:

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

(giả sử rằng x.gs tập tin chứa mã được trình bày ở trên).

Lưu ý rằng không có dấu phẩy ( ,) khi xác định mảng; đó là cú pháp Golfscript

Đầu ra

Khi lệnh được mô tả trong phần Đầu vào được ban hành, đầu ra là:

1 1 1 2 2 2

Python 3, 49 ký tự

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

Python 2, 58 ký tự

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

Japt , 5 byte

c f ¸

Kiểm tra nó

Giải trình

Đầu vào ngầm định của mảng U. Làm phẳng các mảng với c. Lọc nó với fđể loại bỏ 0s. Tham gia nó vào một chuỗi bằng cách sử dụng khoảng trắng với ¸. Ngõ ra đầu ra của chuỗi kết quả.

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

Đầu vào là lồng nhau Object[], đầu ra được in thành STDOUT.

Hãy thử trực tuyến.

46 byte

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

Đầu vào và đầu ra cả như String.

Hãy thử trực tuyến.

C, 45 ký tự

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

Nó giả định rằng đầu vào được đưa ra trong một vùng nhớ có thể sửa đổi được chỉ bởi s.

Python, 99 111 ký tự

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

Phiên bản 99 char trước - không thành công khi chỉ bao gồm danh sách có số không:

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)đệ quy làm phẳng danh sách l, trong khi lọc các số không và chuyển đổi số thành chuỗi.

Scala, 42 ký tự

Mã thông báo chuỗi bằng không chữ số và không chữ số theo sau bằng không.

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

Lời nói đầu (79)

Nó nhập danh sách dưới dạng một thuật ngữ, vì vậy bạn cần đặt một '.' sau danh sách trong đầu vào.

Thực tế không liệt kê danh sách.

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

Hãy thử trực tuyến!

0~⍨ số không được loại bỏ khỏi

∊ các ε nlisted (phẳng) dữ liệu

Stax , 2 byte

$f

Chạy và gỡ lỗi nó

$là phẳng. fđược lọc ra các giá trị falsey và in trên các dòng riêng biệt.

Scala 147:

Làm việc trên danh sách thực, không phải trên chuỗi:

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

Bây giờ là 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 ký tự

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          

đếm dòng 2 chỉ rút ra 'echo $ l |'. Kiểm tra 3 mẫu:

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

Hãy thử trực tuyến!

Giả sử 4-sâu là một cái gì đó như thế {{{{5}}}}. Vì không có ví dụ về điều đó trong các trường hợp thử nghiệm, nó có thể là một cái gì đó như {{{5}}}; nếu là tôi có thể làm cho mã của tôi ngắn hơn!

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

Hãy thử trực tuyến!

Bình thường, 5 byte

jfT.n

Bộ kiểm tra

R , 29 byte

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

Hãy thử trực tuyến!

unlistchuyển đổi danh sách thành atomic vectorđệ quy, vì vậy chúng ta chỉ cần lọc ra các phần tử zero.

JavaScript (Node.js) , 53 byte

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

Hãy thử trực tuyến!

Brachylog , 8 byte

ċ∋↰|ℕ₁ẉ⊥

Hãy thử trực tuyến!

Đưa đầu vào thông qua biến đầu vào và in đầu ra được phân tách bằng các dòng mới. Thông thường tôi sẽ phàn nàn về định dạng đầu ra, nhưng nó thực sự đã tiết kiệm cho tôi một byte theo cách mà tôi có thể không nghĩ khác - đặt ẉ⊥vào cuối là ngắn hơn so với gói nó vào {}ᶠ.

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

Nếu các mục danh sách không bị hạn chế là số nguyên không âm:

Brachylog , 11 byte

ċ!∋↰|0!⊥|ẉ⊥

Hãy thử trực tuyến!

PHP , 70 byte

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

Hãy thử trực tuyến!

Đây sẽ không phải là ngắn nhất (cũng không phải dài nhất), nhưng hình dung nó sẽ là cơ hội để sử dụng array_walk_recursive(), mà cho đến hôm nay tôi không thể nghĩ đến việc sử dụng nó! Ít nhất nó sẽ có thể xử lý một danh sách lồng nhau sâu tùy ý.

Ngôn ngữ Wolfram (Mathicala) , 37 byte

Flatten/*DeleteCases[0]/*StringRiffle

Hãy thử trực tuyến!