Étant donné une liste non plate d'entiers, affichez une liste de listes contenant les entiers dans chaque niveau d'imbrication, en commençant par le niveau le moins imbriqué, avec les valeurs dans leur ordre d'origine dans la liste d'entrée lors de la lecture de gauche à droite. Si deux ou plusieurs listes sont au même niveau d'imbrication dans la liste d'entrée, elles doivent être combinées en une seule liste dans la sortie. La sortie ne doit contenir aucune liste vide - les niveaux d'imbrication qui ne contiennent que des listes doivent être entièrement ignorés.

Vous pouvez supposer que les nombres entiers sont tous dans la plage (inclusive) [-100, 100] . Il n'y a pas de longueur maximale ni de profondeur d'imbrication pour les listes. Il n'y aura pas de listes vides dans l'entrée - chaque niveau d'imbrication contiendra au moins un entier ou une liste.

L'entrée et la sortie doivent être dans la liste native / tableau / enumerable / iterable / etc de votre langue. format, ou dans tout format raisonnable et sans ambiguïté si votre langue n'a pas de type de séquence.

Exemples

[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

L'espace de tête est important. Cela filtre la liste pour savoir si les valeurs sont invariantes sur la sfonction, puis supprime ces valeurs de la liste et l'aplatit d'un niveau. Les valeurs sont également stockées dansY et lorsque nous imprimons, nous supprimons les valeurs vides en filtrant si la valeur triée de la liste est véridique.

Suite de tests

Alternativement, une réponse de 15 octets avec un format de sortie douteux:

 us-GpWJsI#GJQ)

Suite de tests

Expansion:

 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 octets

_{-2 octets dus à Alephalpha .}

_{-2 octets en raison de CatsAreFluffy .}

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

Supprime réellement les niveaux vides.

Python 2, 78 octets

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

Rétine , 79

Je sais que les experts de la rétine joueront davantage au golf, mais voici un début:

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

Essayez-le en ligne.

Mathematica 55 64 62 octets

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

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

Merci Neil d'avoir aidé à raser 32 octets.

Gelée, 24 octets

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

Essayez-le en ligne!

Si les listes séparées par des sauts de ligne étaient autorisées, cela pourrait être réduit à 14 octets .

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

Essayez-le en ligne!

Python, 108 99 octets

Cela me semble un peu long, mais je ne pouvais pas raccourcir une ligne, et si j'essaie d'utiliser à la orplace de if, j'obtiens des listes vides dans les résultats.

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

Essayez-le en ligne

Edit: 9 octets enregistrés grâce à Stack Overflow

Python 3, 109 octets

Comme toujours, des fonctionnalités stupides de Python 2 comme comparer ints et lists signifient que Python 3 sort derrière. Tant pis...

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 octets

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

Des entrées sont attendues en @i, des sorties produites en@o . (J'espère que c'est acceptable).

Exemple:

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

Sortie:

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

Clojure, 119 octets

(116 avec seq? Et entrée sous forme de listes, une modification triviale)

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

Mieux destiné:

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

Lorsqu'il est appelé avec deux arguments (le niveau actuel et une collection), il crée une carte non ordonnée à un élément {level: value}ou appellef manière récursive si un non-numéro (vraisemblablement une collection) est vu.

Ces mini-cartes sont ensuite fusionnées en une seule sorted-mapet les collisions clés sont traitées par concatfonction.valsrenvoie les valeurs de la carte du premier niveau au dernier.

Si un nombre est le seul à son niveau, il reste un vec, d'autres sont convertis en listes par concat.

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

Si l'entrée était un listau lieu de vecalors number?pourrait être remplacé par seq?, curieusement le vecteur ne l'est pas seq?mais il l'est sequential?. Mais je suis trop paresseux pour implémenter cette version, refaire des exemples, etc.

Raquette 259 octets

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

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

Essai:

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

Sortie:

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

MATL , 37 octets

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

Essayez-le en ligne!

Fonctionne avec la version actuelle (13.0.0) du langage / compilateur.

Cela produit la sortie sous forme de lignes de valeurs séparées par des espaces, où chaque ligne correspond au même niveau d'imbrication et différents niveaux d'imbrication sont séparés par des retours à la ligne.

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