เขียนฟังก์ชั่นที่รับรายการหรืออาเรย์แล้วส่งกลับรายการองค์ประกอบที่แตกต่างเรียงลำดับจากมากไปน้อยตามความถี่

ตัวอย่าง:

ได้รับ:

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

ค่าตอบแทนที่คาดหวัง:

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

APL (14)

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

นี่คือฟังก์ชั่นที่รับรายการเช่น:

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

คำอธิบาย:

• ∘.≡⍨⍵: เปรียบเทียบแต่ละองค์ประกอบในอาร์เรย์กับองค์ประกอบอื่น ๆ ในอาร์เรย์ให้เมทริกซ์
• +⌿: รวมคอลัมน์ของเมทริกซ์โดยให้แต่ละองค์ประกอบเกิดขึ้นกี่ครั้ง
• ⍒: ดัชนีให้เรียงลำดับลง
• ⍵[... ]: เรียงลำดับใหม่⍵ตามดัชนีที่ให้มา
• ∪: รับองค์ประกอบที่เป็นเอกลักษณ์

Python 3 - 47 43; Python 2 - 40 39

สำหรับ Python 3:

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

สำหรับ Python 2:

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

การสาธิต:

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

Mathematica, 31

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

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

(พร้อมn = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"})

Mathematica (26) 37)

ด้วย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&]

Perl 6 (36 ไบต์, 35 ตัวอักษร)

»สามารถถูกแทนที่ด้วย>>หากคุณไม่สามารถจัดการ UTF-8 ได้ ฉันเกือบจะแน่ใจว่าสิ่งนี้อาจสั้นกว่านี้ แต่Bagชั้นเรียนค่อนข้างแปลกในพฤติกรรมของมัน (น่าเศร้า) และยังไม่เสร็จสมบูรณ์เนื่องจากมันค่อนข้างใหม่ (แต่สามารถนับการโต้แย้งได้) {}ประกาศฟังก์ชั่นที่ไม่ระบุชื่อ

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

ตัวอย่างผลลัพธ์ (จาก 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

ทับทิม: 34 37 ตัวละคร

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

(แก้ไข: โซลูชัน 30 char ก่อนหน้านี้เป็นเนื้อความของฟังก์ชัน)

GolfScript, 14 ตัวอักษร (19 ชื่อฟังก์ชั่นชื่อ, ยัง 14 เป็นโปรแกรมเต็มรูปแบบ)

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

รหัสนี้ใช้อาร์เรย์บนสแต็กและเรียงลำดับองค์ประกอบที่เป็นเอกลักษณ์ตามลำดับจากมากไปน้อยตามจำนวนครั้งที่เกิดขึ้น ตัวอย่างเช่นถ้าอาร์เรย์อินพุทคือ:

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

จากนั้นอาร์เรย์เอาต์พุตจะเป็น

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

หมายเหตุ:รหัสข้างต้นเป็นชุดคำสั่งที่เปลือยเปล่า ในการเปลี่ยนเป็นฟังก์ชันที่มีชื่อให้ห่อด้วยเครื่องหมายปีกกาและกำหนดให้กับชื่อดังใน:

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

หรือเปลี่ยนรหัสเป็นโปรแกรมเต็มรูปแบบที่อ่านรายการจากอินพุตมาตรฐาน (โดยใช้สัญลักษณ์รายการที่แสดงด้านบน) และพิมพ์ลงในเอาต์พุตมาตรฐานเสริม~และผนวก`เข้ากับโค้ด [. สามารถละเว้นในกรณีนี้ (เพราะเรารู้ว่าจะมีอะไรอย่างอื่นในกอง) เพื่อให้เกิดโปรแกรม 14 ตัวอักษรจะเป็น:

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

มันทำงานยังไง?

• :aบันทึกสำเนาของอาร์เรย์ดั้งเดิมในตัวแปรaเพื่อใช้ในภายหลัง

• .| คำนวณชุดยูเนี่ยนของอาร์เรย์ด้วยตัวเองโดยกำจัดการซ้ำซ้อนเป็นผลข้างเคียง

• { }$เรียงลำดับอาร์เรย์ที่ซ้ำกันโดยใช้คีย์การเรียงลำดับแบบกำหนดเองที่คำนวณโดยรหัสภายในวงเล็บปีกกา รหัสนี้ใช้เวลาแต่ละองค์ประกอบอาร์เรย์ใช้การลบอาร์เรย์เพื่อลบออกจากอาร์เรย์อินพุตดั้งเดิมที่บันทึกไว้aและนับจำนวนองค์ประกอบที่เหลือ ดังนั้นองค์ประกอบจะเรียงลำดับตามความถี่ที่ลดลง

ps ดูที่นี่สำหรับเวอร์ชั่นเดิม 30 ตัวอักษร

R: 23 ตัวอักษร

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

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

แต่มันใช้ทางลัดที่ไม่ค่อยดีTสำหรับTRUE...

ถ้านี่เหมาะสมที่นี่: 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

หรือ

with cte as
(

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

select name from cte order by x desc

เห็นมันในการกระทำ

PHP, 63 62 61 ตัวอักษร

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

การสาธิต:

$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 ตัวอักษร

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

วิ่งตัวอย่าง:

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

Mathematica, 39 ตัวอักษร

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 ตัวอักษร

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 ตัวละคร

import Data.List
import Data.Ord

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

คำอธิบาย: สองบรรทัดแรกเป็นการนำเข้าที่จำเป็นบรรทัดถัดไปของรหัสคือลายเซ็นประเภท (โดยทั่วไปไม่จำเป็น) ฟังก์ชั่นที่เกิดขึ้นจริงเป็นบรรทัดสุดท้าย ฟังก์ชั่นเรียงลำดับรายการตามลำดับโดยธรรมชาติจัดกลุ่มองค์ประกอบที่เท่ากันลงในรายการเรียงลำดับรายการตามขนาดจากมากไปน้อยและใช้องค์ประกอบแรกในแต่ละรายการ

ความยาวรวมรวมถึงการนำเข้า: 120

ไม่มีการนำเข้า แต่มีลายเซ็นประเภท: 86

ฟังก์ชั่นตัวเอง: 53

Clojure: 43 ตัวอักษร

ฟังก์ชั่น:

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

การสาธิต (ในแบบจำลอง):

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

เพื่อให้ตรงตามข้อกำหนด i / o ที่กำหนดฉันต้องการ 120 ตัวอักษร

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

รหัสที่สั้นที่สุดบริสุทธิ์โดยการหนึ่งรายการต่อบรรทัดและพิมพ์หนึ่งรายการต่อบรรทัดฉันต้องการเพียง 55 ตัวอักษร

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

C #: 111 ตัวอักษร

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

(ในชั้นเรียน)

var names = new List<string> {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"};
foreach(var s in M(names))
{
    Console.WriteLine(s);
}

กวางตัวเมีย

ก่อกวน

จอห์น

กระเจี๊ยว

วิธีง่ายๆในการใช้ LINQ

R (22)

names(sort(-table(x)))

ในฐานะที่เป็นฟังก์ชั่นมันจะใช้เวลาอีก 11 ตัวอักษร

การใช้งาน:

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

สกาล่า (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)

J, 8 ไบต์

~.\:#/.~

การใช้

ชื่อจะถูกเก็บไว้เป็นอาร์เรย์ของสตริงที่บรรจุอยู่ในกล่อง

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

คำอธิบาย

~.\:#/.~   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 ไบต์ (อาจไม่ใช่แบบแข่งขัน)

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

นี่อาจใช้คุณสมบัติ CJam จากหลังจากโพสต์ความท้าทายนี้ ฉันขี้เกียจเกินไปที่จะตรวจสอบ