Dada una lista de enteros, agrupe los elementos que ocurren más primero, luego agrupe los siguientes y así sucesivamente hasta que cada elemento único en la lista se haya agrupado una vez.

Ejemplos:

Entrada: [1,2,3]

Salida: [[1,2,3]]

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

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

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

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

Entrada: []

Salida: []

Entrada: (empty input)

Salida: ERROR/Undefined/Doesn't matter

Reglas

• Las agrupaciones deben ir de frecuencia máxima a frecuencia mínima.
• El orden interno de las agrupaciones es arbitrario (por ejemplo, el ejemplo 3 podría tener [8,6] ).
• Este es el código de golf , el menor recuento de bytes gana.

Relacionado

• Ordenar los distintos elementos de una lista en orden descendente por frecuencia

Pyth , 8 7 bytes

_{M.g/Q

Pruébalo en línea!

1 byte gracias a FryAmTheEggman.

Mathematica, 43 bytes

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

Pruébalo en línea! (Usando matemáticas).

Alternativamente:

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

Pruébalo en línea!

Esta es mi primera presentación después de años de lectura.

Básicamente, pone todos los elementos en un contador (diccionario de cuántos elementos de cada uno de la lista) y .most_common () pone los elementos en orden de frecuencia descendente. Después de eso, solo es cuestión de formatear los elementos en la lista correcta.

Guardado 4 bytes gracias a los ovs .

JavaScript (ES6), 95 101 bytes

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)

¿Cómo?

Para cada elemento x de la matriz de entrada a , calculamos el número n de elementos de a que son diferentes de x :

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

Usamos los índices n y x para llenar la matriz o :

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

Editar : Debido a que JS no admite índices de matriz negativos, necesitamos la fórmula x * x + (x > 0)para forzar índices positivos.

Esto nos da una serie de matrices que contienen los elementos únicos de la lista original, agrupados por frecuencia y ordenados de más frecuentes a menos frecuentes.

Sin embargo, tanto la matriz externa como la matriz interna potencialmente tienen muchas ranuras vacías que queremos filtrar. Hacemos esto con la función F , aplicada a o y cada uno de sus elementos:

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

Casos de prueba

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

Pruébalo en línea!

Jalea , 9 8 bytes

QɓċЀĠṚị

Pruébalo en línea!

Clojure, 74 bytes

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

Parece bastante detallado: /

Perl 6 , 43 bytes

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

Pruébalo

Expandido:

*                   # 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 utilidades, 71 61

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

Ingrese como una lista delimitada por nueva línea. Salida como una lista delimitada por nueva línea de valores separados por comas.

Pruébalo en línea .

MATL , 9 bytes

9B#uw3XQP

La entrada es un vector de columna, que se usa ;como separador.

Pruébalo en línea!

Explicación

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}#:'=

Pruébalo en línea.

^{( La k de AW parece requerir un extra@ antes que el #, pero OK no)}

Explicación:

                     = /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ᵐ²|

Pruébalo en línea!

Explicación

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

entrada

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

salida

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

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.