Liste veya dizi alan ve ayrı öğelerin listesini sıklık derecesine göre azalan düzende döndüren bir işlev yazın.

Misal:

Verilen:

["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"]

Beklenen getiri değeri:

["Doe","Harry","John","Dick"]

APL (14)

{∪⍵[⍒+⌿∘.≡⍨⍵]}

Bu, bir listeyi alan bir işlevdir, örneğin:

      names
 John  Doe  Dick  Harry  Harry  Doe  Doe  Harry  Doe  John 
      {∪⍵[⍒+⌿∘.≡⍨⍵]} names
 Doe  Harry  John  Dick

Açıklama:

• ∘.≡⍨⍵: bir matris vererek dizideki her öğeyi dizideki diğer öğelerle karşılaştırın
• +⌿: her bir öğenin kaç kez oluştuğunu vererek matrisin sütunlarını toplar
• ⍒: aşağı yönlü endeksler vermek
• ⍵[... ]: ⍵verilen endekslere göre yeniden sırala
• ∪: benzersiz unsurları elde edin

Python 3 - 47 43; Python 2-40 39

Python 3 için:

f=lambda n:sorted(set(n),key=n.count)[::-1]

Python 2 için:

f=lambda n:sorted(set(n),cmp,n.count,1)

Demo:

>>> names = ["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"]
>>> f(names)
['Doe', 'Harry', 'John', 'Dick']

Mathematica, 31

Sort[GatherBy@n][[-1;;1;;-1,1]]

{"Doe", "Harry", "John", "Dick"}

(İle n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"})

Mathematica (26 37)

İle n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"}:

Last/@Gather@n~SortBy~Length//Reverse

{"Doe", "Harry", "John", "Dick"}

Mathematica V10 + (26) :

Keys@Sort[Counts[n],#>#2&]

Perl 6 (36 bayt, 35 karakter)

»>>UTF-8 ile işlem yapamıyorsanız, ile değiştirilebilir . Bunun daha kısa olabileceğinden neredeyse eminim, ancak Bagsınıf davranışında nispeten garip (ne yazık ki) ve nispeten yeni olduğu için gerçekten tam değil (ancak argümanları sayabilir). {}anonim bir işlev bildirir.

{(sort -*.value,pairs bag @_)».key}

Örnek çıktı (Perl 6 REPL'den):

> my @names = ("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")
John Doe Dick Harry Harry Doe Doe Harry Doe John
> {(sort -*.value,pairs bag @_)».key}(@names)
Doe Harry John Dick

Yakut: 34 37 karakterler

f=->a{a.sort_by{|z|-a.count(z)}&a}

(düzenlenmiş: önceki 30 karakterlik çözüm, işlevin gövdesiydi)

GolfScript, 14 karakter (adlandırılmış işlev olarak 19, ayrıca tam program olarak 14)

:a.|{[.]a\-,}$

Bu kod, yığındaki bir diziyi alır ve benzersiz öğelerini, gerçekleşme sayısına göre azalan sırada sıralar. Örneğin, girdi dizisi:

["John" "Doe" "Dick" "Harry" "Harry" "Doe" "Doe" "Harry" "Doe" "John"]

çıkış dizisi

["Doe" "Harry" "John" "Dick"]

Not: Yukarıdaki kod çıplak bir ifade dizisidir. Adı adlandırılmış bir işleve dönüştürmek için onu parantez içine alın ve aşağıdaki gibi bir ada atayın:

{:a.|{[.]a\-,}$}:f;

Alternatif olarak, kodu standart girişten bir liste okuyan (yukarıda gösterilen liste gösterimini kullanarak) tam bir programa dönüştürmek ve bunu standart çıktıya yazdırmak, başa ~eklemek `ve koda eklemek . [. Bu durumda atlanabilir böylece ortaya çıkan 14 karakterlik programı olacağını, (biz yığın başka bir şey olacağını biliyorum beri):

~:a.|{]a\-,}$`

O nasıl çalışır?

• :aorijinal dizinin bir kopyasını adaha sonra kullanmak üzere değişkene kaydeder .

• .| dizinin küme birleşimini kendisi ile hesaplar, yinelemeleri yan etki olarak ortadan kaldırır.

• { }$parantez içindeki kod tarafından hesaplanan özel sıralama tuşlarını kullanarak çoğaltılmış diziyi sıralar. Bu kod, her dizi öğesini alır, kaydedilmiş orijinal giriş dizisinden kaldırmak için dizi çıkarma özelliğini kullanır ave kalan öğelerin sayısını sayar. Böylece, elemanlar azalan frekans sırasına göre sıralanır.

Ps. Orijinal 30 karakterlik sürüm için buraya bakın .

R: 23 karakter

n <- c("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")

names(sort(table(n),T))
## [1] "Doe"   "Harry" "John"  "Dick" 

Ama değil çok güzel kısayol kullanır Tiçin TRUE...

bu buraya sığabilseydi: In sql-server

create table #t1 (name varchar(10))
insert into #t1 values ('John'),('Doe'),('Dick'),('Harry'),('Harry'),('Doe'),('Doe'),('Harry'),('Doe'),('John')


select name from #t1 group by name order by count(*) desc

VEYA

with cte as
(

select name,count(name) as x from #t1 group by name
)

select name from cte order by x desc

eylemde görmek

PHP, 63 62 61 karakter

function R($a){foreach($a as$v)$b[$v]++;arsort($b);return$b;}

Demo:

$c = array("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John");
$d = print_r(R($c));

Array ( [Doe] => 4 [Harry] => 3 [John] => 2 [Dick] => 1 )

Ruby: 59 karakter

f=->n{n.group_by{|i|i}.sort_by{|i|-i[1].size}.map{|i|i[0]}}

Örnek çalışma:

irb(main):001:0> f=->n{n.group_by{|i|i}.sort_by{|i|-i[1].size}.map{|i|i[0]}}
=> #<Proc:0x93b2e10@(irb):2 (lambda)>

irb(main):004:0> f[["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"]]
=> ["Doe", "Harry", "John", "Dick"]

Mathematica, 39 karakter

f = Reverse[First /@ SortBy[Tally@#, Last]] &

names = {"John", "Doe", "Dick", "Harry", "Harry",
         "Doe", "Doe", "Harry", "Doe", "John"};

f@names

{Doe, Harry, John, Dick}

JavaScript (ECMAScript5'i): 118 113 karakter

function f(n){m={}
for(i in n){m[n[i]]=m[n[i]]+1||1}
return Object.keys(m).sort(function(a,b){return m[b]-m[a]})}

http://jsfiddle.net/mblase75/crg5B/

Haskell - 53 Karakter

import Data.List
import Data.Ord

f :: (Eq a, Ord a) => [a] -> [a]
f=map head.(sortBy$flip$comparing length).group.sort

Açıklama: ilk iki satır gerekli ithalattır, bir sonraki kod satırı tip imzasıdır (genellikle gerekli değildir), gerçek işlev son satırdır. İşlev, listeyi doğal düzenine göre sıralar, eşit öğeleri listeler halinde gruplandırır, liste listesini boyutuna göre küçültür ve her listedeki ilk öğeyi alır.

ithalat dahil toplam uzunluk: 120

ithalatsız, ancak tip imzalı: 86

fonksiyonun kendisi: 53

Clojure: 43 karakter

İşlev:

#(keys(sort-by(comp - val)(frequencies %)))

Demo (yanıt olarak):

user=> (def names ["John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John"])
#'user/names
user=> (#(keys(sort-by(comp - val)(frequencies %))) names)
("Doe" "Harry" "John" "Dick")

Perl

verilen i / o spec karşılamak için 120 karakter gerekir

s!"([^"]+)"[],]!$a{$1}++!e while(<>);print 'MostOccuring = [',join(',',map{qq("$_")}sort{$a{$a}<=>$a{$b}}keys %a),"]\n"

satır başına bir öğe alarak ve satır başına bir öğe yazdırarak saf kısa kod Ben sadece 55 karakter gerekir

$a{$_}++ while(<>);print sort{$a{$a}<=>$a{$b}}keys %a)

C #: 111 karakter

List<string>M(List<string>l){return l.GroupBy(q=>q).OrderByDescending(g=>g.Count()).Select(g=>g.Key).ToList();}

(bir sınıfın içinde)

var names = new List<string> {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"};
foreach(var s in M(names))
{
    Console.WriteLine(s);
}

dişi geyik

Harry

John

çük

LINQ kullanarak basit bir çözüm.

R (22)

names(sort(-table(x)))

Bir işlev olarak 11 karakter daha alır.

Kullanımı:

> x = c("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")
> names(sort(-table(x)))
[1] "Doe"   "Harry" "John"  "Dick"

Scala (71)

(x.groupBy(a=>a)map(t=>(t._1,t._2.length))toList)sortBy(-_._2)map(_._1)

Ungolfed:

def f(x:Array[String]) =
  (x.groupBy(a => a) map (t => (t._1, t._2.length)) toList) 
    sortBy(-_._2) map(_._1)

J, 8 bayt

~.\:#/.~

kullanım

İsimler kutulu dizelerden oluşan bir dizi olarak saklanır.

   'John';'Doe';'Dick';'Harry';'Harry';'Doe';'Doe';'Harry';'Doe';'John'
┌────┬───┬────┬─────┬─────┬───┬───┬─────┬───┬────┐
│John│Doe│Dick│Harry│Harry│Doe│Doe│Harry│Doe│John│
└────┴───┴────┴─────┴─────┴───┴───┴─────┴───┴────┘
   f =: ~.\:#/.~
   f 'John';'Doe';'Dick';'Harry';'Harry';'Doe';'Doe';'Harry';'Doe';'John'
┌───┬─────┬────┬────┐
│Doe│Harry│John│Dick│
└───┴─────┴────┴────┘

açıklama

~.\:#/.~   Input: A
    #/.~   Finds the size of each set of identical items (Frequencies)
~.         List the distinct values in A
           Note: the distinct values and frequencies will be in the same order
  \:       Sort the distinct values in decreasing order according to the frequencies
           Return the sorted list implicitly

CJam, 15 bayt (muhtemelen rakipsiz)

q~$e`{0=W*}$1f=

Bu, bu sorun gönderildikten sonraki CJam özelliklerini kullanabilir. Kontrol etmek için çok tembelim.