Biorąc pod uwagę niepłaską listę liczb całkowitych, wypisz listę list zawierających liczby całkowite na każdym poziomie zagnieżdżenia, zaczynając od poziomu najmniej zagnieżdżonego, z wartościami w ich oryginalnej kolejności na liście wejściowej podczas czytania od lewej do prawej. Jeśli dwie lub więcej list znajduje się na tym samym poziomie zagnieżdżenia na liście danych wejściowych, należy je połączyć w jedną listę danych wyjściowych. Dane wyjściowe nie powinny zawierać żadnych pustych list - poziomy zagnieżdżenia zawierające tylko listy należy całkowicie pominąć.

Możesz założyć, że wszystkie liczby całkowite należą do (włącznie) zakresu [-100, 100]. Dla list nie ma maksymalnej długości ani głębokości zagnieżdżenia. Na wejściu nie będzie pustych list - każdy poziom zagnieżdżenia będzie zawierał co najmniej jedną liczbę całkowitą lub listę.

Dane wejściowe i wyjściowe muszą znajdować się na rodzimej liście / tablicy / enumerable / iterable / etc w twoim języku. format lub w jakimkolwiek rozsądnym, jednoznacznym formacie, jeśli w twoim języku brakuje typu sekwencji.

Przykłady

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

 us-GeaYsI#GQ)S#Y

Wiodąca przestrzeń jest ważna. Filtruje listę pod kątem tego, czy wartości są niezmienne w sfunkcji, a następnie usuwa te wartości z listy i spłaszcza ją o jeden poziom. Wartości są również przechowywane, Ya kiedy drukujemy, usuwamy puste wartości, filtrując, czy posortowana wartość listy jest prawdziwa.

Pakiet testowy

Alternatywnie 15-bajtowa odpowiedź o wątpliwym formacie wyjściowym:

 us-GpWJsI#GJQ)

Pakiet testowy

Ekspansja:

 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 bajty

_{-2 bajty z powodu Alephalpha .}

_{-2 bajty z powodu CatsAreFluffy .}

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

Właściwie usuwa puste poziomy.

Python 2, 78 bajtów

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

Retina , 79

Ja wiem, eksperci Retina golf będzie to więcej, ale tu jest początek:

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

Wypróbuj online.

Mathematica 55 64 62 bajtów

#~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 bajtów

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

Dzięki Neil za pomoc w goleniu 32 bajtów.

Galaretka, 24 bajty

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

Wypróbuj online!

Gdyby dozwolone były listy rozdzielone znakiem nowej linii, można by dodać do 14 bajtów .

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

Wypróbuj online!

Python, 108 99 bajtów

Wydaje mi się to trochę za długie, ale nie mogłem skrócić linijki o jeden wiersz i jeśli spróbuję użyć orzamiast tego if, otrzymam puste listy w wynikach.

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

Wypróbuj online

Edycja: Zapisano 9 bajtów dzięki przepełnieniu stosu

Python 3, 109 bajtów

Jak zawsze, głupie funkcje Pythona 2, takie jak porównywanie ints i lists, oznaczają, że Python 3 ustępuje. No cóż...

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 bajty

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

Dane wejściowe są oczekiwane w @i, dane wyjściowe wyprodukowane w @o. (Mam nadzieję, że jest to do przyjęcia).

Przykład:

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

Wydajność:

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

Clojure, 119 bajtów

(116 z sekwencją? I wprowadzaniem jako listy, trywialna modyfikacja)

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

Lepsze przeznaczenie:

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

Po wywołaniu z dwoma argumentami (bieżącym poziomem i kolekcją) albo tworzy jednoelementową, nieuporządkowaną mapę podobną {level: value}, albo wywołuje frekurencyjnie, jeśli widzi się liczbę inną niż (prawdopodobnie kolekcję).

Te mini-mapy są następnie łączone w jedną, sorted-mapa kolizje kluczy są obsługiwane według concatfunkcji. valszwraca wartości mapy od pierwszego poziomu do ostatniego.

Jeśli liczba jest jedyną na swoim poziomie, to pozostaje a vec, inne są konwertowane na listy przez concat.

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

Jeśli wejście było listzamiast, vecto number?może zostać zastąpione przez seq?, dziwnie wektor nie jest, seq?ale jest sequential?. Ale jestem zbyt leniwy, aby wdrożyć tę wersję, przerobić przykłady itp.

Rakieta 259 bajtów

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

Nie golfowany:

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

Testowanie:

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

Wydajność:

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

MATL , 37 bajtów

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

Wypróbuj online!

Działa z bieżącą wersją (13.0.0) języka / kompilatora.

Daje to wynik jako linie wartości oddzielonych spacjami, gdzie każda linia odpowiada temu samemu poziomowi zagnieżdżenia, a różne poziomy zagnieżdżenia są oddzielone znakami nowej linii.

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