编写一个片段以计算正整数列表的众数（最常用的数字）。

例如，

d = [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]

是1，因为它最多出现5次。

您可以假定列表存储在诸如中的变量中，d并且具有唯一模式。

例如：Python，49岁

max(((i,d.count(i))for i in set(d)), key=lambda x:x[1])

这是代码高尔夫球，因此以字节为单位的最短解决方案为准。

K5，6个字节

*>#:'=

第一（*降元件（的）>的每一个的计数（的）#:'的组的）（ =）。一步步：

  i
4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8

  =i
4 3 1 0 6 7 2 8!(0 7 8 15
 1 10 14
 2 5 11 16 17
 3 9
 4 6
 12 13
 ,18
 ,19)

  #:'=i
4 3 1 0 6 7 2 8!4 3 5 2 2 2 1 1

  >#:'=i
1 4 3 7 6 0 8 2

  *>#:'=i
1

在浏览器中尝试一下！

Python 2-18

max(d,key=d.count)

由于您的python答案似乎无法打印，因此我希望这是您想要的。

print通常添加6个字节。

Matlab /八度，7 5字节

毫不奇怪，这里有一个内置的功能来寻找模式。作为匿名函数：

@mode

这将返回输入向量中最常出现的元素，并且联系变为更小的值。

感谢Dennis，节省了2个字节！

腐霉病 -6

eo/QNQ

在线尝试。

期望在stdin之类的输入[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]。由于Python执行稳定的排序，因此按最后一次出现解决关系。

通过计算列表中的值对列表进行排序，然后打印列表的最后一个数字。

Qd如果初始化d为包含例如之前的值，则可以替换为=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Python风格的伪代码：

Q=eval(input());print(sorted(Q,key=Q.count)[-1])

完整说明：

            : Q=eval(input()) (implicit)
e           : ... [-1]
 o   Q      : orderby(lambda N: ...,Q)
  /QN       : count(Q,N)

Pyth的orderby运行与Python 的运行完全相同sorted，orderby第一个参数是Python的key参数。

Mathematica，25个字节

Last@SortBy[d,d~Count~#&]

要么

#&@@SortBy[d,-d~Count~#&]

与挑战一样，这希望该列表存储在中d。

或... 15个字节

当然，如果Mathematica没有内置的，它将不会是Mathematica：

#&@@Commonest@d

Commonest返回所有最常见元素的列表（如果打成平局），并且#&@@是golfed First@。

Ruby，22个字节

d.max_by{|i|d.count i}

基本上是我的Mathematica答案的一部分，但Ruby有直接的答案，max_by因此我不需要先排序。

R，33 25字节

感谢@Hugh缩短帮助时间：

names(sort(-table(d))[1])

原本的：

v=table(d);names(v[which.max(v)])

这将计算向量中每个元素的频率d，然后返回包含最大值的列的名称。返回的值实际上是包含数字的字符串。它没有说那是不好的地方，所以...

欢迎提出任何缩短此建议的建议！

CJam，11个10字节

A{A\-,}$0=

假设该数组位于名为的变量中A。这基本上是根据数组中每个数字的出现对数组进行排序，然后选择数组的最后一个元素。

用法示例

[1 2 3 4 4 2 6 6 6 6]:A;A{aA\/,}$W=

输出量

6

感谢Dennis，节省了1个字节！

在这里在线尝试

Powershell 19

($d|group)[0].Count

（这假设该数组已经存在$d）。

J-12个字符

匿名函数。从最常见到最不常见，以第一项排序。

(0{~.\:#/.~)

• 0{ 首先
• ~. 独特物品
• \: 降序排列
• #/.~ 频率

自己尝试一下。

JavaScript（ES6）51

仅使用预加载变量d的单行表达式。按频率对数组进行排序，然后得到第一个元素。
令人讨厌的副作用，原始数组已更改

d.sort((a,b)=>d.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

像往常一样，使用.map代替.reduce，因为它总体上短了1个字符。使用.reduce几乎是一种干净的非解决方案。

d.sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

最后，使用函数的解决方案，不更改原始数组且不使用全局变量（62字节）：

F=d=>[...d].sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

在FireFox / FireBug控制台中测试

d=[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]
d.sort((a,b)=>x.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

输出 1

d数组变为：

[1, 1, 1, 1, 1, 4, 4, 4, 4, 3, 3, 3, 0, 6, 6, 0, 7, 7, 2, 8]

的Python-32

max((x.count(i),i)for i in x)[1]

老实说，将来不会在任何地方看到18个字符的解决方案。

编辑：我站纠正，并留下深刻的印象。

JavaScript，ES6、71字节

有点长，可以打很多球。

f=a=>(c=b=[],a.map(x=>b[x]?b[x]++:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())

这将创建一个f可以像调用f([1,1,1,2,1,2,3,4,1,5])并将返回的函数1。

在最新的Firefox控制台上尝试一下。

05AB1E，3个字节

（非竞争性-问题先于语言）

.MJ

说明：

.M  # Gets the most frequent element in the [implicit] input
  J # Converts to a string, needed as the program would output "[1]" instead of "1" without this.

如果要将数组存储在变量中而不是使用输入，只需在程序开始时将数组压入堆栈即可。

在线尝试！

C＃-49

不能真正使用C＃进行竞争，但是很好：

假设d是数组

d.GroupBy(i=>i).OrderBy(a=>a.Count()).Last().Key;

bash- 29 27个字符

sort|uniq -c|sort -nr|sed q

使用它：

sort|uniq -c|sort -nr|sed q
4
3
1
0
6
1
6
4
4
0
3
1
7
7
3
4
1
1
2
8
[ctrl-D]
5 1

即“ 1”是模式，它出现五次。

GolfScript，10个字节

a{a\-,}$0=

从这个答案中，我写了《在GolfScript中打高尔夫球的技巧》。期望输入名为的数组中的a结果，并在堆栈上返回结果。（要从堆栈上的数组读取输入，请前置:11个字节；要从stdin读取输入（格式为[1 2 1 3 7]），也请前置~12个字节。）

该代码通过遍历输入数组，从原始数组减去每个元素并计算剩余元素的数量来工作。然后将其用作对原始数组进行排序的键，并返回已排序数组的第一个元素。

在线演示。

附言 感谢Peter Taylor 向我指出了这一挑战。

Dyalog APL，12个字符

d[⊃⍒+/∘.=⍨d]

∘.=⍨d与...的d∘.=d反身外部产物相同=。它创建一个布尔矩阵，比较中的每对元素d。

+/ 沿轴之一将矩阵求和并产生一个向量。

⍒对向量进行分级，即按索引对其进行排序。（如字形所建议的那样，⍒按降序排列，然后⍋按升序排列。）

⊃从等级中获取第一个索引-的最大元素的索引d。

d[...] 返回该元素。

Perl 6，21个字节

.Bag.invert.max.value

例：

$_ = < 4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8 >».Int;

say .Bag.invert.max.value; # implicitly calls $_.Bag…

如果有平局，它将打印较大的平局。

.Bag列表或数组上的方法创建一个量化的哈希值，该哈希值将给定值被看到多少次的总计数与该值相关联。

bag(4(4), 3(3), 1(5), 0(2), 6(2), 7(2), 2, 8)

该.invert方法在包中创建了一个键对和交换值对的列表。（之所以这样称呼，是因为下一个方法可以执行我们想要的操作）

4 => 4,  3 => 3,  5 => 1,  2 => 0,  2 => 6,  2 => 7,  1 => 2,  1 => 8

.max配对列表上的方法返回最大的配对，首先比较键，如果是平局则比较值。
（这是因为这是multi infix:<cmp>(Pair:D \a, Pair:D \b)确定较大的方法）

5 => 1

该.value方法从对返回值。（如果不是.invert早些时候打来的话，那将是我们追求的关键）

1

如果要返回所有出现平局的值：

say @list.Bag.classify(*.value).max.value».key

该.classify方法返回一个键对列表，键来自*.value每个键对调用任何lambda  。

1 => [2 => 1, 8 => 1],
2 => [0 => 2, 6 => 2, 7 => 2],
3 => [3 => 3],
4 => [4 => 4],
5 => [1 => 5]

然后，我们调用.max以获得最大的货币对。

"5" => [1 => 5]

打电话给.value我们从包中取出原始对（在这种情况下只有一个）

1 => 5

然后，我们使用>>.key来调用.key列表中每个对上的方法，以便最终得到最常看到的值的列表。

1

Java 8：184个字节

Stream.of(A).collect(Collectors.groupingBy(i -> i, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).findFirst().get().getKey();

输入A必须为类型Integer[]。请注意java.util.*，java.util.stream.*需要将其导入，但是在精神上，它们被忽略了。

Bash + Unix工具，62字节

期望在STDIN中使用该数组。只要数字是非负整数，输入格式就不会计数。

grep -o [0-9]\*|sort|uniq -c|sort -n|awk 'END{print $2}'

编辑：在grep参数中转义了通配符。现在，它可以在非空目录中安全运行。多亏了manatwork。

Perl，27个字节

$Q[$a{$_}++]=$_ for@F;pop@Q

如果出现平局，则返回最后一个最常见的值。

PHP，53 50字节

<?=array_flip($c=array_count_values($d))[max($c)];

像这样运行：

echo '<?php $d=$argv;?><?=array_flip($c=array_count_values($d))[max($c)]; echo"\n";' | php -- 4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8

调整

• 通过假设输入被分配给变量来节省3个字节 d

Java 8，83字节

d.stream().max((x,y)->Collections.frequency(d,x)-Collections.frequency(d,y)).get();

d必须是一个Collection<Integer>。

如果Collections可以静态导入：
59字节

d.stream().max((x,y)->frequency(d,x)-frequency(d,y)).get();

哈斯克尔78

import Data.List
import Data.Ord
g=head.maximumBy(comparing length).group.sort

如果忽略导入，则为45。

Haskell，42 39字节

f s=snd$maximum[([1|y<-s,y==x],x)|x<-s]

在线尝试！

编辑：赞到Zgarb为-3个字节

Brachylog，5个字节

ọtᵒth

在线尝试！

这实际上不是一个片段，但是我不确定会是什么。

         The output is
    h    the first element of
   t     the last element of
ọ        a list of [value, number of occurrences] pairs corresponding to
         the input,
  ᵒ      sorted ascending by
 t       their last elements (the numbers of occurrences).

Clojure，32个字节

#(apply max-key(frequencies %)%)

(frequencies %)返回一个哈希映射，可以用作函数。给定一个键，它将返回相应的值:)

等长：

#(last(sort-by(frequencies %)%))

斯卡拉（Scala），32岁

d.groupBy(a=>a).maxBy(_._2.size)

C ++ 119

int *a=std::max_element(x,x+n);int z=0,b=0,c=0;for(int i=0;i<=*a;i++){c=std::count(x,x+n,i);if(c>b){b=c;z=i;}}return z;

完整的代码和测试：

#include <iostream>
#include <algorithm>
#include <vector>

int m(int *x,int n)
{
int *a=std::max_element(x,x+n);int z=0,b=0,c=0;for(int i=0;i<=*a;i++){c=std::count(x,x+n,i);if(c>b){b=c;z=i;}}return z;
}

int main()
{
int d[] = {4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8};
std::cout<<m(d,20);
return 0;
}