[Question]
  [
Write a snippet to calculate the mode (most common number) of a list of positive integers.
For example, the mode of 
```
d = [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]
```
is `1`, because it occurs the maximum of 5 times.
You may assume that the list is stored in a variable such as `d` and has a unique mode.
e.g.: Python, 49
```
max(((i,d.count(i))for i in set(d)), key=lambda x:x[1])
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest solution in bytes wins.
  
[Answer]
## Python 2 - 18
```
max(d,key=d.count)
```
Since your python answer doesn't seem to print, I expect this is what you want.
Add 6 bytes for `print`  normally.
[Answer]
# Matlab/Octave, ~~7~~ 5 bytes
Unsurprisingly there's a built-in function for finding modes. As an anonymous function:
```
@mode
```
This returns the most commonly occuring element in the input vector with ties going to the smaller value.
Saved 2 bytes thanks to Dennis!
[Answer]
## [Pyth](https://github.com/isaacg1/pyth) - 6
```
eo/QNQ
```
[Try it online.](http://isaacg.scripts.mit.edu/pyth/index.py)
Expects input on stdin like `[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]`. Ties are resolved by last occurrence because Python performs stable sorts.
Sorts the list by count the value in the list, then prints the last number of the list.
`Q` could be replaced with `d` if you initialized `d` to contain the value before e.g. `=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)`
Python-esque pseudo-code:
```
Q=eval(input());print(sorted(Q,key=Q.count)[-1])
```
Full Explanation:
```
            : Q=eval(input()) (implicit)
e           : ... [-1]
 o   Q      : orderby(lambda N: ...,Q)
  /QN       : count(Q,N)
```
Pyth's `orderby` runs exactly like Python's `sorted` with `orderby`'s first argument being the `key` argument.
[Answer]
# Mathematica, 25 bytes
```
Last@SortBy[d,d~Count~#&]
```
or
```
#&@@SortBy[d,-d~Count~#&]
```
As in the challenge, this expects the list to be stored in `d`.
## or... 15 bytes
Of course, Mathematica wouldn't be Mathematica if it didn't have a built-in:
```
#&@@Commonest@d
```
`Commonest` returns a list of all most common elements (in case of a tie), and `#&@@` is a golfed `First@`.
[Answer]
# Ruby, 22 bytes
```
d.max_by{|i|d.count i}
```
Basically a port of my Mathematica answer, except Ruby has a direct `max_by` so I don't need to sort first.
[Answer]
# R, ~~33~~ 25 bytes
Thanks @Hugh for the help shortening:
```
names(sort(-table(d))[1])
```
---
The original:
```
v=table(d);names(v[which.max(v)])
```
This calculates the frequency of each element in the vector `d`, then returns the name of the column containing the largest value. The value returned is actually a character string containing the number. It didn't say anywhere that that wasn't okay, so...
Any suggestions to shorten this are welcome!
[Answer]
# CJam, ~~11~~ 10 bytes
```
A{A\-,}$0=
```
Assumes the array in a variable called `A`. This is basically sorting the array based on the occurrence of each number in the array and then picks the last element of the array.
Example usage
```
[1 2 3 4 4 2 6 6 6 6]:A;A{aA\/,}$W=
```
Output
```
6
```
1 byte saved thanks to Dennis!
[Try it online here](http://cjam.aditsu.net/)
[Answer]
# K5, 6 bytes
```
*>#:'=
```
The first (`*`) of the descending elements (`>`) of the count of each (`#:'`) of the group (`=`). Step by step:
```
  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
```
[try it in your browser](http://johnearnest.github.io/ok/index.html?run=%20*%3E%23%3A'%3D4%203%201%200%206%201%206%204%204%200%203%201%207%207%203%204%201%201%202%208)!
[Answer]
# Powershell 19
```
($d|group)[0].Count
```
(this asumes the array is already on `$d`)
[Answer]
# J - 12 char
Anonymous function. Sorts list from most to least common, taking first item.
```
(0{~.\:#/.~)
```
* `0{` First of
* `~.` Unique items
* `\:` Downsorted by
* `#/.~` Frequencies
[Try it for yourself.](http://tryj.tk/)
[Answer]
# JavaScript (ES6) 51
Just a single line expression using the preloaded variable d. Sort the array by frequency then get the first element.  
Nasty side effect, the original array is altered
```
d.sort((a,b)=>d.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]
```
As usual, using .map instead of .reduce because it's 1 char shorter overall. With .reduce it' almost a clean, non-golfed solution.
```
d.sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]
```
At last, a solution using a function, not changing the original array and without globals (62 bytes):
```
F=d=>[...d].sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]
```
**Test** In FireFox/FireBug console
```
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]
```
*Output* 1
The d array becomes:
```
[1, 1, 1, 1, 1, 4, 4, 4, 4, 3, 3, 3, 0, 6, 6, 0, 7, 7, 2, 8]
```
[Answer]
# [Perl 6](http://perl6.org), 21 bytes
```
.Bag.invert.max.value
```
### Example:
```
$_ = < 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…
```
If there is a tie it will print the larger of the ones that tied.
---
The `.Bag` method on a List or an Array creates a quantified hash that associates the total count of how many times a given value was seen with that value.
```
bag(4(4), 3(3), 1(5), 0(2), 6(2), 7(2), 2, 8)
```
The `.invert` method creates a List of the pairs in the bag with the key and the value swapped. ( The reason we call this is for the next method to do what we want )
```
4 => 4,  3 => 3,  5 => 1,  2 => 0,  2 => 6,  2 => 7,  1 => 2,  1 => 8
```
The `.max` method on a List of Pairs returns the biggest Pair comparing the keys first and in the case of a tie comparing the values.  
( This is because that is how `multi infix:<cmp>(Pair:D \a, Pair:D \b)` determines which is larger )
```
5 => 1
```
The `.value` method returns the value from the Pair. ( It would have been the key we were after if it wasn't for the `.invert` call earlier )
```
1
```
---
If you want to return all of the values that tied in the case of a tie:
```
say @list.Bag.classify(*.value).max.value».key
```
The `.classify` method returns a list of pairs where the keys are from calling the Whatever lambda `*.value` with each of the Pairs.
```
1 => [2 => 1, 8 => 1],
2 => [0 => 2, 6 => 2, 7 => 2],
3 => [3 => 3],
4 => [4 => 4],
5 => [1 => 5]
```
Then we call `.max` to get the largest Pair.
```
"5" => [1 => 5]
```
A call to `.value` gets us the original Pairs from the Bag ( just one in this case )
```
1 => 5
```
Then we use `>>.key` to call the `.key` method on every Pair in the list, so that we end up with a list of the values that were seen the most.
```
1
```
[Answer]
# Python - 32
```
max((x.count(i),i)for i in x)[1]
```
Don't see an 18 character solution anywhere in the future to be honest.
EDIT: I stand corrected, and impressed.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
```
.MJ
```
Explanation:
```
.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.
```
If you want to store the array in a variable instead of using input, just push the array to the stack at the start of the program.
[Try it online!](https://tio.run/nexus/05ab1e#@6/n6/X/f7SJjrGOoY6BjhmQNNMxAUIDsIg5EBoDeYZAaKRjEfs1L183OTE5IxUA "05AB1E – TIO Nexus")
[Answer]
# JavaScript, ES6, 71 bytes
A bit long, can be golfed a lot.
```
f=a=>(c=b=[],a.map(x=>b[x]?b[x]++:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())
```
This creates a function `f` which can be called like `f([1,1,1,2,1,2,3,4,1,5])` and will return `1`.
Try it on your latest Firefox's Console.
[Answer]
# Dyalog APL, 12 characters
[`d[⊃⍒+/∘.=⍨d]`](http://tryapl.org/?a=d%u21904%203%201%200%206%201%206%204%204%200%203%201%207%207%203%204%201%201%202%208%20%u22C4%20d%5B%u2283%u2352+/%u2218.%3D%u2368d%5D&run)
`∘.=⍨d` is the same as `d∘.=d`, reflexive outer product of `=`. It creates a boolean matrix comparing every pair of elements in `d`.
`+/` sums that matrix along one of the axes and produces a vector.
`⍒` grades the vector, i.e. sorts it by indices. (As the glyphs suggest, `⍒` grades in descending order and `⍋` would grade in ascending order.)
`⊃` takes the first index from the grading—the index of the largest element of `d`.
`d[...]` returns that element.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
Æṃ
```
[Try it online!](https://tio.run/##y0rNyan8//9w28Odzf8PtyscnfRw54z//6NNdIx1DHUMdMyApJmOCRAagEXMgdAYyDMEQiMdi1gA "Jelly – Try It Online")
Jelly finally got a mode builtin! A non-builtin version however is 5 bytes:
```
ċ@Þ`Ṫ
```
[Try it online!](https://tio.run/##y0rNyan8//9It8PheQkPd676f7hd4eikhztn/P8fbaJjrGOoY6BjBiTNdEyA0AAsYg6ExkCeIRAa6VjEAgA "Jelly – Try It Online")
## How they work
```
Æṃ - Main link. Takes a list d on the left
Æṃ - Return the mode of d
```
Well that was unimpressive. How about the 5 byte, non-builtin version?
```
ċ@Þ`Ṫ - Main link. Takes d on the left
   `  - Use d as both the left and right argument to:
  Þ   -   Sort d by:
ċ@    -     Count occurrences in d
    Ṫ - Take the last element (i.e. the element with a maximal count in d)
```
[Answer]
# C# - 49
Can't really compete using C# but oh well:
Assuming `d` is the array
`d.GroupBy(i=>i).OrderBy(a=>a.Count()).Last().Key;`
[Answer]
# bash - ~~29~~ 27 characters
```
sort|uniq -c|sort -nr|sed q
```
Using it:
```
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
```
i.e. "1" is the mode, and it appears five times.
[Answer]
# GolfScript, 10 bytes
```
a{a\-,}$0=
```
From [this answer](https://codegolf.stackexchange.com/questions/5264/tips-for-golfing-in-golfscript/25737#25737) I wrote to [Tips for golfing in GolfScript](https://codegolf.stackexchange.com/questions/5264/tips-for-golfing-in-golfscript). Expects the input in an array named `a`, returns result on stack. (To read input from an array on the stack, prepend `:` for 11 bytes; to read input from stdin (in the format `[1 2 1 3 7]`), also prepend `~` for 12 bytes.)
This code works by iterating over the input array, subtracting each element from the original array, and counting the number of elements left. This is then used as a key to sort the original array by, and the first element of the sorted array is returned.
[Online demo.](http://golfscript.apphb.com/?c=IyBUZXN0IGlucHV0IChpbiBhcnJheSBhKToKWzQgMyAxIDAgNiAxIDYgNCA0IDAgMyAxIDcgNyAzIDQgMSAxIDIgOF06YTsKCiMgQ29kZToKYXthXC0sfSQwPQ%3D%3D)
*Ps.* Thanks to Peter Taylor for [pointing out this challenge to me](http://chat.stackexchange.com/transcript/message/19178279#19178279).
[Answer]
# Java 8, 83 Bytes
```
d.stream().max((x,y)->Collections.frequency(d,x)-Collections.frequency(d,y)).get();
```
`d` must be a `Collection<Integer>`.
---
If `Collections` can be statically imported:  
**59 Bytes**
```
d.stream().max((x,y)->frequency(d,x)-frequency(d,y)).get();
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~42~~ 39 bytes
```
f s=snd$maximum[([1|y<-s,y==x],x)|x<-s]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02h2LY4L0UlN7EiM7c0N1oj2rCm0ka3WKfS1rYiVqdCs6YCyIv9n5uYmadgq1BQlJlXoqCikKYQbaJjpGOmYwokDXWMgbQZkGUMhEax/wE "Haskell – Try It Online")
*Edit: Thans to Zgarb for -3 bytes*
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
ṢŒrṪÞṪṪ
```
[Try it online!](https://tio.run/nexus/jelly#@/9w56Kjk4oe7lx1eB6QAKL///9Hm@gY6xjqGOiYAUkzHRMgNACLmAOhMZBnCIRGOhaxAA "Jelly – TIO Nexus")
Longer than K :(
Assumes the first argument has the array. There are no variables in Jelly.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 45 bytes
```
x=>x.map(a=t=>a[t]=0+a[t]||[1+t]).sort()[0]-1
```
[Try it online!](https://tio.run/##HcjBCoMwEATQ30lwDUkVWyjr0Z8IOSxWSot1xSziwX9Pt@XBDDNv2imP22uVeuHHVAYsB/aH@9BqCAV7ipLQV786zxgqSdZl3sTY6FMdyn3kJfM8uZmfZjCxhQYCeOg0O2iV/z9X1egK6gK3ZG35Ag "JavaScript (Node.js) – Try It Online")
[42](https://tio.run/##FYhBCoMwEEWvk@AYkiq2IuPSS4QsBiulRR0xobjw7nHkwX@8/6M/xXH/bqlc@T3lAfOBfXGYhTZFmLAnnwLa4tZ5ymgTeU9KextyN/IaeZ7MzB81KF9DBQ5aC42ogVqQuL@nUEk64QGvoHW@AA) without 0 support
[Answer]
## Java 8 : 184 bytes
```
Stream.of(A).collect(Collectors.groupingBy(i -> i, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).findFirst().get().getKey();
```
Input **A** must be of type `Integer[]`. Note `java.util.*` and `java.util.stream.*` need to be imported, however in the spirit oneliner they are left out.
[Answer]
# Bash + unix tools, 62 bytes
Expects the array in the STDIN. The input format does not count, as long as the numbers are non-negative integers.
```
grep -o [0-9]\*|sort|uniq -c|sort -n|awk 'END{print $2}'
```
Edited: escaped wildcard in grep argument. Now it can be run safely in non-empty directories. Thanks to manatwork.
[Answer]
# Perl, 27 bytes
```
$Q[$a{$_}++]=$_ for@F;pop@Q
```
Returns the last most common value in case of a tie.
[Answer]
# jq, 29 characters
```
group_by(.)|max_by(length)[0]
```
Sample run:
```
bash-4.3$ jq 'group_by(.)|max_by(length)[0]' <<< '[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]'
1
```
[On-line test](https://jqplay.org/jq?q=group_by(.)|max_by(length)[0]&j=[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8])
[Answer]
# PHP, ~~53~~ 50 bytes
```
<?=array_flip($c=array_count_values($d))[max($c)];
```
Run like this:
```
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
```
## Tweaks
* Saved 3 bytes by making use of the freedom to assume the input is assigned to a variable `d`
[Answer]
# Haskell 78
```
import Data.List
import Data.Ord
g=head.maximumBy(comparing length).group.sort
```
If the imports are ignored, it's **45**.
]