26
\$\begingroup\$

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 , so the shortest solution in bytes wins.

\$\endgroup\$

35 Answers 35

5
\$\begingroup\$

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!

\$\endgroup\$
29
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ perfect, think @globby needs to see future :) \$\endgroup\$ – garg10may Dec 19 '14 at 16:25
  • 12
    \$\begingroup\$ The great thing about this one is that it's not even golfy, it's just Pythonic. The only thing that's been golfed is a space between d, and key=. \$\endgroup\$ – wchargin Dec 19 '14 at 17:28
  • 5
    \$\begingroup\$ @WChargin: Eh, Pythonic would be to avoid the quadratic runtime by using defaultdict(int) or Counter. Something like Counter(d).most_common()[0]. \$\endgroup\$ – user2357112 supports Monica Dec 21 '14 at 3:01
25
\$\begingroup\$

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!

\$\endgroup\$
  • 3
    \$\begingroup\$ +1, clearly the right tool for the job. As it's a builtin, what happens if there's more than one number of highest frequency? \$\endgroup\$ – Level River St Dec 20 '14 at 10:55
  • 2
    \$\begingroup\$ @steveverrill According to the documentation (type help mode): "If two, or more, values have the same frequency 'mode` returns the smallest." \$\endgroup\$ – wchargin Dec 21 '14 at 3:05
  • 1
    \$\begingroup\$ Unnamed functions seem to be allowed (the accepted answer is one), so you could shorten this to @mode. \$\endgroup\$ – Dennis Jun 2 '16 at 23:41
  • \$\begingroup\$ @Dennis Thanks! Though I admit it's a strange feeling to edit my first answer on the site. \$\endgroup\$ – Alex A. Jun 3 '16 at 5:18
16
\$\begingroup\$

Pyth - 6

eo/QNQ

Try it online.

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.

\$\endgroup\$
11
\$\begingroup\$

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@.

\$\endgroup\$
  • \$\begingroup\$ another case for mthmca \$\endgroup\$ – Michael Stern Apr 13 '16 at 19:26
9
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ I was about to suggest d.max_by d.method:count but that's about a million (aka not even two) bytes longer. Still, it's worth noting that it's possible. \$\endgroup\$ – Fund Monica's Lawsuit May 10 '16 at 18:39
9
\$\begingroup\$

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!

\$\endgroup\$
  • 2
    \$\begingroup\$ names(sort(-table(d))[1]) \$\endgroup\$ – Hugh Dec 20 '14 at 8:21
9
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ A{A\-,}$0= is one byte shorter. \$\endgroup\$ – Dennis Dec 31 '14 at 2:47
  • 1
    \$\begingroup\$ As of 0.6.5 it's doable in 8 bytes: Ae`$e_W= \$\endgroup\$ – Martin Ender Jun 3 '15 at 0:09
  • \$\begingroup\$ @MartinEnder Umm... nope. I knew you need to sort first. \$\endgroup\$ – Erik the Outgolfer Dec 12 '16 at 18:27
  • \$\begingroup\$ @ErikGolferエリックゴルファー whoops, you're right, needs 9 bytes: $e`$e_W= \$\endgroup\$ – Martin Ender Dec 12 '16 at 18:30
8
\$\begingroup\$

Powershell 19

($d|group)[0].Count

(this asumes the array is already on $d)

\$\endgroup\$
8
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ This is really 10 bytes--the function can be assigned without the parens. \$\endgroup\$ – Conor O'Brien May 12 '16 at 21:20
6
\$\begingroup\$

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]
\$\endgroup\$
5
\$\begingroup\$

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.

\$\endgroup\$
4
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Off-topic, but I just realized how relevant your username is to PCG.SE. :P \$\endgroup\$ – nyuszika7h Dec 20 '14 at 11:16
  • \$\begingroup\$ @nyuszika7h heh. Although I have had this username long before I even know PPCG existed. \$\endgroup\$ – Optimizer Dec 20 '14 at 11:20
  • \$\begingroup\$ f=a=>(c=b=[],a.map(x=>b[x]++-1?0:b[x]=1),b.map((x,i)=>c[x]=i),c.pop()) is 1 byte shorter. \$\endgroup\$ – Bálint May 11 '16 at 5:59
4
\$\begingroup\$

05AB1E, 3 bytes

(non-competing - question predates the language)

.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!

\$\endgroup\$
3
\$\begingroup\$

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;

\$\endgroup\$
3
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ sort|uniq -c|sort -nr|sed q saves a couple of characters \$\endgroup\$ – Digital Trauma Dec 19 '14 at 20:06
  • \$\begingroup\$ I posted the same answer, but you were faster :) \$\endgroup\$ – pgy Dec 19 '14 at 20:10
  • \$\begingroup\$ @pgy - thank you - have updated! \$\endgroup\$ – user15259 Dec 19 '14 at 20:25
3
\$\begingroup\$

GolfScript, 10 bytes

a{a\-,}$0=

From this answer I wrote to 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.

Ps. Thanks to Peter Taylor for pointing out this challenge to me.

\$\endgroup\$
3
\$\begingroup\$

Dyalog APL, 12 characters

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

∘.=⍨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.

\$\endgroup\$
  • \$\begingroup\$ +/∘.=⍨d counts for each element of d. ⊢∘≢⌸d counts for each element of ∪d, so the indices don't correspond to those of d. Counterexample: d←1 1 2 2 2. To make it work: (∪d)[⊃⍒⊢∘≢⌸d] or (⊃⍒⊢∘≢⌸d)⊃∪d. \$\endgroup\$ – ngn Dec 31 '14 at 3:15
3
\$\begingroup\$

Perl 6, 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
\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ downvoting because of ... ? \$\endgroup\$ – PoweredByRice Jan 4 '15 at 20:56
  • \$\begingroup\$ I know it's been more than two years, but you can remove the spaces at (i->i,Collectors.counting()). \$\endgroup\$ – Kevin Cruijssen Feb 1 '17 at 12:18
2
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ Best if run in an empty directory. Otherwise [0-9]* may get expanded to matching file names. \$\endgroup\$ – manatwork Nov 29 '15 at 13:26
  • \$\begingroup\$ Alternatively, put ' around the argument to grep. \$\endgroup\$ – Paŭlo Ebermann Nov 29 '15 at 19:41
2
\$\begingroup\$

Perl, 27 bytes

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

Returns the last most common value in case of a tie.

\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

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();
\$\endgroup\$
2
\$\begingroup\$

Haskell 78

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

If the imports are ignored, it's 45.

\$\endgroup\$
  • 1
    \$\begingroup\$ You can save 4 bytes by using point-free style and 2 bytes by using maximumBy instead of last.sortBy. The new code would become g=head.maximumBy(comparing length).group.sort. \$\endgroup\$ – Hjulle Nov 28 '17 at 15:54
  • \$\begingroup\$ 1.) Anonymous functions are allowed, so you can drop the g=. 2.) You can replace maximumBy(comparing length) by snd.maximum.map((,)=<<length) which doesn't need to import Ord, for a total of 62 bytes: Try it online! \$\endgroup\$ – Laikoni Nov 29 '17 at 11:08
2
\$\begingroup\$

Haskell, 42 39 bytes

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

Try it online!

Edit: Thans to Zgarb for -3 bytes

\$\endgroup\$
  • 1
    \$\begingroup\$ I think sum is unnecessary here. \$\endgroup\$ – Zgarb Nov 29 '17 at 11:44
  • \$\begingroup\$ @Zgarb Right, I actually used exactly the same trick in a previous answer. Thanks for reminding me! \$\endgroup\$ – Laikoni Nov 29 '17 at 15:03
2
\$\begingroup\$

Brachylog, 5 bytes

ọtᵒth

Try it online!

This isn't really a snippet, but I'm not sure what would be...

         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).
\$\endgroup\$
  • \$\begingroup\$ It fails for negative input \$\endgroup\$ – garg10may Jun 13 at 3:43
  • \$\begingroup\$ @garg10may Use an underscore instead of a hyphen, it should work that way \$\endgroup\$ – Unrelated String Jun 13 at 4:52
2
\$\begingroup\$

Clojure, 32 bytes

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

(frequencies %) returns a hash-map, which can be used as a function. Given a key it returns the corresponding value :)

Equal length:

#(last(sort-by(frequencies %)%))
\$\endgroup\$
1
\$\begingroup\$

Scala, 32

d.groupBy(a=>a).maxBy(_._2.size)
\$\endgroup\$
1
\$\begingroup\$

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;

Full code and test:

#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;
}
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.