Sort the distinct elements of a list in descending order by frequency

Question

Write a function which takes a list or array, and returns a list of the distinct elements, sorted in descending order by frequency.

Example:

Given:

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

Expected return value:

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

Answer 1

APL (14)

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

This is a function that takes a list, e.g.:

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

Explanation:

• ∘.≡⍨⍵: compare each element in the array to each other element in the array, giving a matrix
• +⌿: sum the columns of the matrix, giving how many times each element occurs
• ⍒: give indices of downward sort
• ⍵[...]: reorder ⍵ by the given indices
• ∪: get the unique elements

Answer 2

Python 3 - 47 43; Python 2 - 40 39

For Python 3:

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

For Python 2:

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

Demo:

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

Answer 3

Mathematica, 31

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

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

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

Answer 4

Mathematica (26 37)

With 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&]

Answer 5

Perl 6 (36 bytes, 35 characters)

» can be replaced with >>, if you cannot handle UTF-8. I'm almost sure this could be shorter, but the Bag class is relatively strange in its behavior (sadly), and isn't really complete, as it's relatively new (but it can count arguments). {} declares an anonymous function.

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

Sample output (from 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

Answer 6

Ruby: 34 37 characters

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

(edited: previous 30-char solution was the body of the function)

Answer 7

GolfScript, 14 chars (19 as named function, also 14 as full program)

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

This code takes an array on the stack and sorts its unique elements in descending order by number of occurrences. For example, if the input array is:

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

then the output array will be

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

Note: The code above is a bare sequence of statements. To turn it into a named function, wrap it in braces and assign it to a name, as in:

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

Alternatively, to turn the code into a full program that reads a list from standard input (using the list notation shown above) and prints it to standard output, prepend ~ and append ` to the code. The [. can be omitted in this case (since we know there will be nothing else on the stack), so that the resulting 14-character program will be:

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

---

How does it work?

• :a saves a copy of the original array in the variable a for later use.

• .| computes the set union of the array with itself, eliminating duplicates as a side effect.

• { }$ sorts the de-duplicated array using the custom sort keys computed by the code inside the braces. This code takes each array element, uses array subtraction to remove it from the original input array saved in a, and counts the number of remaining elements. Thus, the elements get sorted in decreasing order of frequency.

Ps. See here for the original 30-character version.

Answer 8

R: 23 characters

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

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

But it uses the not so nice shortcut of T to TRUE...

Answer 9

K (ngn/k), 5 bytes

>#'=:

Try it online!

• =: group the input, building a dictionary mapping unique values to the indices in which they appear
• #' take the count of each set of indices
• > sort the keys of the dictionary by their values, descending

Answer 10

if this could fit here : 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

OR

with cte as
(

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

select name from cte order by x desc

see it in action

Answer 11

PHP, 63 62 61 chars

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

Demo:

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

Answer 12

Ruby: 59 characters

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

Sample run:

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

Answer 13

Mathematica, 39 characters

f = Reverse[First /@ SortBy[Tally@#, Last]] &

names = {"John", "Doe", "Dick", "Harry", "Harry",
         "Doe", "Doe", "Harry", "Doe", "John"};

f@names

{Doe, Harry, John, Dick}

Answer 14

JavaScript (ECMAScript5): 118 113 characters

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/

Answer 15

C#: 111 characters

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

(inside a class)

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

Harry

John

Dick

A simple solution using LINQ.

Answer 16

Haskell - 53 Characters

import Data.List
import Data.Ord

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

Explanation: the first two lines are necessary imports, the next line of code is the type signature (generally not necessary), the actual function is the last line. The function sorts the list by its natural ordering, groups equal elements into lists, sorts the list of lists by descending size, and takes the first element in each list.

total length including imports: 120

w/o imports but with type signature: 86

function itself: 53

Answer 17

Clojure: 43 characters

Function:

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

Demo (in 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")

Answer 18

J, 8 bytes

~.\:#/.~

Usage

The names are stored as an array of boxed strings.

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

Explanation

~.\:#/.~   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

Answer 19

05AB1E, 5 bytes

ÙΣ¢}R

Try it online.

Explanation:

Ù    # Uniquify the (implicit) input-list
 Σ   # Sort this uniquified list by:
  ¢  #  Get its count in the (implicit) input-list
 }R  # After the ascending sort: reverse the list, so it'll become descending
     # (after which the result is output implicitly)

Answer 20

Stax, 7 bytes

èó±☻₧╛╗

Run and debug it

Answer 21

Jelly, 6 bytes

Qċ@ÞṚ⁺

Try it online!

There are quite a few ways to formulate this, but I find this to be the most amusing of several 6-byte alternatives. ċ@Þ@QṚ comes rather close.

Q         Unique items of the input.
   Þ      Sort them by
 ċ@       how many times they appear in the input
    Ṛ     reversed.
     ⁺    Duplicate the last link: reverse the sorted result.

Answer 22

CJam, 15 bytes

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

This may use CJam features from after this challenge was posted. I'm too lazy to check.

Answer 23

Husk, 5 bytes

u↔Ö#¹

Try it online!

Answer 24

Factor, 33 bytes

[ sorted-histogram keys reverse ]

Try it online!

Explanation

                 ! { "John" "Doe" "Dick" "Harry" "Harry" "Doe" "Doe" "Harry" "Doe" "John" }
sorted-histogram ! { { "Dick" 1 } { "John" 2 } { "Harry" 3 } { "Doe" 4 } }
keys             ! { "Dick" "John" "Harry" "Doe" }
reverse          ! { "Doe" "Harry" "John" "Dick" }

Answer 25

Perl

to meet given i/o spec I need 120 chars

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

pure shortest code by taking one item per line and printing one item per line I only need 55 chars

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

Answer 26

Scala (71)

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

Ungolfed:

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

Answer 27

Perl 5, 51 bytes

sub f{my%k;$k{$_}++for@_;sort{$k{$b}-$k{$a}}keys%k}

Try it online!