整数のリストが与えられたら、最も最初に出現する要素をグループ化し、次にリスト内の各一意の要素が一度グループ化されるまで、2番目に多くの要素をグループ化します。

例：

入力： [1,2,3]

出力： [[1,2,3]]

入力： [1,1,1,2,2,3,3,4,5,6]

出力： [[1],[2,3],[4,5,6]]

入力： [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]]

入力： []

出力： []

入力： (empty input)

出力： ERROR/Undefined/Doesn't matter

ルール

• グループ化は、最大頻度から最小頻度まで行わなければなりません。
• グループ化の内部順序は任意です（EGの例3が[8,6]代わりに持つことができます）。
• これはcode-golfであり、バイト数が最も少なくなります。

関連する

• リストの個別の要素を頻度で降順に並べ替えます

Pyth、8 7バイト

_{M.g/Q

オンラインでお試しください！

FryAmTheEggmanのおかげで1バイト。

Mathematica、43バイト

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

オンラインでお試しください！（数学を使用。）

代わりに：

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

パイソン2、145の 141バイト

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

オンラインでお試しください！

これは長年の読書の後の私の最初の提出です。

基本的には、すべての要素をカウンター（リスト内の各要素の数の辞書）に入れ、.most_common（）は頻度の降順で項目を入れます。その後は、アイテムを正しいリストにフォーマットするだけです。

ovsのおかげで4バイト節約されました。

JavaScript（ES6）、95 101バイト

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)

どうやって？

各要素のためのX入力配列のA、我々は数を計算するn個の要素の異なるそのX。

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

インデックスnとxを使用して、配列oを埋めます。

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

編集：JSは負の配列インデックスをサポートしていないため、式が必要ですx * x + (x > 0)正のインデックスを強制がです。

これにより、元のリストの一意の要素を含む配列の配列が得られ、頻度でグループ化され、頻度の高い順に並べられます。

ただし、外側の配列と内側の配列の両方に、除外する空のスロットが多数ある可能性があります。これを、関数Fをoとその各要素に適用して行います。

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

テストケース

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バイト

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

オンラインでお試しください！

ゼリー、9 8バイト

QɓċЀĠṚị

オンラインでお試しください！

Clojure、74バイト

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

非常に冗長に見える：/

Perl 6バイト

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

試して

拡張：

*                   # 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ユーティリティ、71 61

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

改行区切りリストとして入力します。カンマ区切り値の改行区切りリストとして出力します。

オンラインでお試しください。

MATL、9バイト

9B#uw3XQP

入力は、;セパレータとして使用する列ベクトルです。

オンラインでお試しください！

説明

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バイト

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

オンラインでお試しください。

^{（AWのkはの@前に余分なものが必要なようです#が、oKは必要ありません。}

説明：

                     = /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バイト

ọtᵒ¹tᵍhᵐ²|

オンラインでお試しください！

説明

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バイト

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

入力

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

出力

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

R、84 77バイト

mb7744のおかげで-7バイト

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

stdinから読み取ります。整数のサブベクトルのリストを昇順で返します。intの代わりに文字列を返すことができれば、11バイトをドロップできます（への呼び出しを削除します）as.double）が、です。Rのtable関数はここで面倒な処理を行い、入力の各メンバーの発生をカウントします。次に、それらをカウント（names）。もちろん、それは文字列なので、整数/倍精度に強制する必要があります。

オンラインでお試しください！

JavaScript（ES6）、100 98 96 93バイト

@Neilのおかげで2バイト節約されました（さらに、彼は私のコードのエッジケースのバグを修正しました）。@TomasLangkaasのおかげでさらに3バイト節約できました。

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

テストケース

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のバイト

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

オンラインでお試しください！

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

私はVが大好きであるのと同様に、これがタスクにとって可能な最悪の言語であると確信しています。特に、リストのサポートがなく、基本的に数値のサポートがないことを考慮してください。単なる文字列操作。

C＃、119バイト

それをちょっと突き刺してください：

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バイト

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

オンラインでお試しください！

出力で整数が文字列形式の場合は、48バイトにドロップできます（@Giuseppeの回答に記載されているように）。

ゴルフをしていない：

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のバイト

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

NB：これらの結果が正しくグループ化されていることを確認するには（視覚的に各配列の内容間にデリニエーションがないため）、追加することができます。 | write-host上記の行の最後する。

謝辞

おかげで：

• TessellatingHecklerは、大幅にリファクタリング/リライトすることで7バイトを節約し、よりゴルフに近いアプローチにしています。

前

77バイト

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

Groovy、71バイト

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

これを作成してから実際にgroupByについて学びました。収集が唯一の選択肢ではないことを知りませんでした。

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

ルビー、62バイト

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

オンラインでお試しください！

これを行うには、もっと短い方法が必要です。