R , 84 77 bytes

-7 bytes gracias a mb7744

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

Lee de stdin; devuelve una lista con subvectores de enteros en orden creciente. Si pudiéramos devolver cadenas en lugar de ints, podría eliminar 11 bytes (eliminando la llamada a as.double), pero eso es todo. La tablefunción de R hace el trabajo pesado aquí, contando las ocurrencias de cada miembro de su entrada; luego los agrega por count ( names). Por supuesto, es una cadena, por lo que tenemos que obligarla a un entero / doble.

Pruébalo en línea!

JavaScript (ES6), 100 98 96 93 bytes

Ahorré 2 bytes gracias a @Neil (además corrigió un error de caso de borde en mi código). Ahorré 3 bytes más gracias a @TomasLangkaas.

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

Casos de prueba

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

Pruébalo en línea!

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

Por mucho que amo a V, estoy bastante seguro de que este es el peor lenguaje posible para la tarea. Especialmente considerando que no tiene soporte para listas, y básicamente no tiene soporte para números. Solo manipulación de cuerdas.

C #, 119 bytes

Solo una puñalada rápida:

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)

Pruébalo en línea!

Si en la salida los enteros pueden estar en formato de cadena, pueden caer a 48 bytes (como se menciona en la respuesta de @ Giuseppe).

Sin golf:

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

Potencia Shell, 77, 70 bytes

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

NB: Para ver que estos resultados están agrupados correctamente (ya que visualmente no hay delincuencia entre los contenidos de cada matriz), puede agregar | write-hostal final de la línea anterior.

Expresiones de gratitud

Gracias a:

• TessellatingHeckler para ahorrar 7 bytes refactorizando / reescribiendo masivamente a un enfoque mucho más complejo.

Anterior

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

De hecho, acabo de enterarme de groupBy después de crear esto. No sabía que cobrar no era mi única opción.

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

Pruébalo en línea!

Tiene que haber una forma más corta de hacer esto.