Étant donné une liste d'entiers, groupez les éléments qui se produisent le plus en premier, puis regroupez les suivants et ainsi de suite jusqu'à ce que chaque élément unique de la liste ait été groupé une fois.

Exemples:

Contribution: [1,2,3]

Sortie: [[1,2,3]]

Contribution: [1,1,1,2,2,3,3,4,5,6]

Sortie: [[1],[2,3],[4,5,6]]

Contribution: [1,1,1,4,5,6,6,6,7,7,8,8,8,8,8,8,8,9,5,6,5,6,5,6,5,6,-56]

Sortie: [[6, 8],[5],[1],[7],[9,4,-56]]

Contribution: []

Sortie: []

Contribution: (empty input)

Sortie: ERROR/Undefined/Doesn't matter

Règles

• Les groupements doivent passer de la fréquence maximale à la fréquence minimale.
• L'ordre interne des regroupements est arbitraire (par exemple, l'exemple 3 pourrait [8,6] place).
• Il s'agit du code-golf , le plus petit nombre de victoires d'octets.

en relation

• Trier les éléments distincts d'une liste par ordre décroissant par fréquence

Pyth , 8 7 octets

_{M.g/Q

Essayez-le en ligne!

1 octet grâce à FryAmTheEggman.

Mathematica, 43 octets

Union/@SortBy[l=#,f=-l~Count~#&]~SplitBy~f&

Essayez-le en ligne! (Utilisation des mathématiques.)

Alternativement:

SortBy[Union[l=#],f=-l~Count~#&]~SplitBy~f&

Python 2 , 145 141 octets

import collections as c,itertools as i;o=lambda n:lambda l:l[n]
print[map(o(0),g)for _,g in i.groupby(c.Counter(input()).most_common(),o(1))]

Essayez-le en ligne!

Ceci est ma première soumission après des années de lecture.

En gros, il place tous les éléments dans un compteur (dictionnaire du nombre de chaque élément de la liste) et .most_common () place les éléments dans l'ordre de fréquence décroissant. Après cela, il suffit de formater les éléments dans la bonne liste.

4 octets enregistrés grâce aux ovs .

JavaScript (ES6), 95 101 octets

a=>a.map(x=>(o[a.map(y=>n+=x!=y,n=0)|n]=o[n]||[])[x*x+(x>0)]=x,o=[])&&(F=o=>o.filter(a=>a))(o).map(F)

Comment?

Pour chaque élément x du tableau d'entrée a , nous calculons le nombre n d'éléments de a différents de x :

a.map(y => n += x != y, n = 0) | n

Nous utilisons les indices n et x pour remplir le tableau o :

(o[n] = o[n] || [])[x * x + (x > 0)] = x

Edit : Parce que JS ne prend pas en charge les indices de tableau négatifs, nous avons besoin de la formule x * x + (x > 0)pour forcer les indices positifs.

Cela nous donne un tableau de tableaux contenant les éléments uniques de la liste d'origine, regroupés par fréquence et classés du plus fréquent au moins fréquent.

Cependant, le tableau externe et les tableaux internes ont potentiellement de nombreux emplacements vides que nous voulons filtrer. Nous le faisons avec la fonction F , appliquée à o et à chacun de ses éléments:

F = o => o.filter(a => a)

Cas de test

let f =

a=>a.map(x=>(o[a.map(y=>n+=x!=y,n=0)|n]=o[n]||[])[x*x+(x>0)]=x,o=[])&&(F=o=>o.filter(a=>a))(o).map(F)

console.log(JSON.stringify(f([1,2,3]))) // [[1,2,3]]
console.log(JSON.stringify(f([1,1,1,2,2,3,3,4,5,6]))) // [[1],[2,3],[4,5,6]]
console.log(JSON.stringify(f([1,1,1,4,5,6,6,6,7,7,8,8,8,8,8,8,8,9,5,6,5,6,5,6,5,6,-56]))) // [[6, 8],[5],[1],[7],[9,4,-56]]
console.log(JSON.stringify(f([]))) // []

PHP , 85 octets

<?$r=[];foreach(array_count_values($_GET)as$k=>$v)$r[$v][]=$k;krsort($r);print_r($r);

Essayez-le en ligne!

Gelée , 9 8 octets

QɓċЀĠṚị

Essayez-le en ligne!

Clojure, 74 octets

#(for[[_ g](sort-by(comp - key)(group-by val(frequencies %)))](map key g))

Semble assez verbeux: /

Perl 6 , 43 octets

*.Bag.classify(-*.value).sort».value».key

Essaye-le

Étendu:

*                   # WhateverCode lambda (this is the input)
                    # [1,1,1,2,2,3,3,4,5,6]

.Bag                # turn into a Bag
                    # (1=>3,5=>1,4=>1,3=>2,6=>1,2=>2).Bag

.classify(-*.value) # classify by how many times each was seen
                    # {-2=>[3=>2,2=>2],-3=>[1=>3],-1=>[5=>1,4=>1,6=>1]}

.sort\              # sort (this is why the above is negative)
                    # {-3=>[1=>3],-2=>[3=>2,2=>2],-1=>[5=>1,4=>1,6=>1]}

».value\            # throw out the classification
                    # ([1=>3],[3=>2,2=>2],[5=>1,4=>1,6=>1])

».key               # throw out the counts
                    # ([1],[3,2],[5,4,6])

Utilitaires Bash + GNU, 71 61

sort|uniq -c|sort -nr|awk '{printf$1-a?"\n%d":",%d",$2;a=$1}'

Entrez en tant que liste délimitée par des sauts de ligne. Sortie sous forme de liste délimitée par des sauts de ligne de valeurs séparées par des virgules.

Essayez-le en ligne .

MATL , 9 octets

9B#uw3XQP

L'entrée est un vecteur de colonne, utilisé ;comme séparateur.

Essayez-le en ligne!

Explication

9B#u   % Call 'unique' function with first and fourth outputs: unique entries and
       % number of occurrences
w      % Swap
3XQ    % Call 'accumarray' with anonymous function @(x){sort(x).'}. The output is
       % a cell array with the elements of the input grouped by their frequency.
       % Cells are sorted by increasing frequency. Some cells may be empty, but
       % those won't be displayed
P      % Flip cell array, so that groups with higher frequency appear first.
       % Implicitly display

k, 22 octets

{x@!x}{(>x)@=x@>x}#:'=

Essayez-le en ligne.

^{( AW's k semble nécessiter un supplément @avant le #, mais oK ne le fait pas.)}

Explication:

                     = /group identical numbers in a map/dict
                  #:'  /get number of times each number is repeated
                       /this is almost the answer, but without the inner lists
      {      x@>x}     /order "number of times" greatest to least
            =          /group them (to make the smaller groups)
       (>x)@           /get the actual numbers into place
{x@!x}                 /get values of the map/dict it's in

Brachylog , 10 octets

ọtᵒ¹tᵍhᵐ²|

Essayez-le en ligne!

Explication

Example input: [2,1,1,3]

ọ            Occurences:            [[2,1],[1,2],[3,1]]
 tᵒ¹         Order desc. by tail:   [[1,2],[3,1],[2,1]]
    tᵍ       Group by tail:         [[[1,2]],[[3,1],[2,1]]]
      hᵐ²    Map twice head:        [[1],[3,2]]

         |   Else (Input = [])      Input = Output

Mathematica, 79 octets

Table[#&@@@f[[i]],{i,Length[f=GatherBy[Sort[Tally@#,#1[[2]]>#2[[2]]&],Last]]}]&

contribution

[{1, 1, 1, 4, 5, 6, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 9, 5, 6, 5, 6, 5, 6, 5, 6, -56}]

sortie

{{8, 6}, {5}, {1}, {7}, {-56, 9, 4}}

R , 84 77 octets

-7 octets grâce à mb7744

unique(lapply(x<-sort(table(scan()),T),function(y)as.double(names(x[x==y]))))

Lit à partir de stdin; renvoie une liste avec des sous-vecteurs d'entiers dans l'ordre croissant. Si nous pouvions renvoyer des chaînes au lieu d'entiers, je pourrais supprimer 11 octets (supprimer l'appel à as.double), mais c'est à peu près tout. La tablefonction de R fait le gros du travail ici, en comptant les occurrences de chaque membre de son entrée; puis il les agrège par count ( names). Bien sûr, c'est une chaîne, nous devons donc la contraindre à un entier / double.

Essayez-le en ligne!

JavaScript (ES6), 100 98 96 93 octets

Enregistré 2 octets grâce à @Neil (en plus, il a corrigé un bug de bord-cas dans mon code). Sauvegardé 3 octets supplémentaires grâce à @TomasLangkaas.

a=>a.sort().map((_,n)=>a.filter((v,i)=>i-a.indexOf(v)==n&v!=a[i+1])).filter(a=>a+a).reverse()

Cas de test

f=
a=>a.sort().map((_,n)=>a.filter((v,i)=>i-a.indexOf(v)==n&v!=a[i+1])).filter(a=>a+a).reverse()

console.log(JSON.stringify(f([1,2,3])))
console.log(JSON.stringify(f([1,1,1,2,2,3,3,4,5,6])))
console.log(JSON.stringify(f([1,1,1,4,5,6,6,6,7,7,8,8,8,8,8,8,8,9,5,6,5,6,5,6,5,6,-56])))
console.log(JSON.stringify(f([])))

V , 60 , 54 octets

Úòͨ¼¾©î±/± ±òHòø 
pkJjòú!
Ǩ^ƒ ©î±/o
Îf ld|;D
òV{Jk

Essayez-le en ligne!

Hexdump:

00000000: daf2 cda8 bc81 bea9 eeb1 2fb1 20b1 f248  ........../. ..H
00000010: f2f8 200a 706b 4a6a f2fa 210a c7a8 5e83  .. .pkJj..!...^.
00000020: 20a9 81ee b12f 6f0a ce66 206c 647c 3b44   ..../o..f ld|;D
00000030: 0af2 567b 4a6b                           ..V{Jk

Autant que j'aime V, je suis presque sûr que c'est le pire langage possible pour la tâche. Surtout si l'on considère qu'il n'a pas de support pour les listes, et fondamentalement pas de support pour les nombres. Manipulation de chaîne juste.

C #, 119 octets

Juste un coup d'œil rapide:

using System.Linq;
a=>a.GroupBy(x=>x)
    .GroupBy(x=>x.Count(),x=>x.Key)
    .OrderBy(x=>-x.Key)
    .Select(x=>x.ToArray())
    .ToArray()

R, 66 bytes

(l=lapply)(l(split(x<-table(scan()),factor(-x)),names),as.integer)

Try it online!

If in the output the integers may be in string format, can drop to 48 bytes (as mentioned in @Giuseppe's answer).

Ungolfed:

input <- scan(); # read input
x <- table(input); # count how many times each integer appears, in a named vector
y <- split(x, factor(-x)) # split the count into lists in increasing order
z <- lapply(y, names) # access the the original values which are still
                      # attached via the names
lapply(z, as.integer) # convert the names back to integers

PowerShell, 77, 70 bytes

($a=$args)|group{($a-eq$_).count}|sort n* -Des|%{,($_.group|sort -u)}

NB: To see that these results are correctly grouped (since visually there's no deliniation between the contents of each array), you may wish to append | write-host to the end of the above line.

Acknowledgements

Thanks to:

• TessellatingHeckler for saving 7 bytes by massively refactoring / rewriting to a way more golfed approach.

Previous

77 bytes

param($x)$x|group|sort count -desc|group count|%{,($_.group|%{$_.group[0]})}

Groovy, 71 octets

{a->a.groupBy{a.count(it)}.sort{-it.key}.values().collect{it.unique()}}

En fait, je viens d'apprendre sur groupBy après avoir créé cela. Je ne savais pas que collecter n'était pas mon seul choix.

{
    a->                 // [1,2,1,2,3,3,3,6,5,4]
    a.groupBy{      
        a.count(it)     // [2:[1,2,1,2],3:[3,3,3],1:[6,5,4]]
    }.sort{             
        -it.key         // [3:[3,3,3],2:[1,2,1,2],1:[6,5,4]]
    }.values().collect{ // [[3,3,3],[1,2,1,2],[6,5,4]]
        it.unique()
    }                   // [[3],[1,2],[6,5,4]]
}

Rubis , 62 octets

->a{a.group_by{|e|a.count(e)}.sort_by{|x,_|-x}.map{|_,i|i|[]}}

Essayez-le en ligne!

Il doit y avoir un moyen plus court de le faire.