정수 목록이 주어지면 가장 먼저 나타나는 요소를 그룹화 한 다음 목록의 각 고유 요소가 한 번 그룹화 될 때까지 다음으로 가장 많이 그룹화하십시오.

예 :

입력: [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 바이트.

수학, 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 바이트가 절약되었습니다 .

자바 스크립트 (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 입력 어레이의 우리 계산할 수 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)양의 인덱스를 강제 하려면 수식 이 필요합니다 .

이것은 우리에게 빈도별로 그룹화되고 가장 빈번한 순서에서 가장 빈번한 순서로 원본 목록의 고유 한 요소를 포함하는 배열의 배열을 제공합니다.

그러나 외부 배열과 내부 배열에는 필터링하려는 빈 슬롯이 많이있을 수 있습니다. o 와 각 요소에 적용되는 함수 F 로이를 수행합니다 .

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ɓċЀĠṚị

온라인으로 사용해보십시오!

클로저, 74 바이트

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

꽤 장황 해 보인다 : /

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

배쉬 + 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)로 집계합니다 . 물론 이것은 문자열이므로 정수 / 더블로 강제 변환해야합니다.

온라인으로 사용해보십시오!

자바 스크립트 (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

온라인으로 사용해보십시오!

16 진 덤프 :

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)

온라인으로 사용해보십시오!

출력에서 정수가 문자열 형식 일 경우 @Giuseppe의 답변에서 언급 한 것처럼 48 바이트로 떨어질 수 있습니다 .

언 골프 드 :

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

그루비, 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|[]}}

온라인으로 사용해보십시오!

이 작업을 수행하는 더 짧은 방법이 있습니다.