Viết hàm lấy danh sách hoặc mảng và trả về danh sách các phần tử riêng biệt, được sắp xếp theo thứ tự giảm dần theo tần số.

Thí dụ:

Được:

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

Giá trị lợi nhuận dự kiến:

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

APL (14)

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

Đây là một chức năng có một danh sách, ví dụ:

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

Giải trình:

• ∘.≡⍨⍵: so sánh từng phần tử trong mảng với từng phần tử khác trong mảng, đưa ra một ma trận
• +⌿: tính tổng các cột của ma trận, đưa ra số lần mỗi phần tử xảy ra
• ⍒: đưa ra các chỉ số sắp xếp đi xuống
• ⍵[... ]: Sắp xếp lại ⍵theo các chỉ số đã cho
• ∪: có được các yếu tố độc đáo

Trăn 3 - 47 43; Con trăn 2 - 40 39

Đối với Python 3:

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

Đối với Python 2:

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

Bản giới thiệu:

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

Toán học, 31

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

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

(Với n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"})

Toán học (26 37)

Với n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"}:

Last/@Gather@n~SortBy~Length//Reverse

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

Toán học V10 + (26) :

Keys@Sort[Counts[n],#>#2&]

Perl 6 (36 byte, 35 ký tự)

»có thể được thay thế bằng >>, nếu bạn không thể xử lý UTF-8. Tôi gần như chắc chắn rằng điều này có thể ngắn hơn, nhưng Baglớp học tương đối lạ trong hành vi của nó (đáng buồn thay) và không thực sự hoàn chỉnh, vì nó tương đối mới (nhưng nó có thể đếm các đối số). {}tuyên bố một chức năng ẩn danh.

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

Đầu ra mẫu (từ 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

Hồng ngọc: 34 37 nhân vật

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

(đã chỉnh sửa: giải pháp 30-char trước đó là phần thân của hàm)

GolfScript, 14 ký tự (19 chức năng được đặt tên, cũng là 14 chương trình đầy đủ)

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

Mã này lấy một mảng trên ngăn xếp và sắp xếp các phần tử duy nhất của nó theo thứ tự giảm dần theo số lần xuất hiện. Ví dụ: nếu mảng đầu vào là:

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

sau đó mảng đầu ra sẽ là

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

Lưu ý: Đoạn mã trên là một chuỗi các câu lệnh trần. Để biến nó thành một hàm được đặt tên, bọc nó trong dấu ngoặc nhọn và gán nó cho một tên, như trong:

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

Ngoài ra, để biến mã thành một chương trình đầy đủ đọc danh sách từ đầu vào tiêu chuẩn (sử dụng ký hiệu danh sách được hiển thị ở trên) và in nó sang đầu ra tiêu chuẩn, thêm vào ~và nối thêm `mã. Có [. thể bỏ qua trong trường hợp này (vì chúng ta biết sẽ không có gì khác trên ngăn xếp), do đó chương trình 14 ký tự kết quả sẽ là:

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

Làm thế nào nó hoạt động?

• :alưu một bản sao của mảng ban đầu trong biến ađể sử dụng sau.

• .| tính toán kết hợp tập hợp của mảng với chính nó, loại bỏ các bản sao làm hiệu ứng phụ.

• { }$sắp xếp mảng không trùng lặp bằng các phím sắp xếp tùy chỉnh được tính theo mã bên trong dấu ngoặc nhọn. Mã này lấy từng phần tử mảng, sử dụng phép trừ mảng để loại bỏ nó khỏi mảng đầu vào ban đầu được lưu avà đếm số phần tử còn lại. Do đó, các phần tử được sắp xếp theo thứ tự tần số giảm dần.

Thi thiên Xem ở đây cho phiên bản 30 ký tự gốc.

R: 23 ký tự

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

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

Nhưng nó sử dụng các phím tắt không quá tốt đẹp của Tđể TRUE...

nếu điều này có thể phù hợp ở đây: 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

HOẶC LÀ

with cte as
(

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

select name from cte order by x desc

nhìn thấy nó trong hành động

PHP, 63 62 61 ký tự

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

Bản giới thiệu:

$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 ký tự

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

Chạy mẫu:

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

Toán học, 39 ký tự

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 ký tự

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 nhân vật

import Data.List
import Data.Ord

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

Giải thích: hai dòng đầu tiên là nhập khẩu cần thiết, dòng mã tiếp theo là chữ ký loại (thường không cần thiết), chức năng thực tế là dòng cuối cùng. Hàm sắp xếp danh sách theo thứ tự tự nhiên, nhóm các phần tử bằng nhau vào danh sách, sắp xếp danh sách danh sách theo kích thước giảm dần và lấy phần tử đầu tiên trong mỗi danh sách.

tổng chiều dài bao gồm nhập khẩu: 120

Không nhập khẩu nhưng có chữ ký loại: 86

chức năng chính nó: 53

Clojure: 43 ký tự

Chức năng:

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

Bản demo (thay thế):

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

Perl

để đáp ứng i / o spec tôi cần 120 ký tự

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

mã ngắn nhất thuần túy bằng cách lấy một mục trên mỗi dòng và in một mục trên mỗi dòng Tôi chỉ cần 55 ký tự

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

C #: 111 ký tự

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

(trong một lớp học)

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

Tinh ranh

Một giải pháp đơn giản sử dụng LINQ.

R (22)

names(sort(-table(x)))

Là một chức năng, nó sẽ mất thêm 11 ký tự.

Sử dụng:

> x = c("John","Doe","Dick","Harry","Harry","Doe","Doe","Harry","Doe","John")
> names(sort(-table(x)))
[1] "Doe"   "Harry" "John"  "Dick"

Scala (71)

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

Ung dung:

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

J, 8 byte

~.\:#/.~

Sử dụng

Các tên được lưu trữ dưới dạng một chuỗi các chuỗi được đóng hộp.

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

Giải trình

~.\:#/.~   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 byte (có thể không cạnh tranh)

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

Điều này có thể sử dụng các tính năng của CJam từ sau khi thử thách này được đăng. Tôi quá lười để kiểm tra.