Viết đoạn trích để tính chế độ (số phổ biến nhất) của danh sách các số nguyên dương.

Ví dụ: chế độ của

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

là 1bởi vì nó xảy ra tối đa 5 lần.

Bạn có thể cho rằng danh sách được lưu trữ trong một biến như dvà có chế độ duy nhất.

ví dụ: Python, 49

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

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất tính bằng byte sẽ thắng.

K5, 6 byte

*>#:'=

Đầu tiên ( *) của các phần tử giảm dần ( >) của số lượng từng ( #:') của nhóm ( =). Từng bước một:

  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

Hãy thử nó trong trình duyệt của bạn !

Con trăn 2 - 18

max(d,key=d.count)

Vì câu trả lời trăn của bạn dường như không in, tôi hy vọng đây là những gì bạn muốn.

Thêm 6 byte cho printbình thường.

Matlab / Octave, 7 5 byte

Không có gì đáng ngạc nhiên khi có một chức năng tích hợp để tìm các chế độ. Là một chức năng ẩn danh:

@mode

Điều này trả về phần tử thường xảy ra nhất trong vectơ đầu vào với các mối quan hệ đi đến giá trị nhỏ hơn.

Đã lưu 2 byte nhờ Dennis!

Thứ 6 - 6

eo/QNQ

Hãy thử trực tuyến.

Mong đợi đầu vào trên stdin như thế nào [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Các mối quan hệ được giải quyết bằng lần xuất hiện cuối cùng vì Python thực hiện các loại ổn định.

Sắp xếp danh sách bằng cách đếm giá trị trong danh sách, sau đó in số cuối cùng của danh sách.

Qcó thể được thay thế bằng dnếu bạn khởi tạo dđể chứa giá trị trước, vd=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Mã giả Python-esque:

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

Giải thích đầy đủ:

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

Pyth's orderbychạy chính xác như Python sortedvới orderbyđối số đầu tiên là keyđối số.

Toán học, 25 byte

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

hoặc là

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

Như trong thử thách, điều này hy vọng danh sách sẽ được lưu trữ trong d.

hoặc ... 15 byte

Tất nhiên, Mathicala sẽ không phải là Mathicala nếu nó không được tích hợp sẵn:

#&@@Commonest@d

Commonesttrả về một danh sách tất cả các yếu tố phổ biến nhất (trong trường hợp hòa) và #&@@là một môn đánh gôn First@.

Ruby, 22 byte

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

Về cơ bản là một cổng của câu trả lời Mathicala của tôi, ngoại trừ Ruby có trực tiếp max_bynên tôi không cần phải sắp xếp trước.

R, 33 25 byte

Cảm ơn @Hugh đã rút ngắn trợ giúp:

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

Bản gốc:

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

Điều này sẽ tính tần số của từng phần tử trong vectơ d, sau đó trả về tên của cột chứa giá trị lớn nhất. Giá trị được trả về thực sự là một chuỗi ký tự chứa số. Nó không nói bất cứ nơi nào không ổn, vì vậy ...

Bất kỳ đề xuất để rút ngắn điều này đều được chào đón!

CJam, 11 10 byte

A{A\-,}$0=

Giả sử mảng trong một biến được gọi là A. Điều này về cơ bản là sắp xếp mảng dựa trên sự xuất hiện của từng số trong mảng và sau đó chọn phần tử cuối cùng của mảng.

Ví dụ sử dụng

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

Đầu ra

6

Lưu 1 byte nhờ Dennis!

Dùng thử trực tuyến tại đây

Quyền hạn 19

($d|group)[0].Count

(điều này cho thấy mảng đã được bật $d)

J - 12 char

Chức năng ẩn danh. Sắp xếp danh sách từ hầu hết đến ít phổ biến nhất, lấy mục đầu tiên.

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

• 0{ Đầu tiên của
• ~. Vật phẩm độc đáo
• \: Bị hạ bệ bởi
• #/.~ Thường xuyên

Hãy thử nó cho chính mình.

JavaScript (ES6) 51

Chỉ là một biểu thức dòng đơn sử dụng biến được tải sẵn d. Sắp xếp mảng theo tần số sau đó lấy phần tử đầu tiên.
Tác dụng phụ khó chịu, mảng ban đầu bị thay đổi

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

Như thường lệ, sử dụng .map thay vì .reduce vì tổng thể là 1 char. Với .reduce, nó gần như là một giải pháp sạch sẽ, không chơi gôn.

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

Cuối cùng, một giải pháp sử dụng hàm, không thay đổi mảng ban đầu và không có toàn cục (62 byte):

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

Kiểm tra trong bảng điều khiển 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]

Đầu ra 1

Mảng d trở thành:

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

Con trăn - 32

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

Thành thật không thấy giải pháp 18 ký tự ở bất cứ đâu trong tương lai.

EDIT: Tôi đứng chính xác, và ấn tượng.

JavaScript, ES6, 71 byte

Một chút dài, có thể được chơi golf rất nhiều.

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

Điều này tạo ra một chức năng fcó thể được gọi là thích f([1,1,1,2,1,2,3,4,1,5])và sẽ trở lại 1.

Hãy dùng thử trên Bảng điều khiển Firefox mới nhất của bạn.

05AB1E , 3 byte

(không cạnh tranh - câu hỏi có trước ngôn ngữ)

.MJ

Giải trình:

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

Nếu bạn muốn lưu trữ mảng trong một biến thay vì sử dụng đầu vào, chỉ cần đẩy mảng vào ngăn xếp khi bắt đầu chương trình.

Hãy thử trực tuyến!

C # - 49

Không thể thực sự cạnh tranh bằng C # nhưng ồ:

Giả sử dlà mảng

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

bash - 29 27 ký tự

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

Sử dụng nó:

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

tức là "1" là chế độ và nó xuất hiện năm lần.

GolfScript, 10 byte

a{a\-,}$0=

Từ câu trả lời này, tôi đã viết cho Mẹo chơi golf trong GolfScript . Yêu cầu đầu vào trong một mảng có tên a, trả về kết quả trên ngăn xếp. (Để đọc đầu vào từ một mảng trên ngăn xếp, hãy thêm vào: 11 byte; để đọc đầu vào từ stdin (ở định dạng [1 2 1 3 7]), cũng là thêm vào ~12 byte.)

Mã này hoạt động bằng cách lặp qua mảng đầu vào, trừ từng phần tử khỏi mảng ban đầu và đếm số phần tử còn lại. Điều này sau đó được sử dụng như một khóa để sắp xếp mảng ban đầu và phần tử đầu tiên của mảng được sắp xếp được trả về.

Bản demo trực tuyến.

Thi thiên Cảm ơn Peter Taylor đã chỉ ra thử thách này với tôi .

APL Dyalog, 12 ký tự

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

∘.=⍨dlà giống như d∘.=d, sản phẩm bên ngoài phản xạ của =. Nó tạo ra một ma trận boolean so sánh mọi cặp phần tử trongd .

+/ tổng hợp ma trận dọc theo một trong các trục và tạo ra một vectơ.

⍒xếp loại vectơ, tức là sắp xếp nó theo chỉ số. (Như glyphs đề xuất, ⍒các lớp theo thứ tự giảm dần và ⍋sẽ xếp theo thứ tự tăng dần.)

⊃lấy chỉ số đầu tiên từ điểm phân loại chỉ số của phần tử lớn nhất của d.

d[...] trả về phần tử đó.

Perl 6 , 21 byte

.Bag.invert.max.value

Thí dụ:

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

Nếu có một cái cà vạt, nó sẽ in cái lớn hơn của cái cà vạt.

Các .Bag phương pháp trên một danh sách hoặc một mảng tạo một hash định lượng mà liên kết tổng số bao nhiêu lần một giá trị nhất định đã được nhìn thấy với giá trị đó.

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

Các .invertphương pháp tạo ra một danh sách các cặp trong túi với chìa khóa và giá trị trao đổi. (Lý do chúng tôi gọi đây là phương pháp tiếp theo để làm những gì chúng tôi muốn)

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

Các .maxphương pháp trên một danh sách các cặp trả về Pair lớn nhất so với các phím đầu tiên và trong trường hợp của một tie so sánh các giá trị.
(Điều này là do đó là cách multi infix:<cmp>(Pair:D \a, Pair:D \b)xác định cái nào lớn hơn)

5 => 1

Các .valuephương thức trả về giá trị từ Pair. (Nó sẽ là chìa khóa chúng tôi theo sau nếu không phải là .invertcuộc gọi trước đó)

1

Nếu bạn muốn trả về tất cả các giá trị được buộc trong trường hợp hòa:

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

Các .classifyphương thức trả về một danh sách các cặp nơi các phím là từ gọi lambda Dù  *.valuevới mỗi cặp.

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

Sau đó, chúng tôi gọi .maxđể có được cặp lớn nhất.

"5" => [1 => 5]

Một cuộc gọi để .valuenhận cho chúng tôi các Cặp ban đầu từ Túi (chỉ một trong trường hợp này)

1 => 5

Sau đó, chúng tôi sử dụng >>.keyđể gọi .keyphương thức trên mỗi Cặp trong danh sách, để chúng tôi kết thúc với một danh sách các giá trị được nhìn thấy nhiều nhất.

1

Java 8: 184 byte

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

Đầu vào A phải là loại Integer[]. Lưu ý java.util.*và java.util.stream.*cần phải được nhập khẩu, tuy nhiên trong tinh thần oneliner chúng bị bỏ lại.

Công cụ Bash + unix, 62 byte

Mong đợi các mảng trong STDIN. Định dạng đầu vào không được tính, miễn là các số đó là số nguyên không âm.

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

Đã chỉnh sửa: thoát ký tự đại diện trong đối số grep. Bây giờ nó có thể được chạy một cách an toàn trong các thư mục không trống. Nhờ làm móng tay.

Perl, 27 byte

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

Trả về giá trị phổ biến cuối cùng trong trường hợp hòa.

PHP, 53 50 byte

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

Chạy như thế này:

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

Tinh chỉnh

• Đã lưu 3 byte bằng cách sử dụng quyền tự do để giả sử đầu vào được gán cho một biến d

Java 8, 83 byte

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

dphải là a Collection<Integer>.

Nếu Collectionscó thể được nhập tĩnh:
59 Byte

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

Haskell 78

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

Nếu nhập khẩu bị bỏ qua, đó là 45 .

Haskell , 42 39 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: Thans thành Zgarb cho -3 byte

Brachylog , 5 byte

ọtᵒth

Hãy thử trực tuyến!

Đây thực sự không phải là một đoạn trích, nhưng tôi không chắc điều gì sẽ ...

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

Clojure, 32 byte

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

(frequencies %)trả về một bản đồ băm, có thể được sử dụng như một hàm. Cho một khóa nó trả về giá trị tương ứng :)

Chiều dài bằng nhau:

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

Scala, 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;

Mã và kiểm tra đầy đủ:

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