26

सकारात्मक पूर्णांकों की सूची के मोड (सबसे सामान्य संख्या) की गणना करने के लिए एक स्निपेट लिखें।

उदाहरण के लिए, की विधा

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

है 1, क्योंकि यह अधिकतम 5 बार होता है।

आप मान सकते हैं कि सूची एक चर में संग्रहीत है जैसे कि dऔर एक अद्वितीय मोड है।

उदाहरण: पायथन, 49

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

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा समाधान है।

code-golf array-manipulation

— garg10may
स्रोत

5

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

इसे अपने ब्राउज़र में आज़माएं !

— JohnE
स्रोत

29

अजगर 2 - 18

max(d,key=d.count)

चूँकि आपका अजगर जवाब नहीं छापता है, मुझे उम्मीद है कि आप यही चाहते हैं।

printसामान्य रूप से 6 बाइट्स जोड़ें ।

— FryAmTheEggman
स्रोत

एकदम सही, सोचिए @globby को भविष्य देखने की ज़रूरत है :)

— garg10may

12

इस एक के बारे में महान बात यह है कि यह भी गोल्फ नहीं है, यह सिर्फ पायथन है। केवल बात यह है कि golfed किया गया है के बीच एक रिक्ति है d,और key=।

— व्रकिन

5

@Chargin: एह, Pythonic का उपयोग करके defaultdict(int)या द्विघात रनटाइम से बचने के लिए किया जाएगा Counter। कुछ इस तरह Counter(d).most_common()[0]।

— user2357112

25

मतलाब / ऑक्टेव, 7 5 बाइट्स

मोड खोजने के लिए एक अंतर्निहित कार्य है। एक अनाम फ़ंक्शन के रूप में:

@mode

यह छोटी मात्रा में जाने वाले संबंधों के साथ इनपुट वेक्टर में सबसे सामान्य रूप से उत्पन्न होने वाला तत्व देता है।

डेनिस के लिए धन्यवाद 2 बाइट्स सहेजे गए!

— एलेक्स ए।
स्रोत

3

+1, स्पष्ट रूप से नौकरी के लिए सही उपकरण। जैसा कि यह एक बिलिन है, क्या होता है अगर एक से अधिक संख्या होती है?

— लेवल रिवर सेंट

2

प्रलेखन के अनुसार @steveverrill (प्रकार help mode): "यदि दो, या अधिक, मानों की आवृत्ति समान है 'मोड' सबसे छोटा रिटर्न देता है।"

— व्रचिनि

1

कार्यों को अनुमति दी गई प्रतीत होती है (स्वीकृत उत्तर एक है), इसलिए आप इसे छोटा कर सकते हैं @mode।

— डेनिस

@ डेनिस धन्यवाद! हालांकि मैं मानता हूं कि साइट पर अपना पहला उत्तर संपादित करने के लिए यह एक अजीब लग रहा है।

— एलेक्स ए।

16

अजगर - 6

eo/QNQ

इसे ऑनलाइन आज़माएं।

स्टड पर इनपुट की उम्मीद है [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]। संबंधों को अंतिम घटना द्वारा हल किया जाता है क्योंकि पायथन स्थिर रूप से प्रदर्शन करता है।

सूची में मान की गणना करके सूची को सॉर्ट करता है, फिर सूची के अंतिम नंबर को प्रिंट करता है।

Qdयदि आपने 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)

पाइथ का orderbyरन वास्तव में पाइथन के पहले तर्क के sortedसाथ तर्क की तरह है।orderbykey

— FryAmTheEggman
स्रोत

11

गणितज्ञ, 25 बाइट्स

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

या

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

चुनौती के रूप में, यह सूची को संग्रहित करने की उम्मीद करता है d।

या ... 15 बाइट्स

अगर यह एक अंतर्निहित नहीं था, तो निश्चित रूप से, गणितज्ञ गणितज्ञ नहीं होगा:

#&@@Commonest@d

Commonestसभी सबसे आम तत्वों की सूची देता है (टाई के मामले में), और #&@@एक गोल्फ है First@।

— मार्टिन एंडर
स्रोत

Mthmca के लिए एक और मामला

— माइकल स्टर्न

9

रूबी, 22 बाइट्स

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

मूल रूप से मेरे गणितज्ञ उत्तर का एक बंदरगाह, सिवाय रूबी के पास एक प्रत्यक्ष है max_byइसलिए मुझे पहले छाँटने की आवश्यकता नहीं है।

— मार्टिन एंडर
स्रोत

1

मैं सुझाव देने वाला था, d.max_by d.method:countलेकिन यह लगभग एक मिलियन (उर्फ दो भी नहीं) बाइट्स लंबा है। फिर भी, यह ध्यान देने योग्य है कि यह संभव है।

— निधि मोनिका का मुकदमा

9

आर, 33 25 बाइट्स

धन्यवाद @ मदद कम करने के लिए ह्यूग:

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

असली:

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

यह वेक्टर में प्रत्येक तत्व की आवृत्ति की गणना करता है d, फिर सबसे बड़े मान वाले कॉलम का नाम लौटाता है। लौटाया गया मूल्य वास्तव में एक वर्ण स्ट्रिंग है जिसमें संख्या होती है। यह कहीं भी नहीं कहा कि ठीक नहीं था, इसलिए ...

इसे छोटा करने के किसी भी सुझाव का स्वागत है!

— एलेक्स ए।
स्रोत

2

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

— ह्यूज

9

सीजेएम, 11 10 बाइट्स

A{A\-,}$0=

सरणी को एक चर में कहा जाता है A। यह मूल रूप से सरणी में प्रत्येक संख्या की घटना के आधार पर सरणी को छांट रहा है और फिर सरणी के अंतिम तत्व को चुनता है।

उदाहरण उपयोग

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

उत्पादन

1 बाइट ने डेनिस को दिया धन्यवाद!

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

A{A\-,}$0=एक बाइट कम है

— डेनिस

1

०.६.५ के रूप में tes बाइट्स में यह उल्लेखनीय है:Ae`$e_W=

— मार्टिन एंडर

@MartinEnder उम्म ... नहीं । मुझे पता था कि आपको पहले क्रमबद्ध करना होगा।

— १२:१६ को

@ErikGolfer エリ fer fer fer フ ops ops ops व्हाट्स, आप सही हैं, 9 बाइट्स की जरूरत है:$e`$e_W=

— मार्टिन एंडर

8

शक्तियां १ ९

($d|group)[0].Count

(यह माना जाता है कि सरणी पहले से ही है $d)

— DarkAjax
स्रोत

8

जे - 12 चार

अनाम फ़ंक्शन। प्रथम आइटम लेते हुए, सबसे कम से कम सामान्य से सॉर्ट सूची।

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

0{ के पहले
~. अद्वितीय आइटम
\: द्वारा डाउन किया गया
#/.~ आवृत्तियों

इसे अपने लिए आजमाएं।

— algorithmshark
स्रोत

यह वास्तव में 10 बाइट्स है - फ़ंक्शन को पैरेंस के बिना सौंपा जा सकता है।

— कॉनर ओ'ब्रायन

6

जावास्क्रिप्ट (ईएस 6) 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]

फायरफॉक्स / फायरबग कंसोल में टेस्ट

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

डी सरणी बन जाता है:

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

— edc65
स्रोत

5

अजगर - 32

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

ईमानदार होने के लिए भविष्य में कहीं भी 18 चरित्र का समाधान न देखें।

संपादित करें: मैं सही, और प्रभावित खड़ा हूँ।

— globby
स्रोत

4

जावास्क्रिप्ट, ईएस 6, 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।

इसे अपने नवीनतम फ़ायरफ़ॉक्स कंसोल पर आज़माएं।

— अनुकूलक
स्रोत

ऑफ-टॉपिक, लेकिन मुझे सिर्फ एहसास हुआ कि आपका उपयोगकर्ता नाम PCG.SE के लिए कितना प्रासंगिक है। : पी

— nyuszika7h

@ nyuszika7h हेह। हालांकि मुझे पता है कि पीपीसीजी के अस्तित्व में आने से पहले भी मेरा यह उपयोगकर्ता नाम रहा है।

— ऑप्टिमाइज़र

f=a=>(c=b=[],a.map(x=>b[x]++-1?0:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())1 बाइट छोटी है।

— बैलिंट

4

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.

यदि आप इनपुट का उपयोग करने के बजाय एक चर में सरणी को संग्रहीत करना चाहते हैं, तो बस कार्यक्रम की शुरुआत में सरणी को स्टैक पर धक्का दें।

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत

3

सी # - 49

वास्तव में C # का उपयोग करके प्रतिस्पर्धा नहीं कर सकते, लेकिन अच्छी तरह से ओह:

मान dलेना सरणी है

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

— ब्रैंडन
स्रोत

3

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" मोड है, और यह पांच बार दिखाई देता है।

sort|uniq -c|sort -nr|sed qकुछ पात्रों को बचाता है

— डिजिटल ट्रॉमा

मैंने उसी उत्तर को पोस्ट किया, लेकिन आप तेजी से थे :)

— पैग

@ पगी - शुक्रिया - अपडेट किया है!

3

GolfScript, 10 बाइट्स

a{a\-,}$0=

से इस उत्तर मैं करने के लिए लिखा था GolfScript में गोल्फ के लिए सुझाव । नाम की एक सरणी में इनपुट की उम्मीद है a, स्टैक पर परिणाम देता है। (स्टैक पर एक सरणी से इनपुट पढ़ने के :लिए, 11 बाइट्स के लिए प्रीपेंड करें ; स्टडिन से इनपुट को पढ़ने के लिए (प्रारूप में [1 2 1 3 7]), ~12 बाइट्स के लिए भी प्रीपेंड करें ।)

यह कोड इनपुट सरणी पर पुनरावृति करता है, प्रत्येक तत्व को मूल सरणी से घटाता है, और बचे हुए तत्वों की संख्या गिनता है। इसके बाद मूल सरणी को क्रमबद्ध करने के लिए एक कुंजी के रूप में उपयोग किया जाता है, और क्रमबद्ध सरणी का पहला तत्व वापस आ जाता है।

ऑनलाइन डेमो।

Ps। मेरे लिए इस चुनौती को इंगित करने के लिए पीटर टेलर का धन्यवाद ।

— इल्मरी करोनें
स्रोत

3

डायलाग एपीएल, 12 अक्षर

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

∘.=⍨dके रूप में ही है d∘.=d, के रूप में प्रतिवर्त बाहरी उत्पाद =। यह तत्वों की हर जोड़ी की तुलना में एक बूलियन मैट्रिक्स बनाता है d।

+/ एक मैट्रिक्स के साथ मैट्रिक्स को sums और एक वेक्टर का उत्पादन करता है।

⍒वेक्टर को ग्रेड करते हैं, अर्थात सूचकांकों द्वारा इसे क्रमबद्ध करते हैं। (जैसा कि ग्लिफ़ का सुझाव है, ⍒अवरोही क्रम ⍋में ग्रेड और आरोही क्रम में ग्रेड होगा।)

⊃ग्रेडिंग से पहला सूचकांक लेता है - सबसे बड़े तत्व का सूचकांक d।

d[...] उस तत्व को लौटाता है।

— NGN
स्रोत

+/∘.=⍨dके प्रत्येक तत्व के लिए मायने रखता है d। ⊢∘≢⌸dप्रत्येक तत्व के लिए मायने रखता है ∪d, इसलिए सूचकांकों के अनुरूप नहीं हैं d। Counterexample: d←1 1 2 2 2। इसे काम करने के लिए: (∪d)[⊃⍒⊢∘≢⌸d]या (⊃⍒⊢∘≢⌸d)⊃∪d।

— ngn

3

पर्ल 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…

यदि कोई टाई है तो यह बड़े लोगों को प्रिंट करेगा जो बंधे हुए हैं।

.Bagएक सूची या किसी सरणी पर विधि एक मात्रा निर्धारित हैश कि कितनी बार किसी दिए गए मूल्य कि मूल्य के साथ देखा गया था की कुल संख्या एकत्रित करती है बनाता है।

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पहले कॉल के लिए नहीं थे तो यह हमारे लिए महत्वपूर्ण होगा )

यदि आप एक टाई के मामले में बंधे सभी मूल्यों को वापस करना चाहते हैं:

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

.classifyविधि जोड़े जहां कुंजी जो भी लैम्ब्डा कॉल करने से कर रहे हैं की एक सूची लौटाती *.valueजोड़े में से प्रत्येक के साथ।

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, ताकि हम उन मूल्यों की एक सूची के साथ समाप्त हो जाएं जिन्हें सबसे अधिक देखा गया था।

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

जावा 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 में उन्हें छोड़ दिया जाता है।

— PoweredByRice
स्रोत

downvoting की वजह से ...?

— PoweredByRice 20

मुझे पता है कि यह दो साल से अधिक हो गया है, लेकिन आप रिक्त स्थान हटा सकते हैं (i->i,Collectors.counting())।

— केविन क्रूज़सेन

2

बैश + यूनिक्स उपकरण, 62 बाइट्स

एसटीडीआईएन में सरणी की अपेक्षा करता है। इनपुट प्रारूप की गणना नहीं की जाती है, जब तक कि संख्याएं गैर-नकारात्मक पूर्णांक हैं।

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

संपादित: grep तर्क में वाइल्डकार्ड से बच गए। अब इसे गैर-रिक्त निर्देशिकाओं में सुरक्षित रूप से चलाया जा सकता है। मैनटवर्क की बदौलत।

— PGY
स्रोत

1

खाली निर्देशिका में चलाने पर सर्वश्रेष्ठ। अन्यथा [0-9]*मिलान फ़ाइल नामों के लिए विस्तारित हो सकता है।

— मैनटवर्क

वैकल्पिक रूप से, 'तर्क के चारों ओर रखो grep।

— पाओलो एबरमन

2

पर्ल, 27 बाइट्स

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

एक टाई के मामले में अंतिम सबसे आम मूल्य देता है।

— टन हास्पेल
स्रोत

2

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

— aross
स्रोत

2

जावा 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();

— CPU1
स्रोत

2

हास्केल 78

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

यदि आयात की अनदेखी की जाती है, तो यह 45 है ।

1

आप का उपयोग करके बिंदु मुक्त शैली का उपयोग करके 4 बाइट और 2 बाइट्स बचा सकता है maximumByबजाय last.sortBy। नया कोड बन जाएगा g=head.maximumBy(comparing length).group.sort।

— हेजल ने

1.) बेनामी कार्यों की अनुमति है, इसलिए आप ड्रॉप कर सकते हैं g=। 2.) आप कुल 62 बाइट्स के लिए आयात करने की आवश्यकता नहीं maximumBy(comparing length)है snd.maximum.map((,)=<<length)जिसके द्वारा प्रतिस्थापित कर सकते हैं Ord: इसे ऑनलाइन आज़माएं!

— लकोनी

2

हास्केल , 42 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: -3 बाइट्स के लिए ज़गारब की तुलना में

— Laikoni
स्रोत

1

मुझे लगता sumहै कि यहां अनावश्यक है।

— जर्गब

@Zgarb राइट, मैंने वास्तव में पिछले उत्तर में उसी चाल का उपयोग किया था । मुझे याद दिलाने के लिये धन्यवाद!

— लकोनी

2

ब्रेकीलॉग , 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).

— असंबंधित स्ट्रिंग
स्रोत

यह नकारात्मक इनपुट के लिए विफल रहता है

— garg10may

@ garg10may एक हाइफन के बजाय एक अंडरस्कोर का उपयोग करें, इसे इस तरह से काम करना चाहिए

— असंबंधित स्ट्रिंग

2

क्लोजर, 32 बाइट्स

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

(frequencies %)एक हैश-मैप देता है, जिसका उपयोग फ़ंक्शन के रूप में किया जा सकता है। एक कुंजी को देखते हुए यह संबंधित मान लौटाता है :)

समान लंबाई:

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

— NikoNyrh
स्रोत

1

स्काला, ३२

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

— चाड Retz
स्रोत

1

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

— bacchusbeale
स्रोत

किसी सूची का मोड (सबसे सामान्य तत्व)

K5, 6 बाइट्स

अजगर 2 - 18

मतलाब / ऑक्टेव, 7 5 बाइट्स

अजगर - 6

गणितज्ञ, 25 बाइट्स

या ... 15 बाइट्स

रूबी, 22 बाइट्स

आर, 33 25 बाइट्स

सीजेएम, 11 10 बाइट्स

शक्तियां १ ९

जे - 12 चार

जावास्क्रिप्ट (ईएस 6) 51

अजगर - 32

जावास्क्रिप्ट, ईएस 6, 71 बाइट्स

05AB1E , 3 बाइट्स

सी # - 49

bash - 29 27 वर्ण

GolfScript, 10 बाइट्स

डायलाग एपीएल, 12 अक्षर

पर्ल 6 , 21 बाइट्स

उदाहरण:

जावा 8: 184 बाइट्स

बैश + यूनिक्स उपकरण, 62 बाइट्स

पर्ल, 27 बाइट्स

PHP, 53 50 बाइट्स

बदलाव

जावा 8, 83 बाइट्स

हास्केल 78

हास्केल , 42 39 बाइट्स

ब्रेकीलॉग , 5 बाइट्स

क्लोजर, 32 बाइट्स

स्काला, ३२

C ++ 119