Diberikan daftar bilangan bulat yang tidak rata, mengeluarkan daftar daftar yang berisi bilangan bulat di setiap tingkat bersarang, dimulai dengan tingkat paling tidak-bertingkat, dengan nilai-nilai dalam urutan aslinya dalam daftar input saat dibaca dari kiri ke kanan. Jika dua atau lebih daftar berada pada level bersarang yang sama dalam daftar input, mereka harus digabungkan menjadi satu daftar di output. Output tidak boleh berisi daftar kosong apa pun - level bersarang yang hanya berisi daftar harus dilewati seluruhnya.

Anda dapat mengasumsikan bahwa bilangan bulat semuanya berada dalam kisaran (inklusif) [-100, 100]. Tidak ada panjang maksimal atau kedalaman bersarang untuk daftar. Tidak akan ada daftar kosong di input - setiap tingkat bersarang akan mengandung setidaknya satu bilangan bulat atau daftar.

Input dan output harus dalam daftar / array / enumerable / iterable / etc asli bahasa Anda. format, atau dalam format wajar, tidak ambigu jika bahasa Anda tidak memiliki jenis urutan.

Contohnya

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

Pyth, 17

 us-GeaYsI#GQ)S#Y

Ruang utama itu penting. Ini memfilter daftar pada apakah nilai-nilai invarian pada sfungsi, kemudian menghapus nilai-nilai ini dari daftar dan meratakannya satu tingkat. Nilai-nilai juga disimpan di Ydan ketika kami mencetak kami menghapus nilai-nilai kosong dengan memfilter jika nilai daftar yang diurutkan benar.

Test Suite

Atau, jawaban 15 byte dengan format output yang meragukan:

 us-GpWJsI#GJQ)

Test Suite

Ekspansi:

 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

Mathematica, 56 54 52 byte

_{-2 byte karena Alephalpha .}

_{-2 byte karena CatsAreFluffy .}

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

Sebenarnya menghapus level kosong.

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],[]))

Retina , 79

Saya tahu para ahli Retina akan bermain golf ini lebih banyak, tapi ini awalnya:

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

Cobalah online.

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

Terima kasih Neil untuk membantu mengurangi 32 byte.

Jelly, 24 byte

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

Cobalah online!

Jika daftar yang dipisahkan baris baru diizinkan, ini bisa di-golf hingga 14 byte .

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

Cobalah online!

Python, 108 99 byte

Ini sepertinya agak lama bagi saya, tetapi saya tidak bisa membuat satu-liner lebih pendek, dan jika saya mencoba menggunakan oralih-alih if, saya mendapatkan daftar kosong di hasilnya.

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

Cobalah online

Sunting: Disimpan 9 byte berkat Stack Overflow

Python 3, 109 byte

Seperti biasa, fitur Python 2 bodoh seperti membandingkan ints dan lists berarti bahwa Python 3 keluar di belakang. Baiklah...

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}

Input diharapkan masuk @i, output diproduksi pada @o. (Saya harap ini bisa diterima).

Contoh:

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

Keluaran:

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

Clojure, 119 byte

(116 dengan seq? Dan masukan sebagai daftar, modifikasi sepele)

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

Ditujukan lebih baik:

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

Ketika dipanggil dengan dua argumen (level saat ini dan koleksi) itu baik membuat satu elemen-unordered-map seperti {level: value}, atau panggilan fsecara rekursif jika non-nomor (mungkin koleksi) terlihat.

Peta mini ini kemudian digabung menjadi satu sorted-mapdan tumbukan utama ditangani oleh concatfungsi. valsmengembalikan nilai peta dari tingkat pertama ke yang terakhir.

Jika angka adalah satu-satunya pada levelnya maka itu tetap a vec, yang lain dikonversi menjadi daftar oleh concat.

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

Jika input listbukan, vecmaka number?bisa diganti dengan seq?, anehnya vektor tidak seq?tetapi itu sequential?. Tapi saya terlalu malas untuk mengimplementasikan versi itu, melakukan kembali contoh dll.

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

Tidak Disatukan:

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

Pengujian:

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

Keluaran:

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

MATL , 37 byte

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

Cobalah online!

Bekerja dengan rilis saat ini (13.0.0) dari bahasa / kompiler.

Ini menghasilkan output sebagai garis-garis nilai-nilai yang dipisahkan ruang, di mana setiap baris sesuai dengan tingkat bersarang yang sama, dan tingkat bersarang yang berbeda dipisahkan oleh baris baru.

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