รับรายการจำนวนเต็มจัดกลุ่มองค์ประกอบที่เกิดขึ้นเป็นอันดับแรกจากนั้นจัดกลุ่มรายการถัดไปเป็นลำดับถัดไปเรื่อย ๆ จนกระทั่งแต่ละองค์ประกอบที่ไม่ซ้ำกันในรายการได้รับการจัดกลุ่มหนึ่งครั้ง

ตัวอย่าง:

การป้อนข้อมูล: [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

กฎระเบียบ

• การจัดกลุ่มจะต้องเปลี่ยนจากความถี่สูงสุดไปเป็นความถี่ต่ำสุด
• คำสั่งภายในของการจัดกลุ่มเป็นแบบสุ่ม (ตัวอย่างที่ 3 อาจมี[8,6]แทน)
• นี่คือรหัส - กอล์ฟชนะน้อยที่สุดนับไบต์

ที่เกี่ยวข้อง

• เรียงลำดับองค์ประกอบที่แตกต่างของรายการตามลำดับจากมากไปน้อยตามความถี่

Pyth , 8 7 ไบต์

_{M.g/Q

ลองออนไลน์!

1 ไบต์ต้องขอบคุณ FryAmTheEggman

Mathematica, 43 ไบต์

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

ลองออนไลน์! (ใช้คณิตศาสตร์)

อีกวิธีหนึ่งคือ:

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

ลองออนไลน์!

นี่คือการส่งครั้งแรกของฉันหลังจากปีของการอ่าน

โดยพื้นฐานแล้วมันจะใส่องค์ประกอบทั้งหมดลงในตัวนับ (พจนานุกรมจำนวนองค์ประกอบแต่ละรายการในรายการ) และ . most_common ()ใส่รายการในลำดับความถี่ในการตัดสินใจ หลังจากนั้นมันเป็นเพียงเรื่องของการจัดรูปแบบรายการลงในรายการที่ถูกต้อง

ที่บันทึกไว้ 4 ไบต์ขอบคุณที่OVS

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ขององค์ประกอบของaที่แตกต่างจาก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))

ดูเหมือน verbose ค่อนข้าง: /

Perl 6 , 43 ไบต์

*.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, 8, 9, 5, 6, 5, 6, 5, 6, 5, 6, -56}]

เอาท์พุต

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

R , 84 77 ไบต์

-7 ไบต์ขอบคุณ mb7744

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

อ่านจาก stdin; ส่งคืนรายการที่มีตัวคั่นย่อยของจำนวนเต็มในลำดับที่เพิ่มขึ้น หากเราสามารถส่งคืนสตริงแทน ints ได้ฉันสามารถวาง 11 ไบต์ (ลบการเรียกไปยังas.double) แต่นั่นเป็นเรื่องเกี่ยวกับมัน tableฟังก์ชั่นของ R คือการยกของหนักที่นี่นับจำนวนการเกิดของสมาชิกแต่ละคนของอินพุต จากนั้นจะรวมพวกเขาด้วยการนับ ( names) แน่นอนว่าเป็นสตริงดังนั้นเราต้องบีบบังคับให้เป็นจำนวนเต็ม / คู่

ลองออนไลน์!

JavaScript (ES6), 100 98 96 93 ไบต์

บันทึก 2 ไบต์ด้วย @Neil (และเขาแก้ไขข้อผิดพลาดของ edge-case ในรหัสของฉัน) บันทึกอีก 3 ไบต์ขอบคุณ @TomasLangkaas

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 bytes

Just a quick stab at it:

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)

Try it online!

If in the output the integers may be in string format, can drop to 48 bytes (as mentioned in @Giuseppe's answer).

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 bytes

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

NB: To see that these results are correctly grouped (since visually there's no deliniation between the contents of each array), you may wish to append | write-host to the end of the above line.

Acknowledgements

Thanks to:

• TessellatingHeckler for saving 7 bytes by massively refactoring / rewriting to a way more golfed approach.

Previous

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

I actually just learned about groupBy after creating this. I didn't know collect wasn't my only choice.

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

Try it online!

There has got to be a shorter way to do this.