Napisz funkcję, która pobiera listę lub tablicę i zwraca listę różnych elementów, posortowanych w porządku malejącym według częstotliwości.

Przykład:

Dany:

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

Oczekiwana wartość zwrotu:

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

APL (14)

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

Jest to funkcja, która pobiera listę, np .:

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

Wyjaśnienie:

• ∘.≡⍨⍵: porównaj każdy element w tablicy z innymi elementami w tablicy, dając macierz
• +⌿: zsumuj kolumny macierzy, podając ile razy występuje każdy element
• ⍒: podaj wskaźniki w dół
• ⍵[... ]: zmiana kolejności ⍵według podanych wskaźników
• ∪: zdobądź unikalne elementy

Python 3-47 43; Python 2 - 40 39

W przypadku Python 3:

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

W przypadku Python 2:

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

Próbny:

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

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

Mathematica (26 37)

Z 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 bajtów, 35 znaków)

»można zastąpić >>, jeśli nie możesz obsługiwać UTF-8. Jestem prawie pewien, że może to być krótsze, ale Bagklasa zachowuje się dość dziwnie (niestety) i nie jest tak naprawdę ukończona, ponieważ jest stosunkowo nowa (ale może liczyć argumenty). {}deklaruje anonimową funkcję.

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

Przykładowe dane wyjściowe (z Perl 6 REPL):

> 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

Rubin: 34 37 postacie

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

(edytowane: poprzednie 30-znakowe rozwiązanie było ciałem funkcji)

GolfScript, 14 znaków (19 jako nazwana funkcja, również 14 jako pełny program)

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

Ten kod pobiera tablicę na stos i sortuje unikalne elementy w porządku malejącym według liczby wystąpień. Na przykład, jeśli tablica wejściowa to:

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

wtedy tablica wyjściowa będzie

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

Uwaga: powyższy kod jest czystą sekwencją instrukcji. Aby przekształcić go w funkcję o nazwie, zawiń ją w nawiasy klamrowe i przypisz do nazwy, jak w:

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

Alternatywnie, aby przekształcić kod w pełny program, który odczytuje listę ze standardowego wejścia (używając notacji listy pokazanej powyżej) i drukuje ją na standardowe wyjście, ~dołącza i dołącza `do kodu. W [. tym przypadku można pominąć (ponieważ wiemy, że na stosie nie będzie nic więcej), więc wynikowy program składający się z 14 znaków będzie:

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

Jak to działa?

• :azapisuje kopię oryginalnej tablicy w zmiennej ado późniejszego wykorzystania.

• .| oblicza zestaw unii tablicy z samym sobą, eliminując duplikaty jako efekt uboczny.

• { }$sortuje zduplikowaną tablicę za pomocą niestandardowych kluczy sortowania obliczonych przez kod w nawiasach klamrowych. Ten kod pobiera każdy element tablicy, używa odejmowania tablicy, aby usunąć go z oryginalnej zapisanej tablicy wejściowej a, i zlicza liczbę pozostałych elementów. W ten sposób elementy są sortowane w malejącej kolejności częstotliwości.

Ps. Zobacz tutaj oryginalną 30-znakową wersję.

R: 23 znaki

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

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

Ale to nie używa tak piękny skrót Tdo TRUE...

jeśli to może pasować tutaj: 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

LUB

with cte as
(

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

select name from cte order by x desc

zobacz to w akcji

PHP, 63 62 61 znaków

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

Próbny:

$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 znaków

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

Przykładowy przebieg:

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 znaków

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): 118 113 znaków

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 znaków

import Data.List
import Data.Ord

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

Objaśnienie: pierwsze dwa wiersze to konieczne importowanie, następny wiersz kodu to podpis typu (generalnie nie jest to konieczne), faktyczna funkcja to ostatni wiersz. Funkcja sortuje listę według naturalnego porządku, grupuje równe elementy w listy, sortuje listę według malejącego rozmiaru i pobiera pierwszy element z każdej listy.

całkowita długość wraz z importem: 120

bez importu, ale z podpisem typu: 86

sama funkcja: 53

Clojure: 43 znaków

Funkcjonować:

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

Demo (w repl):

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

Aby spełnić specyfikację wejścia / wyjścia potrzebuję 120 znaków

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

czysty najkrótszy kod, biorąc jeden element w wierszu i drukując jeden element w wierszu Potrzebuję tylko 55 znaków

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

C #: 111 znaków

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

(wewnątrz klasy)

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

Łania

Złupić

Jan

Kutas

Proste rozwiązanie wykorzystujące LINQ.

R (22)

names(sort(-table(x)))

Jako funkcja zajęłaby 11 dodatkowych znaków.

Stosowanie:

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

Nie golfowany:

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

J, 8 bajtów

~.\:#/.~

Stosowanie

Nazwy są przechowywane jako tablica ciągów w ramkach.

   '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│
└───┴─────┴────┴────┘

Wyjaśnienie

~.\:#/.~   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 bajtów (być może niekonkurujących)

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

Może to korzystać z funkcji CJam po opublikowaniu tego wyzwania. Jestem zbyt leniwy, by to sprawdzić.