Напишіть функцію, яка приймає список або масив, і повертає список різних елементів, відсортованих у порядку зменшення за частотою.

Приклад:

Подано:

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

Очікувана повернена вартість:

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

APL (14)

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

Це функція, яка бере список, наприклад:

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

Пояснення:

• ∘.≡⍨⍵: порівняйте кожен елемент в масиві один з одним в масиві, даючи матрицю
• +⌿: підсумовуйте стовпці матриці, даючи, скільки разів виникає кожен елемент
• ⍒: дайте показники сортування вниз
• ⍵[... ]: упорядкувати ⍵за поданими показниками
• ∪: отримати унікальні елементи

Пітон 3 - 47 43; Пітон 2 - 40 39

Для Python 3:

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

Для Python 2:

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

Демонстрація:

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

Математика, 31

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

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

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

Математика (26 37)

З 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 байт, 35 символів)

»можна замінити >>, якщо ви не можете впоратися з UTF-8. Я майже впевнений, що це може бути коротшим, але Bagклас відносно дивний у своїй поведінці (на жаль), і насправді не повний, оскільки він відносно новий (але він може рахувати аргументи). {}оголошує анонімну функцію.

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

Вибірка зразка (від 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

Рубін: 34 37 символів

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

(відредаговано: попереднє 30-ти канальне рішення було частиною функції)

GolfScript, 14 символів (19 як названа функція, також 14 як повна програма)

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

Цей код бере масив на стеку і сортує його унікальні елементи у порядку зменшення за кількістю входів. Наприклад, якщо вхідний масив:

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

тоді вихідний масив буде

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

Примітка: Код, наведений вище, є голою послідовністю тверджень. Щоб перетворити його в іменовану функцію, оберніть її в дужки та призначте ім'я, як у:

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

Альтернативно, щоб перетворити код у повну програму, яка читає список зі стандартного введення (використовуючи позначення списку, показані вище) та роздруковує його до стандартного виводу, ~додає та додає `до коду. У [. цьому випадку можна пропустити (оскільки ми знаємо, що на стеку нічого більше не буде), так що отримана програма з 14 символів буде:

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

Як це працює?

• :aзберігає копію вихідного масиву у змінній aдля подальшого використання.

• .| обчислює встановлене об'єднання масиву з собою, виключаючи дублікати як побічний ефект.

• { }$сортує дебюльований масив за допомогою спеціальних клавіш сортування, обчислених кодом всередині дужок. Цей код приймає кожен елемент масиву, використовує віднімання масиву для видалення його з вихідного масиву вводу, збереженого в ньому a, і підраховує кількість решти елементів. Таким чином, елементи сортуються у порядку зменшення частоти.

Пс. Дивіться тут оригінальну версію з 30 символами.

R: 23 символи

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

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

Але він використовує не дуже приємний ярлик Tдля TRUE...

якщо це могло б поміститися тут: 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

АБО

with cte as
(

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

select name from cte order by x desc

бачити це в дії

PHP, 63 62 61 чол

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

Демонстрація:

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

Рубін: 59 символів

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

Проба зразка:

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

Математика, 39 символів

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 символів

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/

Хаскелл - 53 персонажа

import Data.List
import Data.Ord

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

Пояснення: перші два рядки необхідні для імпорту, наступний рядок коду - це підпис типу (як правило, не потрібно), фактична функція - останній рядок. Функція сортує список за його природним упорядкуванням, групує рівні елементи за списками, сортує список списків за розміром за розміром та приймає перший елемент у кожному списку.

загальна довжина, включаючи імпорт: 120

без імпорту, але з підписом типу: 86

сама функція: 53

Clojure: 43 символи

Функція:

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

Демо (у відповіді):

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

щоб зустріти дані вводу / виводу, мені потрібно 120 символів

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

чистий найкоротший код, беручи по одному елементу на рядок і друкуючи один елемент на рядок, мені потрібно лише 55 символів

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

C #: 111 символів

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

(всередині класу)

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

Doe

Гаррі

Джон

Дік

Просте рішення за допомогою LINQ.

R (22)

names(sort(-table(x)))

Як функція знадобиться ще 11 символів.

Використання:

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

Скала (71)

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

Безголівки:

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

J, 8 байт

~.\:#/.~

Використання

Імена зберігаються у вигляді масиву рядків у коробці.

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

Пояснення

~.\:#/.~   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 байт (можливо, не конкуруючий)

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

Це може використовувати функції CJam після опублікування цього виклику. Я лінивий перевірити.