Bir tamsayı listesi verildiğinde, en önce gerçekleşen öğeleri gruplandırın, ardından listedeki her bir benzersiz öğe bir kez gruplanıncaya kadar en sonuncuyu ve diğerlerini gruplandırın.

Örnekler:

Giriş: [1,2,3]

Çıktı: [[1,2,3]]

Giriş: [1,1,1,2,2,3,3,4,5,6]

Çıktı: [[1],[2,3],[4,5,6]]

Giriş: [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]

Çıktı: [[6, 8],[5],[1],[7],[9,4,-56]]

Giriş: []

Çıktı: []

Giriş: (empty input)

Çıktı: ERROR/Undefined/Doesn't matter

kurallar

• Gruplamalar maksimum frekanstan minimum frekansa geçmelidir.
• Grupların iç sırası isteğe bağlıdır ( [8,6]bunun yerine EG örnek 3 olabilir ).
• Bu kod golf , en düşük bayt sayma kazançtır.

İlgili

• Bir listenin farklı öğelerini sıklığa göre azalan düzende sıralama

Pyth , 8 7 bayt

_{M.g/Q

Çevrimiçi deneyin!

FryAmTheEggman sayesinde 1 bayt.

Mathematica, 43 bayt

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

Çevrimiçi deneyin! (Matematik kullanarak.)

Alternatif:

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

Python 2 , 145 141 bayt

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

Çevrimiçi deneyin!

Bu yıllarca okuduktan sonra ilk gönderim.

Temel olarak, tüm öğeleri bir Sayaç içine koyar (listedeki her bir öğenin kaç tanesinin sözlüğü) ve .most_common () öğeleri azalan sıklık sırasına koyar. Ondan sonra, sadece öğeleri doğru listeye biçimlendirme meselesi.

Ovs sayesinde 4 byte kurtarıldı .

JavaScript (ES6), 95 101 bayt

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)

Nasıl?

Her bir eleman için, x Girdi dizisi bir a , biz dizi hesaplamak n elemanlarının bir farklı olduğu , x :

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

Biz endeksi kullanmak , n ve x dizisini doldurmak için o :

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

Düzenleme : JS negatif dizi endekslerini desteklemediğinden, x * x + (x > 0)pozitif endeksleri zorlamak için formüle ihtiyacımız var .

Bu, bize orijinal listenin benzersiz öğelerini içeren, sıklığa göre gruplandırılmış ve en sık sık en az sıkça sıralanan bir dizi dizisi verir.

Bununla birlikte, hem dış dizi hem de iç diziler potansiyel olarak filtrelemek istediğimiz birçok boş yuvaya sahiptir. Bunu, F'ye , o'ya ve elemanlarının her birine uygulanan :

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

Test durumları

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 bayt

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

Çevrimiçi deneyin!

Jöle , 9 8 bayt

QɓċЀĠṚị

Çevrimiçi deneyin!

Clojure, 74 bayt

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

Çok ayrıntılı görünüyor:

Perl 6 , 43 bayt

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

Dene

Expanded:

*                   # 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 yardımcı programları, 71 61

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

Yeni satır ayrılmış bir liste olarak giriş yapın. Yeni satırlı, virgülle ayrılmış değerler listesi olarak çıktı alın.

Çevrimiçi deneyin .

MATL , 9 bayt

9B#uw3XQP

Giriş, ;ayırıcı olarak kullanan bir sütun vektörüdür .

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin.

^{( AW’lerin k’sinden@ önce bir ekstraya ihtiyaç var gibi gözüküyor #, ancak OK bunu gerektirmiyor .)}

Açıklama:

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

ọtᵒ¹tᵍhᵐ²|

Çevrimiçi deneyin!

açıklama

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 bayt

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

giriş

[{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)

çıktı

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

R , 84 77 bayt

Mb7744 sayesinde -7 bayt

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

Stdin'den okur; Tamsayı alt düzenleyicileri ile artan düzende bir liste döndürür. Eğer string yerine string döndürebilirsek, 11 byte bırakabilirim (çağrıyı kaldırabilirim as.double), ama bununla ilgili. R'nin tableişlevi burada ağır kaldırma yapar ve girişindeki her bireyin oluşumunu sayar; daha sonra onları count ( names) ile toplar . Tabii ki, bu bir dize, bu yüzden onu bir tamsayıya / çiftliğe zorlamak zorundayız.

Çevrimiçi deneyin!

JavaScript (ES6), 100 98 96 93 bayt

@Neil sayesinde 2 bayt kaydedildi (ayrıca kodumda bir uç hata oluştu). @TomasLangkaas sayesinde 3 bayt daha kaydedildi.

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

Test durumları

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 bayt

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

Çevrimiçi deneyin!

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'yi sevdiğim kadarıyla, bu iş için mümkün olan en kötü dil olduğundan eminim. Özellikle listeler için bir desteğe sahip olmadığı ve temelde sayılar için bir desteğe sahip olmadığı düşünüldüğünde. Sadece dize manipülasyonu.

C #, 119 bayt

Sadece hızlı bir bıçakla:

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 bayt

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

Çevrimiçi deneyin!

Çıktıda tamsayılar dize biçiminde ise, 48 bayta kadar düşebilir (@ Giuseppe'nin cevabında belirtildiği gibi).

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 bayt

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

Not: Bu sonuçların doğru bir şekilde gruplandırıldığını görmek için (görsel olarak her dizinin içeriği arasında bir ayrım olmadığından), | write-hostyukarıdaki satırın sonuna eklemek isteyebilirsiniz .

Teşekkür

Sayesinde:

• TessellatingHeckler kitlesel / üstlenmeden daha yaklaşım golfed bir şekilde yeniden yazarak 7 bayt kaydetmek için.

Önceki

77 bayt

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

Groovy, 71 bayt

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

Aslında bunu yarattıktan sonra groupBy'yi öğrendim. Collect'in tek seçeneğim olmadığını bilmiyordum.

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

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

Çevrimiçi deneyin!

Bunu yapmanın daha kısa bir yolu olmalı.