Bei einer Liste von Ganzzahlen gruppieren Sie die Elemente, die zuerst am häufigsten vorkommen, und gruppieren Sie dann die nächsten am häufigsten usw., bis jedes einzelne Element in der Liste einmal gruppiert wurde.

Beispiele:

Eingang: [1,2,3]

Ausgabe: [[1,2,3]]

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

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

Eingang: [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]

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

Eingang: []

Ausgabe: []

Eingang: (empty input)

Ausgabe: ERROR/Undefined/Doesn't matter

Regeln

• Die Gruppierungen müssen von der Maximalfrequenz zur Minimalfrequenz gehen.
• Die interne Reihenfolge der Gruppierungen ist willkürlich (zB könnte Beispiel 3 [8,6]stattdessen haben).
• Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt.

verbunden

• Sortieren Sie die einzelnen Elemente einer Liste in absteigender Reihenfolge nach Häufigkeit

Pyth , 8 7 Bytes

_{M.g/Q

Probieren Sie es online!

1 Byte danke an FryAmTheEggman.

Mathematica, 43 Bytes

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

Probieren Sie es online! (Verwenden von Mathematik.)

Alternative:

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

Python 2 , 145 141 Bytes

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

Probieren Sie es online!

Dies ist meine erste Vorlage nach Jahren des Lesens.

Im Grunde genommen werden alle Elemente in einem Zähler abgelegt ( Verzeichnis der Anzahl der Elemente in der Liste) und .most_common () ordnet die Elemente in absteigender Reihenfolge der Häufigkeit an. Danach müssen die Elemente nur noch in der richtigen Liste formatiert werden.

4 Bytes dank ovs gespart .

JavaScript (ES6), 95 bis 101 Byte

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)

Wie?

Für jedes Element x des Eingabearrays a berechnen wir die Anzahl n der Elemente von a , die sich von x unterscheiden :

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

Wir verwenden die Indizes n und x , um das Array o zu füllen :

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

Bearbeiten : Da JS keine negativen Array-Indizes unterstützt, benötigen wir die Formel x * x + (x > 0), um positive Indizes zu erzwingen.

Dies gibt uns ein Array von Arrays, die die eindeutigen Elemente der ursprünglichen Liste enthalten, gruppiert nach Häufigkeit und geordnet von am häufigsten bis am seltensten.

Sowohl das äußere als auch das innere Array haben möglicherweise viele leere Slots, die herausgefiltert werden sollen. Wir tun dies mit der Funktion F , die auf o und jedes seiner Elemente angewendet wird :

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

Testfälle

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 Bytes

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

Probieren Sie es online!

Gelee , 9 8 Bytes

QɓċЀĠṚị

Probieren Sie es online!

Clojure, 74 Bytes

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

Sieht ziemlich ausführlich aus: /

Perl 6 , 43 Bytes

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

Probier es aus

Erweitert:

*                   # 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])

Bash + GNU-Dienstprogramme, 71 61

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

Eingabe als durch neue Zeilen getrennte Liste. Ausgabe als durch Zeilenumbrüche getrennte Liste von durch Kommas getrennten Werten.

Probieren Sie es online aus .

MATL , 9 Bytes

9B#uw3XQP

Die Eingabe ist ein Spaltenvektor, der ;als Trennzeichen verwendet wird.

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online aus.

^{( AW's k scheint ein Extra @vor dem zu erfordern #, aber OK nicht.)}

Erläuterung:

                     = /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 Bytes

ọtᵒ¹tᵍhᵐ²|

Probieren Sie es online!

Erläuterung

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 Bytes

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

Eingang

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

Ausgabe

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

R , 84 77 Bytes

-7 Bytes dank mb7744

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

Liest von stdin; Gibt eine Liste mit Untervektoren von ganzen Zahlen in aufsteigender Reihenfolge zurück. Wenn wir Strings anstelle von ints zurückgeben könnten, dann könnte ich 11 Bytes löschen (den Aufruf von entfernen as.double), aber das war es auch schon. Die tableFunktion von R übernimmt hier das schwere Heben, indem die Vorkommen jedes Mitglieds seiner Eingabe gezählt werden. dann aggregiert es sie nach count ( names). Natürlich ist das eine Zeichenkette, also müssen wir sie zu einer Ganzzahl / einem Doppelten zwingen.

Probieren Sie es online!

JavaScript (ES6), 100 98 96 93 Byte

2 Bytes dank @Neil gespart (und einen Edge-Case-Fehler in meinem Code behoben). 3 weitere Bytes dank @TomasLangkaas gespeichert.

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

Testfälle

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 Bytes

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

Probieren Sie es online!

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

So sehr ich V auch liebe, ich bin mir ziemlich sicher, dass dies die schlechteste Sprache für diese Aufgabe ist. Besonders wenn man bedenkt, dass es keine Unterstützung für Listen und im Grunde keine Unterstützung für Zahlen gibt. Nur die Manipulation von Strings.

C #, 119 Bytes

Nur ein kurzer Versuch:

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)

Probieren Sie es online!

Wenn die Ganzzahlen in der Ausgabe möglicherweise im Zeichenfolgenformat vorliegen, können sie auf 48 Byte sinken (wie in der Antwort von @ Giuseppe angegeben).

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 Byte

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

Hinweis: Um sicherzustellen, dass diese Ergebnisse korrekt gruppiert sind (da visuell keine Abgrenzung zwischen den Inhalten der einzelnen Arrays besteht), möchten Sie möglicherweise | write-hostdas Ende der obigen Zeile anhängen .

Danksagung

Dank an:

• TessellatingHeckler für das Einsparen von 7 Bytes durch massives Refactoring / Umschreiben, um den Golfansatz zu verbessern.

Bisherige

77 Bytes

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

Groovy, 71 Bytes

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

Ich habe gerade erst von groupBy erfahren, als ich das erstellt habe. Ich wusste nicht, dass Sammeln nicht meine einzige Wahl ist.

{
    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]]
}

Ruby , 62 Bytes

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

Probieren Sie es online!

Dafür muss es einen kürzeren Weg geben.