ให้ลิสต์ของจำนวนเต็มแบบไม่แบนเอาท์พุทลิสต์ของรายการที่มีจำนวนเต็มในแต่ละระดับการซ้อนเริ่มต้นด้วยระดับที่ซ้อนกันน้อยที่สุดโดยมีค่าตามลำดับดั้งเดิมในรายการอินพุตเมื่ออ่านจากซ้ายไปขวา หากรายการสองรายการขึ้นไปอยู่ในระดับการซ้อนเดียวกันในรายการอินพุตรายการเหล่านั้นควรรวมกันเป็นรายการเดียวในเอาต์พุต เอาต์พุตไม่ควรมีรายการว่างใด ๆ - ระดับการซ้อนที่มีเฉพาะรายการควรถูกข้ามทั้งหมด

คุณอาจจะคิดว่าเลขที่มีทั้งหมดใน (รวม) [-100, 100]ช่วง ไม่มีความยาวสูงสุดหรือความลึกการซ้อนสำหรับรายการ จะไม่มีรายการว่างในอินพุต - ทุกระดับการซ้อนจะมีจำนวนเต็มหรือรายการอย่างน้อยหนึ่งรายการ

อินพุตและเอาต์พุตต้องอยู่ในรายการ / อาร์เรย์ / enumerable / iterable / etc ในภาษาของคุณ รูปแบบหรือในรูปแบบที่สมเหตุสมผลและชัดเจนใด ๆ หากภาษาของคุณไม่มีประเภทของลำดับ

ตัวอย่าง

[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

พื้นที่ชั้นนำมีความสำคัญ สิ่งนี้จะกรองรายการว่าค่าคงที่ในsฟังก์ชันหรือไม่จากนั้นลบค่าเหล่านี้ออกจากรายการและทำให้แบนหนึ่งระดับ ค่าจะถูกเก็บไว้ในYและเมื่อเราพิมพ์เราจะลบค่าว่างโดยการกรองหากค่าที่เรียงของรายการนั้นเป็นจริง

ชุดทดสอบ

อีกทางเลือกหนึ่งคือ 15 ไบต์ด้วยรูปแบบเอาต์พุตที่น่าสงสัย:

 us-GpWJsI#GJQ)

ชุดทดสอบ

ขยาย:

 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 ไบต์

_{-2 ไบต์เนื่องจากAlephalpha}

_{-2 ไบต์เนื่องจากCatsAreFluffy}

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

จริง ๆ แล้วลบระดับว่างเปล่า

Python 2, 78 ไบต์

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

เรติน่า , 79

ฉันรู้ว่าผู้เชี่ยวชาญ Retina จะตีกอล์ฟให้มากกว่านี้ แต่นี่เป็นการเริ่มต้น:

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

ลองออนไลน์

Mathematica 55 64 62 ไบต์

#~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 ไบต์

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

ขอบคุณ Neil ที่ช่วยโกนหนวดออกไป 32 ไบต์

เยลลี่ 24 ไบต์

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

ลองออนไลน์!

หากรายการขึ้นบรรทัดใหม่แยกออกจากกันได้รับอนุญาตนี้อาจจะแข็งแรงเล่นกอล์ฟลงไป14 ไบต์

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

ลองออนไลน์!

Python, 108 99 ไบต์

ดูเหมือนว่าจะค่อนข้างยาวสำหรับฉัน แต่ฉันไม่สามารถทำให้ซับในสั้นลงและถ้าฉันลองใช้orแทนifฉันจะได้รายการเปล่าในผลลัพธ์

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

ลองออนไลน์

แก้ไข: บันทึกแล้ว 9 ไบต์ขอบคุณ Stack Overflow

Python 3, 109 ไบต์

เช่นเคยคุณลักษณะ Python 2 ที่โง่เขลาเช่นการเปรียบเทียบints และlists หมายความว่า Python 3 ออกมาด้านหลัง โอ้ดี ...

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 ไบต์

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

คาดว่าอินพุตจะเป็น@iเอาต์พุตที่สร้าง@oขึ้น (ฉันหวังว่านี่จะเป็นที่ยอมรับได้)

ตัวอย่าง:

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

เอาท์พุท:

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

Clojure, 119 ไบต์

(116 ที่มี seq? และป้อนเป็นรายการการแก้ไขเล็กน้อย)

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

ตั้งใจดีกว่า:

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

เมื่อเรียกว่ามีสองข้อโต้แย้ง (ระดับปัจจุบันและคอลเลกชัน) มันจะสร้างองค์ประกอบหนึ่งเหมือนแผนที่ unordered {level: value}หรือเรียกfซ้ำถ้าไม่เห็นจำนวน (สันนิษฐานคอลเลกชัน)

แผนที่ขนาดเล็กเหล่านี้จะถูกรวมเข้าด้วยกันเป็นหนึ่งเดียวsorted-mapและการชนคีย์นั้นได้รับการจัดการโดยconcatฟังก์ชัน valsส่งคืนค่าของแผนที่จากระดับแรกถึงระดับสุดท้าย

หากตัวเลขเป็นเพียงตัวเลขเดียวที่อยู่ในระดับเดียวกันvecตัวเลขจะถูกแปลงเป็นรายการconcatอื่น ๆ

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

ถ้าใส่เป็นlistแทนvecแล้วnumber?จะถูกแทนที่ด้วยseq?แปลกเวกเตอร์ไม่ได้แต่มันก็เป็นseq? sequential?แต่ฉันขี้เกียจเกินไปที่จะใช้เวอร์ชันนั้นทำซ้ำตัวอย่าง ฯลฯ

แร็กเก็ต 259 ไบต์

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

Ungolfed:

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

การทดสอบ:

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

เอาท์พุท:

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

MATL , 37 ไบต์

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

ลองออนไลน์!

ทำงานร่วมกับรีลีสปัจจุบัน (13.0.0)ของภาษา / คอมไพเลอร์

สิ่งนี้สร้างเอาต์พุตเป็นบรรทัดของค่าที่คั่นด้วยช่องว่างโดยที่แต่ละบรรทัดสอดคล้องกับระดับการซ้อนเดียวกันและระดับการซ้อนที่แตกต่างกันจะถูกคั่นด้วยบรรทัดใหม่

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