Bei einer nicht flachen Liste von Ganzzahlen wird eine Liste von Listen ausgegeben, die die Ganzzahlen in jeder Verschachtelungsebene enthält, beginnend mit der am wenigsten verschachtelten Ebene, wobei die Werte in ihrer ursprünglichen Reihenfolge in der Eingabeliste von links nach rechts gelesen werden. Befinden sich zwei oder mehr Listen in der Eingabeliste auf derselben Verschachtelungsebene, sollten sie in der Ausgabe zu einer einzigen Liste zusammengefasst werden. Die Ausgabe sollte keine leeren Listen enthalten. Verschachtelungsebenen, die nur Listen enthalten, sollten vollständig übersprungen werden.

Sie können davon ausgehen, dass die ganzen Zahlen alle im Bereich (einschließlich) liegen [-100, 100]. Es gibt keine maximale Länge oder Schachtelungstiefe für die Listen. Die Eingabe enthält keine leeren Listen. Jede Verschachtelungsebene enthält mindestens eine Ganzzahl oder Liste.

Die Ein- und Ausgabe muss sich in der systemeigenen Liste / array / enumerable / iterable / etc Ihrer Sprache befinden. Format oder in jedem vernünftigen, eindeutigen Format, wenn in Ihrer Sprache ein Sequenztyp fehlt.

Beispiele

[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

Der führende Raum ist wichtig. Dadurch wird die Liste danach gefiltert, ob die Werte für die sFunktion unveränderlich sind. Anschließend werden diese Werte aus der Liste entfernt und um eine Ebene reduziert. Die Werte werden auch in gespeichert Yund wenn wir drucken, entfernen wir die leeren Werte durch Filtern, wenn der sortierte Wert der Liste wahr ist.

Test Suite

Alternativ eine 15-Byte-Antwort mit einem zweifelhaften Ausgabeformat:

 us-GpWJsI#GJQ)

Test Suite

Erweiterung:

 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 Bytes

_{-2 Bytes aufgrund von Alephalpha .}

_{-2 Bytes aufgrund von CatsAreFluffy .}

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

Löscht tatsächlich leere Ebenen.

Python 2, 78 Bytes

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

Retina , 79

Ich weiß, dass die Retina-Experten dies mehr Golf spielen werden, aber hier ist ein Anfang:

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

Probieren Sie es online aus.

Mathematica 55 64 62 Bytes

#~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 Bytes

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

Vielen Dank, Neil, dass du uns geholfen hast, 32 Bytes zu sparen.

Gelee, 24 Bytes

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

Probieren Sie es online!

Wenn durch Zeilenumbrüche getrennte Listen zulässig wären, könnte dies auf 14 Byte reduziert werden .

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

Probieren Sie es online!

Python, 108 99 Bytes

Das scheint mir ein bisschen lang zu sein, aber ich könnte keinen Einzeiler kürzer machen, und wenn ich es orstattdessen versuche if, bekomme ich leere Listen in den Ergebnissen.

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

Probieren Sie es online aus

Edit: 9 Bytes dank Stack Overflow gespeichert

Python 3, 109 Bytes

Wie immer bedeuten dumme Python 2-Funktionen wie das Vergleichen von ints und lists, dass Python 3 dahinter rauskommt. Naja...

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 Bytes

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

Input wird erwartet in @i, Output produziert in @o. (Ich hoffe das ist akzeptabel).

Beispiel:

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

Ausgabe:

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

Clojure, 119 Bytes

(116 mit seq? Und Eingabe als Listen, eine triviale Modifikation)

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

Besser gedacht:

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

Wenn es mit zwei Argumenten (der aktuellen Ebene und einer Sammlung) aufgerufen wird, wird entweder eine ungeordnete Karte mit einem Element erstellt {level: value} oder ein Aufruf ausgeführtf rekursiv aufgerufen, wenn eine Nicht-Nummer (vermutlich eine Sammlung) angezeigt wird.

Diese Mini-Maps werden dann zu einer einzigen zusammengefügt sorted-mapund Schlüsselkollisionen werden nach concatFunktionen behandelt.valsGibt die Werte der Karte von der ersten bis zur letzten Ebene zurück.

Wenn eine Zahl die einzige auf ihrer Ebene ist, bleibt sie eine vec, andere werden von in Listen umgewandelt concat.

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

Wenn Eingabe a liststatt vecdann number?ersetzt werden könnte seq?, ist seltsamerweise Vektor nicht seq?aber es ist sequential?. Aber ich bin zu faul, um diese Version zu implementieren, Beispiele zu wiederholen usw.

Schläger 259 Bytes

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

Testen:

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

Ausgabe:

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

MATL , 37 Bytes

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

Probieren Sie es online!

Funktioniert mit der aktuellen Version (13.0.0) der Sprache / des Compilers.

Dies erzeugt die Ausgabe als Zeilen mit durch Leerzeichen getrennten Werten, wobei jede Zeile der gleichen Verschachtelungsebene entspricht und verschiedene Verschachtelungsebenen durch Zeilenumbrüche getrennt sind.

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