Pozitif tamsayılar listesinin modunu (en yaygın sayı) hesaplamak için bir pasaj yazın.

Örneğin, modu

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

olduğunu 1o 5 kez maksimum oluşur çünkü.

Listenin gibi bir değişkende saklandığını dve benzersiz bir moda sahip olduğunu varsayabilirsiniz .

örneğin: Python, 49

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

Bu kod golf , yani bayttaki en kısa çözüm kazanır.

K5, 6 bayt

*>#:'=

Grubun her birinin ( ) sayısının *azalan elemanlarının ( >) ilki ( )#:'= . Adım adım:

  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

Tarayıcınızda deneyin !

Python 2 - 18

max(d,key=d.count)

Python cevabınız basılmış görünmediğinden, istediğiniz şeyin bu olmasını bekliyorum.

printNormalde 6 bayt ekleyin .

Matlab / Octave, 7 5 bayt

Şaşırtıcı olmayan bir şekilde, modları bulmak için yerleşik bir işlev var. Anonim bir işlev olarak:

@mode

Bu, girdi vektöründe en yaygın olarak meydana gelen elemanı, bağları daha küçük olan değere döndürerek döndürür.

Dennis sayesinde 2 bayt kaydedildi!

Pyth - 6

eo/QNQ

Çevrimiçi deneyin.

Stdin benzeri girdiler bekliyor [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Python istikrarlı türler gerçekleştirdiğinden bağlar son olaylarla çözülür.

Listedeki değeri sayarak listeyi sıralar, ardından listenin son sayısını yazdırır.

Qile değiştirilebilir olabilir dsen başlatıldı eğer dörneğin öncesi değeri içermesini=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Python-esque sözde kodu:

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

Tam açıklama:

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

Pyth's orderbytam olarak Python'ınki gibi çalışır sorted, orderbyilk argüman keyargümandır.

Mathematica, 25 bayt

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

veya

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

Mücadelede olduğu gibi, bu, listenin depolanmasını bekler d.

veya ... 15 bayt

Tabii ki, eğer yerleşik olmasaydı, Mathematica, Mathematica olmazdı:

#&@@Commonest@d

Commonesten sık kullanılan öğelerin bir listesini verir (beraberlik durumunda), ve #&@@bir golf oynar First@.

Ruby, 22 bayt

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

Temelde, Mathematica cevabımın bir limanı, Ruby'nin direkleri dışında, max_byilk önce sıralama yapmam gerekmiyor.

R, 3325 bayt

Yardım kısaltması için @Hugh:

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

Orijinal:

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

Bu, vektördeki her bir öğenin sıklığını hesaplar d, ardından en büyük değeri içeren sütunun adını döndürür. Dönen değer aslında sayıyı içeren bir karakter dizesidir. Hiçbir şeyin yolunda gitmediğini söylemedi, o yüzden ...

Bu kısaltmak için herhangi bir öneriniz açığız!

CJam, 11 10 bayt

A{A\-,}$0=

Diziyi denilen bir değişkende varsayar A. Bu temelde dizideki her sayının oluşumuna göre diziyi sıralamakta ve daha sonra dizinin son elemanını seçmektedir.

Örnek kullanım

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

Çıktı

6

Dennis sayesinde 1 bayt kurtarıldı!

Burada çevrimiçi deneyin

Powershell 19

($d|group)[0].Count

(bu, dizinin zaten açık olduğunu varsayar $d)

J - 12 karakter

Anonim işlev İlk öğeyi alarak listeyi en genelden en genel düzeye doğru sıralar.

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

• 0{ İlki
• ~. Benzersiz öğeler
• \: Aşağı göre sırala
• #/.~ frekanslar

Kendin için dene.

JavaScript (ES6) 51

Önceden yüklenmiş değişkeni kullanarak sadece tek bir satır ifadesi d. Diziyi frekansa göre sıralayın, ardından ilk elemanı alın.
Kötü yan etkisi, orijinal dizi değiştirildi

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

Her zamanki gibi, genel olarak 1 karakter daha kısa olduğundan, .reduce yerine .map öğesini kullanın. .Reduce ile 'temiz, golf oynamayan bir çözüm.

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

Sonunda, orijinal diziyi değiştirmeyen ve globalsız (62 bayt) bir işlev kullanan bir çözüm:

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

FireFox / FireBug konsolunda test edin

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]

Çıkış 1

D dizisi şöyle olur:

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

Python - 32

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

Dürüst olmak gerekirse gelecekte 18 karakterlik bir çözüm görmeyin.

EDIT: Düzeltilmiş ve etkilendim duruyorum.

JavaScript, ES6, 71 bayt

Biraz uzun, çok golf oynayabilir.

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

Bu, fbenzer olarak adlandırılabilecek f([1,1,1,2,1,2,3,4,1,5])ve geri dönecek bir fonksiyon yaratır 1.

En son Firefox Konsolunda deneyin.

05AB1E , 3 bayt

(rekabet etmeyen - soru dili yırtıcıdır)

.MJ

Açıklama:

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

Diziyi girdi kullanmak yerine değişkende saklamak istiyorsanız, diziyi programın başlangıcındaki yığına itmeniz yeterlidir.

Çevrimiçi deneyin!

C # - 49

Gerçekten C # kullanarak rekabet edemem ama ah peki:

Diyelim dki dizi

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

bash - 29 27 karakter

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

Onu kullanarak:

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

yani "1" moddur ve beş kez görünür.

GolfScript, 10 bayt

a{a\-,}$0=

Gönderen bu cevap ben yazdım GolfScript golf için ipuçları . Girdiyi bir dizide bekler, asonucu yığına döndürür. (Yığındaki bir diziden girişi okumak :için, 11 bayt için hazırlayın; stdin'den girdi okumak için (biçiminde [1 2 1 3 7]), ayrıca ~12 bayt için hazırlayın.)

Bu kod giriş dizisini yineleyerek, her bir öğeyi orijinal diziden çıkararak ve kalan öğelerin sayısını sayarak çalışır. Bu daha sonra orijinal diziyi sıralamak için bir anahtar olarak kullanılır ve sıralanan dizinin ilk elemanı döndürülür.

Çevrimiçi demo.

Ps. Peter Taylor'a bana bu zorluğu gösterdiği için teşekkür ederim .

Dyalog APL, 12 karakter

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

∘.=⍨dd∘.=ddönüşlü dış ürünü ile aynıdır =. İçindeki her bir öğeyi karşılaştıran bir boole matrisi oluşturur d.

+/ eksenlerin birindeki bu matrisi toplar ve bir vektör üretir.

⍒vektörü derecelendirir, yani dizinleri sıralar. (Gliflerin önerdiği gibi, ⍒azalan düzende ⍋dereceler ve yükselen düzende dereceler).

⊃ilk dizini sınıflandırmadan alır - en büyük elemanının dizini d.

d[...] bu öğeyi döndürür.

Perl 6 , 21 bayt

.Bag.invert.max.value

Örnek:

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

Eğer bir bağ varsa, bağlananlardan daha büyük basar.

.BagList veya bir Array üzerinde yöntem, belirli bir değer bu değerle görüldü kaç kez toplam sayısını ilişkilendiren bir niceliksel karma yaratır.

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

.invertYöntem anahtarı ve takas değerle torbada çiftleri listesi oluşturur. (Bunu adlandırmamızın nedeni bir sonraki yöntemi istediğimizi yapmasıdır)

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

.maxÇiftler bir Listesinde yöntem birinci ve değerlerini karşılaştıran bir eşitlik olması durumunda anahtarlarını karşılaştıran büyük Çifti döndürür.
(Bunun sebebi multi infix:<cmp>(Pair:D \a, Pair:D \b)hangisinin daha büyük olduğunu belirlemesidir)

5 => 1

.valueYöntem Pair değeri verir. (Daha .invertönce arama için olmasaydı, peşimizde olan anahtar olurdu )

1

Beraberlik durumunda bağlı olan tüm değerleri iade etmek istiyorsanız:

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

.classifyYöntem anahtarlar her ne lambda çağrı vardır çiftlerinin bir listesini verir  *.valueçiftlerinin her biri.

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

Sonra .maxen büyük çifti almak için çağırıyoruz .

"5" => [1 => 5]

.valueÇantadan orijinal Çiftleri almak için bir çağrı (bu durumda sadece bir tane)

1 => 5

Daha sonra listedeki her Eşe metodu >>.keyçağırırız .key, böylece en çok görülen değerlerin bir listesini elde ederiz.

1

Java 8: 184 bayt

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

A girişi tipinde olmalıdır Integer[]. Dikkat edin java.util.*ve java.util.stream.*ithal edilmesi gerekir, ancak oneliner ruhunda dışlanırlar.

Bash + unix araçları, 62 bayt

STDIN'deki diziyi bekler. Giriş biçimi, sayılar negatif olmayan tam sayılar olmadığı sürece sayılmaz.

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

Düzenlendi: grep argümanında kaçtı joker karakter. Artık boş olmayan dizinlerde güvenle çalıştırılabilir. İnsan işi için teşekkürler.

Perl, 27 bayt

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

Beraberlik durumunda en son ortak değeri döndürür.

PHP, 53 50 bayt

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

Bu şekilde koş:

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

Düzenlemeler

• Girdi bir değişkene atandığını kabul etme özgürlüğünü kullanarak 3 bayt kurtarıldı d

Java 8, 83 Bayt

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

dolmalı Collection<Integer>.

Eğer Collectionsstatik olarak alınabilir:
59 Bytes

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

İthalat ihmal edilirse, 45'tir .

Haskell , 42 39 bayt

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

Çevrimiçi deneyin!

Düzenleme: -3 bayt Zgarb için Thans

Brachylog , 5 bayt

ọtᵒth

Çevrimiçi deneyin!

Bu gerçekten bir pasaj değil, ama ne olacağından emin değilim.

         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 bayt

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

(frequencies %)işlev olarak kullanılabilecek bir karma haritası döndürür. Bir anahtar verildiğinde karşılık gelen değeri verir :)

Eşit uzunluk:

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

Tam kod ve test:

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