Dada una lista no entera de enteros, genera una lista de listas que contienen los enteros en cada nivel de anidación, comenzando con el nivel menos anidado, con los valores en su orden original en la lista de entrada cuando se leen de izquierda a derecha. Si dos o más listas están en el mismo nivel de anidación en la lista de entrada, deben combinarse en una sola lista en la salida. La salida no debe contener listas vacías; los niveles de anidamiento que contienen solo listas deben omitirse por completo.

Puede suponer que todos los enteros están en el rango (inclusive) [-100, 100]. No hay una longitud máxima o profundidad de anidamiento para las listas. No habrá listas vacías en la entrada; cada nivel de anidamiento contendrá al menos un número entero o lista.

La entrada y la salida deben estar en la lista / matriz / enumerable / iterable / etc de su idioma nativo. formato, o en cualquier formato razonable e inequívoco si su idioma carece de un tipo de secuencia.

Ejemplos

[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

El espacio principal es importante. Esto filtra la lista sobre si los valores son invariables en la sfunción, luego elimina estos valores de la lista y lo aplana un nivel. Los valores también se almacenan Yy, cuando imprimimos, eliminamos los valores vacíos filtrando si el valor ordenado de la lista es verdadero.

Banco de pruebas

Alternativamente, una respuesta de 15 bytes con un formato de salida dudoso:

 us-GpWJsI#GJQ)

Banco de pruebas

Expansión:

 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 debido a Alephalpha .}

_{-2 bytes debido a CatsAreFluffy .}

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

En realidad elimina niveles vacíos.

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

Yo sé los expertos Retina campo de esto más, pero aquí es un comienzo:

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

Pruébalo en línea.

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)

Gracias Neil por ayudar a reducir 32 bytes.

Jalea, 24 bytes

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

Pruébalo en línea!

Si se permitieran listas separadas por una nueva línea, esto podría reducirse a 14 bytes .

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

Pruébalo en línea!

Python, 108 99 bytes

Esto me parece un poco largo, pero no podría acortar una línea, y si intento usar en orlugar de if, obtengo listas vacías en los resultados.

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

Pruébalo en línea

Editar: guardado 9 bytes gracias a Stack Overflow

Python 3, 109 bytes

Como siempre, estúpidos Python 2 características como la comparación de ints y lists media que Python 3 viene detrás. Oh bien...

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}

Se espera entrada en @i, salida producida en @o. (Espero que esto sea aceptable).

Ejemplo:

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

Salida:

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

Clojure, 119 bytes

(116 con seq? Y entrada como listas, una modificación trivial)

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

Mejor pensado:

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

Cuando se llama con dos argumentos (el nivel actual y una colección), crea un mapa desordenado de un elemento como {level: value}, o llama frecursivamente si se ve un no número (presumiblemente una colección).

Estos minimapas se fusionan en una sola sorted-mapy las colisiones clave se manejan por concatfunción. valsDevuelve los valores del mapa desde el primer nivel hasta el último.

Si un número es el único en su nivel, sigue siendo un vec, otros se convierten en listas por concat.

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

Si la entrada fuera un en listlugar de vecentonces number?podría ser reemplazada por seq?, curiosamente el vector no seq?lo es, pero lo es sequential?. Pero soy demasiado vago para implementar esa versión, rehacer ejemplos, etc.

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

Sin golf:

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

Pruebas:

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

Salida:

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

MATL , 37 bytes

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

Pruébalo en línea!

Funciona con la versión actual (13.0.0) del lenguaje / compilador.

Esto produce la salida como líneas de valores separados por espacios, donde cada línea corresponde al mismo nivel de anidación, y los diferentes niveles de anidación están separados por nuevas líneas.

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