编写一个函数，该函数接受一个列表或数组，并返回一个不同元素的列表，这些元素按频率降序排列。

例：

鉴于：

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

说明：

• ∘.≡⍨⍵：将数组中的每个元素与数组中的每个其他元素进行比较，得到一个矩阵
• +⌿：对矩阵的列求和，给出每个元素出现多少次
• ⍒：给出向下排序的索引
• ⍵[... ]：⍵按给定索引重新排序
• ∪：获取独特元素

Python 3-47 43; Python 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']

Mathematica，31岁

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

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

（带n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"}）

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

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

Mathematica，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/

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

演示（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")

佩尔

要满足给定的I / O规格，我需要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);
}

母鹿

哈里

约翰

迪克

使用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功能。我懒得检查。