양의 정수 목록의 모드 (가장 일반적인 숫자)를 계산하는 스 니펫을 작성하십시오.

예를 들어

d = [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]

이다 1는 5 배의 최대 발생하기 때문.

목록이 d고유 모드와 같은 변수에 저장되어 있다고 가정 할 수 있습니다 .

예 : Python, 49

max(((i,d.count(i))for i in set(d)), key=lambda x:x[1])

이것은 code-golf 이므로 바이트 단위의 최단 솔루션이 이깁니다.

K5, 6 바이트

*>#:'=

그룹 ( ) 의 각 ( ) 개수의 *내림차순 요소 ( >)의 첫 번째 ( )입니다 . 단계별 :#:'=

  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

브라우저에서 사용해보십시오 !

파이썬 2-18

max(d,key=d.count)

파이썬 답변이 인쇄되지 않는 것 같아서 이것이 당신이 원하는 것으로 기대합니다.

print일반적으로 6 바이트를 추가하십시오 .

Matlab / Octave, 7 5 바이트

당연히 모드를 찾기위한 내장 기능이 있습니다. 익명 함수로 :

@mode

입력 벡터에서 가장 흔하게 발생하는 요소를 더 작은 값으로 반환합니다.

Dennis 덕분에 2 바이트를 절약했습니다!

피스 -6

eo/QNQ

온라인으로 사용해보십시오.

stdin과 같은 입력을 예상합니다 [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. 파이썬은 안정적인 정렬을 수행하기 때문에 마지막 발생으로 해결됩니다.

목록의 값을 기준으로 목록을 정렬 한 다음 목록의 마지막 번호를 인쇄합니다.

Q예를 들어 값을 포함하도록 d초기화 한 경우d=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

파이썬과 같은 의사 코드 :

Q=eval(input());print(sorted(Q,key=Q.count)[-1])

전체 설명 :

            : Q=eval(input()) (implicit)
e           : ... [-1]
 o   Q      : orderby(lambda N: ...,Q)
  /QN       : count(Q,N)

Pyth orderby는 Python sorted과 똑같이 실행되며 orderby첫 번째 인수는 key인수입니다.

Mathematica, 25 바이트

Last@SortBy[d,d~Count~#&]

또는

#&@@SortBy[d,-d~Count~#&]

챌린지에서와 같이 목록이에 저장 될 것으로 예상합니다 d.

또는 ... 15 바이트

물론 Mathematica가 내장되어 있지 않으면 Mathematica가 아닙니다.

#&@@Commonest@d

Commonest가장 일반적인 요소 (타이의 경우)의 목록을 반환하며 #&@@golfed First@입니다.

루비, 22 바이트

d.max_by{|i|d.count i}

기본적으로 Ruby가 직접 제외하고 Mathematica 답변의 포트 max_by이므로 먼저 정렬 할 필요가 없습니다.

R, 33 25 바이트

도움 단축을위한 @Hugh에게 감사드립니다 :

names(sort(-table(d))[1])

원래:

v=table(d);names(v[which.max(v)])

벡터의 각 요소의 빈도를 계산 한 d다음 가장 큰 값을 포함하는 열의 이름을 반환합니다. 반환 된 값은 실제로 숫자를 포함하는 문자열입니다. 괜찮지 않다고 아무 말도하지 않았으므로 ...

이를 단축하기위한 제안은 환영합니다!

CJam, 11 10 바이트

A{A\-,}$0=

라는 변수의 배열을 가정합니다 A. 이것은 기본적으로 배열의 각 숫자 발생에 따라 배열을 정렬 한 다음 배열의 마지막 요소를 선택합니다.

사용법 예

[1 2 3 4 4 2 6 6 6 6]:A;A{aA\/,}$W=

산출

6

Dennis 덕분에 1 바이트가 절약되었습니다!

여기에서 온라인으로 사용해보십시오

파워 쉘 19

($d|group)[0].Count

(이것은 배열이 이미 켜져 있다고 가정합니다 $d)

J-12 자

익명의 기능. 가장 일반적인 것부터 가장 적은 것까지 목록을 정렬하여 첫 번째 항목을 가져옵니다.

(0{~.\:#/.~)

• 0{ 우선
• ~. 독특한 아이템
• \: 에 의해 분류
• #/.~ 주파수

직접 해보십시오.

자바 스크립트 (ES6) 51

사전로드 된 변수를 사용하는 단일 행 표현식 d. 빈도를 기준으로 배열을 정렬 한 다음 첫 번째 요소를 가져옵니다.
불쾌한 부작용, 원래 배열이 변경됨

d.sort((a,b)=>d.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

평소와 같이 .reduce 대신 .map을 사용하면 전체적으로 1 문자가 짧아집니다. .reduce를 사용하면 거의 깨끗하고 골프가 아닌 솔루션입니다.

d.sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

마지막으로 원래 배열을 변경하지 않고 전역 (62 바이트)을 사용하지 않고 함수를 사용하는 솔루션 :

F=d=>[...d].sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

FireFox / FireBug 콘솔에서 테스트

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]

출력 1

d 배열은 다음과 같습니다.

[1, 1, 1, 1, 1, 4, 4, 4, 4, 3, 3, 3, 0, 6, 6, 0, 7, 7, 2, 8]

파이썬-32

max((x.count(i),i)for i in x)[1]

정직하게 미래에 18 문자 솔루션을 보지 마십시오.

편집 : 나는 정정하고 감동했습니다.

자바 스크립트, ES6, 71 바이트

조금 길고 골프를 많이 할 수 있습니다.

f=a=>(c=b=[],a.map(x=>b[x]?b[x]++:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())

이렇게하면 f호출 할 수 있는 함수 가 만들어져 f([1,1,1,2,1,2,3,4,1,5])반환 1됩니다.

최신 Firefox 콘솔에서 사용해보십시오.

05AB1E , 3 바이트

(비경쟁-질문은 언어보다 우선)

.MJ

설명:

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

입력을 사용하는 대신 변수에 배열을 저장하려면 프로그램 시작시 배열을 스택에 밀어 넣으십시오.

온라인으로 사용해보십시오!

C #-49

C #을 사용하여 실제로 경쟁 할 수는 없지만 잘 작동합니다.

d배열이 가정

d.GroupBy(i=>i).OrderBy(a=>a.Count()).Last().Key;

bash- 29 27 자

sort|uniq -c|sort -nr|sed q

그것을 사용 :

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

즉, "1"이 모드이며 5 번 나타납니다.

GolfScript, 10 바이트

a{a\-,}$0=

에서 이 대답 내가 쓴 GolfScript에서 골프를위한 팁 . 이라는 배열의 입력을 예상하고 a스택에 결과를 반환합니다. (스택의 배열에서 입력을 읽으려면 :11 바이트를 앞에 추가 하고 stdin에서 입력을 읽으려면 (형식으로 [1 2 1 3 7])~ 12 바이트를 .

이 코드는 입력 배열을 반복하고 원래 배열에서 각 요소를 빼고 남은 요소 수를 계산하여 작동합니다. 그런 다음 원래 배열을 정렬하는 키로 사용되며 정렬 된 배열의 첫 번째 요소가 반환됩니다.

온라인 데모.

추신. 이 도전에 대해 지적한 Peter Taylor에게 감사한다 .

Dyalog APL, 12 자

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

∘.=⍨d의 d∘.=d반사 외부 제품과 동일 =합니다. 의 모든 요소 쌍을 비교하는 부울 행렬을 만듭니다 d.

+/ 축 중 하나를 따라 해당 행렬을 합산하고 벡터를 생성합니다.

⍒벡터의 등급을 매 깁니다 (즉, 인덱스별로 정렬). 글리프에서 알 수 있듯이 ⍒내림차순 ⍋으로 등급을 매기고 오름차순으로 등급을 매 깁니다.

⊃그레이딩에서 첫 번째 인덱스 (의 가장 큰 요소의 인덱스)를 가져옵니다 d.

d[...] 해당 요소를 반환합니다.

펄 6 , 21 바이트

.Bag.invert.max.value

예:

$_ = < 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…

넥타이가있는 경우 묶은 것 중 큰 것을 인쇄합니다.

.BagList 또는 Array 의 메소드는 주어진 값을 몇 번 본 총 횟수를 해당 값과 연관시키는 정량화 된 해시를 작성합니다.

bag(4(4), 3(3), 1(5), 0(2), 6(2), 7(2), 2, 8)

이 .invert메소드는 키와 값이 교환 된 백의 쌍 목록을 작성합니다. (우리가 이것을 부르는 이유는 다음 방법이 우리가 원하는 것을 할 수 있기 때문입니다)

4 => 4,  3 => 3,  5 => 1,  2 => 0,  2 => 6,  2 => 7,  1 => 2,  1 => 8

.max쌍의 목록에 대한 방법은 제 값을 비교하는 넥타이의 경우 키를 비교하는 가장 큰 쌍을 반환합니다.
(이것이 multi infix:<cmp>(Pair:D \a, Pair:D \b)큰 쪽을 결정하는 방법이기 때문입니다 )

5 => 1

이 .value메소드는 쌍에서 값을 리턴합니다. ( .invert이전 에 전화 하지 않았다면 그것은 우리의 열쇠 였을 것입니다 )

1

동점 인 경우에 묶인 모든 값을 리턴하려면 다음을 수행하십시오.

say @list.Bag.classify(*.value).max.value».key

이 .classify메소드는 *.value각 쌍으로 Whatever 람다를 호출하여 키가있는 쌍 목록을 리턴합니다  .

1 => [2 => 1, 8 => 1],
2 => [0 => 2, 6 => 2, 7 => 2],
3 => [3 => 3],
4 => [4 => 4],
5 => [1 => 5]

그런 다음 .max가장 큰 페어를 얻기 위해 전화 합니다.

"5" => [1 => 5]

.value가방에서 원래 쌍 을 가져 오라는 요청 (이 경우 단 하나)

1 => 5

그런 다음 목록의 모든 쌍에서 메소드 >>.key를 호출 .key하여 가장 많이 본 값 목록으로 끝납니다.

1

자바 8 : 184 바이트

Stream.of(A).collect(Collectors.groupingBy(i -> i, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).findFirst().get().getKey();

입력 A 는 유형이어야합니다 Integer[]. 주 java.util.*와 java.util.stream.*그들이 밖으로 남아 있습니다 oneliner 필요는 그러나 정신으로 가져올 수 있습니다.

배쉬 + 유닉스 도구, 62 바이트

STDIN의 배열을 예상합니다. 숫자가 음이 아닌 정수이면 입력 형식이 계산되지 않습니다.

grep -o [0-9]\*|sort|uniq -c|sort -n|awk 'END{print $2}'

편집 : grep 인수에서 와일드 카드를 이스케이프 처리했습니다. 이제 비어 있지 않은 디렉토리에서 안전하게 실행할 수 있습니다. manatwork 덕분에.

펄, 27 바이트

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

동점 일 경우 가장 일반적인 값을 반환합니다.

PHP, 53 50 바이트

<?=array_flip($c=array_count_values($d))[max($c)];

다음과 같이 실행하십시오.

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

조정

• 입력이 변수에 할당되었다고 가정 할 수있는 자유를 사용하여 3 바이트 절약 d

자바 8, 83 바이트

d.stream().max((x,y)->Collections.frequency(d,x)-Collections.frequency(d,y)).get();

d이어야합니다 Collection<Integer>.

Collections정적으로 가져올 수있는 경우 :
59 바이트

d.stream().max((x,y)->frequency(d,x)-frequency(d,y)).get();

하스켈 78

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

가져 오기가 무시되면 45 입니다.

하스켈 , 42 39 바이트

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

온라인으로 사용해보십시오!

편집 : -3 바이트의 Zgarb에 비해

Brachylog , 5 바이트

ọtᵒth

온라인으로 사용해보십시오!

이것은 실제로 스 니펫이 아니지만 무엇이 될지 잘 모르겠습니다 ...

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

클로저, 32 바이트

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

(frequencies %)함수로 사용할 수있는 해시 맵을 반환합니다. 키가 주어지면 해당 값을 반환합니다 :)

동등한 길이 :

#(last(sort-by(frequencies %)%))

스칼라, 32

d.groupBy(a=>a).maxBy(_._2.size)

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;

전체 코드 및 테스트 :

#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;
}