Đưa ra một danh sách các số nguyên không phẳng, xuất ra một danh sách các danh sách chứa các số nguyên ở mỗi cấp lồng nhau, bắt đầu với mức lồng nhau ít nhất, với các giá trị theo thứ tự ban đầu trong danh sách đầu vào khi đọc từ trái sang phải. Nếu hai hoặc nhiều danh sách ở cùng một mức lồng nhau trong danh sách đầu vào, chúng sẽ được kết hợp thành một danh sách duy nhất trong đầu ra. Đầu ra không được chứa bất kỳ danh sách trống nào - các mức lồng nhau chỉ chứa các danh sách nên được bỏ qua hoàn toàn.

Bạn có thể cho rằng các số nguyên đều nằm trong phạm vi (bao gồm) [-100, 100]. Không có chiều dài tối đa hoặc độ sâu lồng cho danh sách. Sẽ không có danh sách trống trong đầu vào - mỗi cấp độ lồng sẽ chứa ít nhất một số nguyên hoặc danh sách.

Đầu vào và đầu ra phải nằm trong danh sách / mảng / liệt kê / lặp lại / ngôn ngữ của ngôn ngữ của bạn. định dạng hoặc ở bất kỳ định dạng hợp lý, rõ ràng nào nếu ngôn ngữ của bạn thiếu loại trình tự.

Ví dụ

[1, 2, [3, [4, 5], 6, [7, [8], 9]]] => [[1, 2], [3, 6], [4, 5, 7, 9], [8]]

[3, 1, [12, [14, [18], 2], 1], [[4]], 5] => [[3, 1, 5], [12, 1], [14, 2, 4], [18]]

[2, 1, [[5]], 6] => [[2, 1, 6], [5]]

[[54, [43, 76, [[[-19]]]], 20], 12] => [[12], [54, 20], [43, 76], [-19]]

[[[50]], [[50]]] => [[50, 50]]

Bình thường, 17

 us-GeaYsI#GQ)S#Y

Không gian hàng đầu là quan trọng. Cái này lọc danh sách xem các giá trị có bất biến trên shàm hay không, sau đó xóa các giá trị này khỏi danh sách và làm phẳng nó một cấp. Các giá trị cũng được lưu trữ trong Yvà khi chúng tôi in, chúng tôi sẽ xóa các giá trị trống bằng cách lọc nếu giá trị được sắp xếp của danh sách là trung thực.

Phòng thử nghiệm

Ngoài ra, một câu trả lời 15 byte với định dạng đầu ra đáng ngờ:

 us-GpWJsI#GJQ)

Phòng thử nghiệm

Sự bành trướng:

 us-GeaYsI#GQ)S#Y     ##   Q = eval(input)
 u          Q)        ##   reduce to fixed point, starting with G = Q
        sI#G          ##   get the values that are not lists from G
                      ##   this works because s<int> = <int> but s<list> = flatter list
      aY              ##   append the list of these values to Y
     e                ##   flatten the list
   -G                 ##   remove the values in the list from G
              S#Y     ##   remove empty lists from Y

Toán học, 56 54 52 byte

_{-2 byte do Alephalpha .}

_{-2 byte do CatsAreFluffy .}

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}/.{}->Nothing&

Trên thực tế xóa các mức trống.

Python 2, 78 byte

f=lambda l:l and zip(*[[x]for x in l if[]>x])+f(sum([x for x in l if[]<x],[]))

Võng mạc , 79

Tôi biết các chuyên gia Retina sẽ đánh gôn này nhiều hơn, nhưng đây là một khởi đầu:

{([^{}]+)}(,?)([^{}]*)
$3$2<$1>
)`[>}],?[<{]
,
(\d),+[<{]+
$1},{
<+
{
,*[>}]+
}

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

Toán học 55 64 62 byte

#~Select~AtomQ/.{}->Nothing&/@Table[Level[#,{k}],{k,Depth@#}]&

%&[{1, 2, {3, {4, 5}, 6, {7, {8}, 9}}}]

{{1, 2}, {3, 6}, {4, 5, 7, 9}, {8}}

JavaScript, 112 80 byte

F=(a,b=[],c=0)=>a.map(d=>d!==+d?F(d,b,c+1):b[c]=[...b[c]||[],d])&&b.filter(d=>d)

Cảm ơn Neil đã giúp cạo sạch 32 byte.

Thạch, 24 byte

fFW®;©ṛ¹ḟF;/µŒḊ’$¡W®Tị¤;

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

Nếu danh sách phân tách dòng mới được cho phép, điều này có thể được giảm xuống còn 14 byte .

fFṄ¹¹?ḟ@¹;/µ¹¿

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

Python, 108 99 byte

Điều này có vẻ hơi dài đối với tôi, nhưng tôi không thể làm cho một lớp lót ngắn hơn và nếu tôi thử sử dụng orthay vì if, tôi nhận được danh sách trống trong kết quả.

def f(L):
    o=[];i=[];j=[]
    for x in L:[i,j][[]<x]+=[x]
    if i:o+=[i]
    if j:o+=f(sum(j,[]))
    return o

Dùng thử trực tuyến

Chỉnh sửa: Đã lưu 9 byte nhờ Stack Overflow

Python 3, 109 byte

Như mọi khi, các tính năng Python 2 ngu ngốc như so sánh ints và lists có nghĩa là Python 3 xuất hiện phía sau. Ồ tốt ...

def d(s):
 o=[]
 while s:
  l,*n=[],
  for i in s:
   try:n+=i
   except:l+=[i]
  if l:o+=[l]
  s=n
 return o

Perl, 63 byte

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}

Đầu vào dự kiến @i, đầu ra được sản xuất trong @o. (Tôi hy vọng điều này được chấp nhận).

Thí dụ:

@i=[[54, [43, 76, [[[-19]]]], 20], 12];                              # input

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}      # the snippet

use Data::Dumper;                                                    # print output
$Data::Dumper::Indent=0;  # keep everything on one line
$Data::Dumper::Terse=1;   # don't print $VAR =
print Dumper(\@o);

Đầu ra:

[[12],[54,20],[43,76],[-19]]

Clojure, 119 byte

(116 với seq? Và nhập vào dưới dạng danh sách, một sửa đổi nhỏ)

(defn f([v](vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

Dự định tốt hơn:

(defn f([v]  (vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))
       ([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

Khi được gọi với hai đối số (cấp độ hiện tại và bộ sưu tập), nó sẽ tạo ra một bản đồ không có thứ tự một phần tử {level: value}, hoặc gọi fđệ quy nếu nhìn thấy một số không (có lẽ là một bộ sưu tập).

Các bản đồ mini này sau đó được hợp nhất thành một sorted-mapva chạm chính và được xử lý theo concatchức năng. valstrả về giá trị của bản đồ từ cấp đầu tiên đến cấp cuối cùng.

Nếu một số là số duy nhất ở cấp của nó thì nó vẫn là một vec, số khác được chuyển đổi thành danh sách theo concat.

(f [[54, [43, 76, [[[-19]]]], 20], 12])
([12] (54 20) (43 76) [-19])

Nếu đầu vào là một listthay thế vecsau đó number?có thể được thay thế bằng seq?, vectơ kỳ lạ không phải seq?là nó sequential?. Nhưng tôi quá lười để thực hiện phiên bản đó, làm lại các ví dụ, v.v.

Vợt 259 byte

(let((ol'())(m 0))(let p((l l)(n 0))(cond[(empty? l)][(list?(car l))(set! m(+ 1 n))
(p(car l)(+ 1 n))(p(cdr l)n)][(set! ol(cons(list n(car l))ol))(p(cdr l)n )]))
(for/list((i(+ 1 m)))(flatten(map(λ(x)(cdr x))(filter(λ(x)(= i(list-ref x 0)))(reverse ol))))))

Ung dung:

(define (f l)
  (define ol '())
  (define maxn 0)
  (let loop ((l l)              ; in this loop each item is added with its level
             (n 0))
    (cond
      [(empty? l)]
      [(list? (first l))
       (set! maxn (add1 n))
       (loop (first l) (add1 n))
       (loop (rest l) n)]
      [else
       (set! ol (cons (list n (first l)) ol))
       (loop (rest l) n )]))

  ; now ol is '((0 1) (0 2) (1 3) (2 4) (2 5) (1 6) (2 7) (3 8) (2 9)) 

  (for/list ((i (add1 maxn)))   ; here similar levels are combined
    (flatten
     (map (λ (x) (rest x))      ; level numbers are removed
          (filter (λ (x) (= i(list-ref x 0)))
                  (reverse ol))))))

Kiểm tra:

(f '[1 2 [3 [4 5] 6 [7 [8] 9]]])

Đầu ra:

'((1 2) (3 6) (4 5 7 9) (8))

MATL , 37 byte

j']['!=dYsXKu"GK@=)'[\[\],]'32YXUn?1M

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

Hoạt động với bản phát hành hiện tại (13.0.0) của ngôn ngữ / trình biên dịch.

Điều này tạo ra đầu ra dưới dạng các dòng của các giá trị được phân tách bằng dấu cách, trong đó mỗi dòng tương ứng với cùng một mức lồng và các mức lồng khác nhau được phân tách bằng các dòng mới.

j            % read input as string (row array of chars)
']['!        % 2x1 array containing ']'  and '['
=            % test for equality, all combinations
d            % row array obtained as first row minus second row
Ys           % cumulative sum. Each number is a nesting level
XK           % copy to clibdoard K
u            % unique values: all existing nesting levels
"            % for each nesting level
  G          %   push input
  K          %   push array that indicates nesting level of each input character
  @          %   push level corresponding to this iteration
  =          %   true for characters corresponding to that nesting level
  )          %   pick those characters
  '[\[\],]'  %   characters to be replaced
  32         %   space
  YX         %   regexp replacement
  U          %   only numbers and spaces remain: convert string to array of numbers
  n?         %   if non-empty
    1M       %     push that array of numbers again
             %   end if implicitly
             % end for each implicitly