목록 또는 배열을 가져와 고유 한 요소의 목록을 빈도별로 내림차순으로 정렬하는 함수를 작성하십시오.

예:

주어진:

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

설명:

• ∘.≡⍨⍵: 배열의 각 요소를 배열의 다른 요소와 비교하여 행렬을 제공합니다.
• +⌿: 행렬의 열을 합하여 각 요소가 몇 번 발생하는지 나타냅니다.
• ⍒: 하향 정렬 지수 제공
• ⍵[... ]: ⍵주어진 지수로 재정렬
• ∪: 독특한 요소를 얻을

파이썬 3-47 43; 파이썬 2 - (40) (39)

파이썬 3의 경우 :

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

파이썬 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']

매스 매 티카, 31

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

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

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

매스 매 티카 (26 37)

로 n = {"John", "Doe", "Dick", "Harry", "Harry", "Doe", "Doe", "Harry", "Doe", "John"}:

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

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

매스 매 티카 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 문자 솔루션은 함수의 본문이었습니다)

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\-,}$`

어떻게 작동합니까?

• :aa나중에 사용할 수 있도록 원래 배열의 사본을 변수 에 저장합니다 .

• .| 배열 자체의 합집합을 계산하여 부작용으로 중복을 제거합니다.

• { }$중괄호 안의 코드로 계산 된 사용자 지정 정렬 키를 사용하여 중복 제거 된 배열을 정렬합니다. 이 코드는 각 배열 요소를 가져 와서 배열 빼기를 사용하여에 저장된 원래 입력 배열에서 제거하고 a남은 요소 수를 계산합니다. 따라서 요소는 주파수의 내림차순으로 정렬됩니다.

추신. 원래 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 )

루비 : 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) : 118113 자

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/

하스켈-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

클로저 : 43 자

함수:

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

데모 (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")

펄

주어진 I / O 사양을 충족시키기 위해서는 120자가 필요합니다.

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

한 줄에 하나의 항목을 가져 와서 한 줄에 하나의 항목을 인쇄하여 가장 짧은 코드

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

언 골프 드 :

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 기능을 사용할 수 있습니다. 확인하기에는 너무 게으르다.