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.