Đưa ra một danh sách các số nguyên, nhóm các phần tử xảy ra nhiều nhất trước, sau đó nhóm nhiều nhất tiếp theo và cứ thế cho đến khi mỗi phần tử duy nhất trong danh sách được nhóm lại một lần.

Ví dụ:

Đầu vào: [1,2,3]

Đầu ra: [[1,2,3]]

Đầu vào: [1,1,1,2,2,3,3,4,5,6]

Đầu ra: [[1],[2,3],[4,5,6]]

Đầu vào: [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]

Đầu ra: [[6, 8],[5],[1],[7],[9,4,-56]]

Đầu vào: []

Đầu ra: []

Đầu vào: (empty input)

Đầu ra: ERROR/Undefined/Doesn't matter

Quy tắc

• Các nhóm phải đi từ tần số tối đa đến tần số tối thiểu.
• Thứ tự nội bộ của các nhóm là tùy ý (ví dụ EG 3 có thể có [8,6]thay thế).
• Đây là môn đánh gôn , đánh số byte thấp nhất.

Liên quan

• Sắp xếp các thành phần riêng biệt của danh sách theo thứ tự giảm dần theo tần suất

Bình thường , 8 7 byte

_{M.g/Q

Hãy thử trực tuyến!

1 byte nhờ FryAmTheEggman.

Toán học, 43 byte

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

Hãy thử trực tuyến! (Sử dụng toán học.)

Cách khác:

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

Python 2 , 145 141 byte

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

Hãy thử trực tuyến!

Đây là bài nộp đầu tiên của tôi sau nhiều năm đọc.

Về cơ bản, nó đặt tất cả các phần tử vào một Counter (từ điển có bao nhiêu phần tử trong danh sách) và. Maximum_common () đặt các mục theo thứ tự tần số giảm dần. Sau đó, vấn đề chỉ là định dạng các mục vào đúng danh sách.

Đã lưu 4 byte nhờ vào ovs .

JavaScript (ES6), 95 101 byte

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)

Làm sao?

Với mỗi phần tử x của mảng đầu vào a , chúng tôi tính số n của các phần tử của a khác với x :

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

Chúng tôi sử dụng các chỉ số n và x để điền vào mảng o :

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

Chỉnh sửa : Vì JS không hỗ trợ các chỉ số mảng âm, nên chúng tôi cần công thức x * x + (x > 0)để buộc các chỉ số dương.

Điều này cung cấp cho chúng tôi một mảng các mảng chứa các thành phần duy nhất của danh sách gốc, được nhóm theo tần suất và được sắp xếp theo thứ tự từ thường xuyên nhất đến ít thường xuyên nhất.

Tuy nhiên, cả mảng bên ngoài và mảng bên trong có khả năng có nhiều vị trí trống mà chúng tôi muốn lọc ra. Chúng tôi thực hiện điều này với hàm F , áp dụng cho o và từng phần tử của nó:

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

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Thạch , 9 8 byte

QɓċЀĠṚị

Hãy thử trực tuyến!

Clojure, 74 byte

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

Trông khá dài dòng: /

Perl 6 , 43 byte

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

Kiểm tra nó

Mở rộng:

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

Tiện ích Bash + GNU, 71 61

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

Nhập dưới dạng danh sách giới hạn dòng mới. Xuất ra dưới dạng một danh sách được phân tách bằng dòng mới của các giá trị được phân tách bằng dấu phẩy.

Hãy thử trực tuyến .

MATL , 9 byte

9B#uw3XQP

Đầu vào là một vectơ cột, sử dụng ;như dấu phân cách.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến.

^{( AW's k dường như yêu cầu thêm @trước #, nhưng oK thì không.)}

Giải trình:

                     = /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 byte

ọtᵒ¹tᵍhᵐ²|

Hãy thử trực tuyến!

Giải trình

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

Toán học, 79 byte

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

đầu vào

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

đầu ra

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

R , 84 77 byte

-7 byte nhờ mb7744

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

Đọc từ stdin; trả về một danh sách với các phần tử con của số nguyên theo thứ tự tăng dần. Nếu chúng ta có thể trả về chuỗi thay vì ints, thì tôi có thể giảm 11 byte (loại bỏ cuộc gọi đến as.double), nhưng đó là về nó. tableChức năng của R thực hiện việc nâng vật nặng ở đây, đếm số lần xuất hiện của từng thành viên đầu vào; sau đó nó tổng hợp chúng bằng cách đếm ( names). Tất nhiên, đó là một chuỗi, vì vậy chúng ta phải ép buộc nó thành một số nguyên / gấp đôi.

Hãy thử trực tuyến!

JavaScript (ES6), 100 98 96 93 byte

Đã lưu 2 byte nhờ @Neil (cộng với anh ấy đã sửa lỗi trường hợp cạnh trong mã của tôi). Đã lưu thêm 3 byte nhờ @TomasLangkaas.

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

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

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

Tôi yêu V rất nhiều, tôi khá chắc chắn đây là ngôn ngữ tồi tệ nhất có thể cho nhiệm vụ. Đặc biệt là xem xét nó không có hỗ trợ cho danh sách, và về cơ bản không hỗ trợ cho các con số. Chỉ cần thao tác chuỗi.

C #, 119 byte

Chỉ cần một cú đâm nhanh vào nó:

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 byte

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

Hãy thử trực tuyến!

Nếu trong đầu ra, số nguyên có thể ở định dạng chuỗi, có thể giảm xuống 48 byte (như được đề cập trong câu trả lời của @ Giuseppe).

Ung dung:

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

Lưu ý: Để thấy rằng các kết quả này được nhóm chính xác (vì trực quan không có phân định giữa các nội dung của từng mảng), bạn có thể muốn nối | write-hostvào cuối dòng trên.

Lời cảm ơn

Nhờ vào:

• TessellatingHeckler để lưu 7 byte bằng cách tái cấu trúc / viết lại ồ ạt theo cách tiếp cận nhiều hơn.

Trước

77 byte

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

Groovy, 71 byte

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

Tôi thực sự chỉ tìm hiểu về groupBy sau khi tạo ra điều này. Tôi không biết thu thập không phải là lựa chọn duy nhất của tôi.

{
    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 byte

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

Hãy thử trực tuyến!

Phải có một cách ngắn hơn để làm điều này.