整数の非フラットリストが指定されている場合、左から右に読むと、入力リストの元の順序の値で、ネストの最小レベルから始まる各ネストレベルの整数を含むリストのリストを出力します。入力リストで2つ以上のリストが同じ入れ子レベルにある場合、それらを出力で1つのリストに結合する必要があります。出力には空のリストを含めないでください。リストのみを含むネストレベルは完全にスキップする必要があります。

整数はすべて（範囲内）の範囲にあると仮定できます[-100, 100]。リストの最大長またはネストの深さはありません。入力には空のリストはありません。すべてのネストレベルには、少なくとも1つの整数またはリストが含まれます。

入力と出力は、言語のネイティブリスト/配列/列挙可能/反復可能/などである必要があります。形式、または言語にシーケンス型がない場合は、合理的で明確な形式。

例

[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関数で不変であるかどうかのリストがフィルタリングされ、リストからこれらの値が削除されて、1レベルフラット化されます。値は次の場所にも保存されます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バイト

_{Alephalphaによる-2バイト。}

_{CatsAreFluffyによる-2バイト。}

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)

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バイト保存

Python 3、109バイト

相変わらず、intsとlistsの比較のような愚かなPython 2の機能は、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)))

2つの引数（現在のレベルとコレクション）で呼び出されると{level: value}、のような1要素の順序付けられていないマップを作成するか、f場合、のか、非数値（presumamblyコレクション）が見つかった場合に再帰的に。

これらのミニマップは単一にマージされ、sorted-mapキーの衝突はconcat機能ごとに処理されます。valsマップの値を最初のレベルから最後のレベルまで返します。

番号がそのレベルで唯一のものである場合、それはaのままでvec、他はリストによってリストに変換されますconcat。

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

入力がthenのlist代わりにで置き換えられた場合、奇妙なベクトルはそうではありませんが、そうです。しかし、私はそのバージョンを実装したり、サンプルをやり直したりするのが面倒です。vecnumber?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))))))

ゴルフをしていない：

(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