ধনাত্মক পূর্ণসংখ্যার তালিকার মোড (সর্বাধিক সাধারণ সংখ্যা) গণনা করার জন্য একটি স্নিপেট লিখুন।
উদাহরণস্বরূপ, এর মোড
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])
এটি কোড-গল্ফ , তাই বাইটগুলির মধ্যে সংক্ষিপ্ততম সমাধানটি জিতে।
উত্তর:
*>#:'=
গ্রুপ ( ) এর প্রতিটি ( ) এর গণনার *অবতরণ উপাদানগুলির প্রথম ( )। ধাপে ধাপে:>#:'=
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
max(d,key=d.count)
যেহেতু আপনার অজগর উত্তরটি মুদ্রণযোগ্য বলে মনে হচ্ছে না, আমি আশা করি এটি আপনি চান।
printসাধারণত 6 বাইট যোগ করুন ।
d,এবং মধ্যে একটি স্থান key=।
defaultdict(int)বা ব্যবহার করে চতুর্ভুজ রানটাইম এড়ানো হবে Counter। কিছু একটা Counter(d).most_common()[0]।
আশ্চর্যজনকভাবে মোডগুলি সন্ধানের জন্য একটি অন্তর্নির্মিত ফাংশন রয়েছে। বেনামে ফাংশন হিসাবে:
@modeএটি ইনপুট ভেক্টরের মধ্যে সবচেয়ে বেশি সংঘটিত উপাদানটিকে আরও ছোট মানতে যাওয়ার সাথে ফেরত দেয়।
ডেনিসের জন্য 2 টি বাইট সংরক্ষণ করা!
help mode): "যদি দুটি বা আরও বেশি হয় তবে মানগুলির একই ফ্রিকোয়েন্সি থাকে 'মোড` সবচেয়ে ছোট দেয় `
@mode।
eo/QNQ
স্টিডিনে ইনপুট আশা করে [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ঠিক পাইথন মত রান sortedদিয়ে orderbyএর প্রথম আর্গুমেন্ট হচ্ছে keyযুক্তি।
Last@SortBy[d,d~Count~#&]
অথবা
#&@@SortBy[d,-d~Count~#&]
চ্যালেঞ্জ হিসাবে, এটি তালিকাটি সংরক্ষণের আশা করে d।
অবশ্যই ম্যাথমেটিকা ম্যাথমেটিকা না থাকলে এটি অন্তর্নির্মিত না থাকলে:
#&@@Commonest@d
Commonestসমস্ত সাধারণ উপাদানগুলির একটি তালিকা (টাইয়ের ক্ষেত্রে) প্রদান করে এবং #&@@এটি গল্ফ হয় First@।
d.max_by{|i|d.count i}
মূলত আমার গাণিতিক উত্তরটির একটি বন্দর, রুবির বাদে সরাসরি আছে max_byতাই আমার প্রথমে বাছাইয়ের দরকার নেই।
d.max_by d.method:countতবে এটি প্রায় মিলিয়ন (প্রায় দুইটি নয়) বাইট দীর্ঘতর। তবুও, এটি সম্ভব যে লক্ষণীয়।
সাহায্য সংক্ষিপ্তকরণের জন্য ধন্যবাদ @
names(sort(-table(d))[1])
মূল:
v=table(d);names(v[which.max(v)])
এটি ভেক্টরের প্রতিটি উপাদানের ফ্রিকোয়েন্সি গণনা করে d, তারপরে সর্বাধিক মানযুক্ত কলামটির নাম দেয়। প্রত্যাবর্তিত মানটি হ'ল সংখ্যাযুক্ত একটি অক্ষরের স্ট্রিং। এটি কোথাও বলেনি যে এটি ঠিক ছিল না, তাই ...
এটি সংক্ষিপ্ত করার জন্য কোনও পরামর্শ স্বাগত!
names(sort(-table(d))[1])
A{A\-,}$0=
কলকৃত একটি ভেরিয়েলে অ্যারে ধরে নেয় A। এটি মূলত অ্যারেতে প্রতিটি সংখ্যার উপস্থিতির ভিত্তিতে অ্যারে বাছাই করে এবং তারপরে অ্যারের শেষ উপাদানটি বাছাই করে।
ব্যবহারের উদাহরণ
[1 2 3 4 4 2 6 6 6 6]:A;A{aA\/,}$W=
আউটপুট
6
ডেনিসকে ধন্যবাদ 1 বাইট!
A{A\-,}$0=এক বাইট খাটো।
Ae`$e_W=
$e`$e_W=
বেনামে ফাংশন। সর্বাধিক থেকে কমপক্ষে সাধারণ থেকে তালিকা তৈরি করুন, প্রথম আইটেমটি নিয়ে।
(0{~.\:#/.~)
0{ প্রথম~. স্বতন্ত্র আইটেম\: দ্বারা ডাউনসোর্টড#/.~ ফ্রিকোয়েন্সিপ্রিলোডেড ভেরিয়েবলটি ব্যবহার করে কেবল একটি একক লাইন প্রকাশ d ফ্রিকোয়েন্সি অনুসারে অ্যারে বাছাই করুন তারপরে প্রথম উপাদানটি পান।
অদ্ভুত পার্শ্ব প্রতিক্রিয়া, মূল অ্যারে পরিবর্তন করা হয়
d.sort((a,b)=>d.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]
যথারীতি, .reduc পরিবর্তে .map ব্যবহার করা কারণ এটি সামগ্রিকভাবে 1 টি খাটো কম। .ড্রেস করে এটি প্রায় একটি পরিষ্কার, অ-গল্ফযুক্ত সমাধান।
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]
কিছুটা দীর্ঘ, অনেক গল্ফ করা যেতে পারে।
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।
আপনার সর্বশেষতম ফায়ারফক্সের কনসোলে এটি ব্যবহার করে দেখুন।
f=a=>(c=b=[],a.map(x=>b[x]++-1?0:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())1 বাইট সংক্ষিপ্ত।
(অ-প্রতিদ্বন্দ্বী - প্রশ্ন ভাষার পূর্বে)
.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.
আপনি যদি ইনপুট ব্যবহারের পরিবর্তে অ্যারেটিকে একটি চলকতে সঞ্চয় করতে চান তবে প্রোগ্রামের শুরুতে অ্যারেটিকে স্ট্যাকের দিকে চাপুন।
সি # ব্যবহার করে আসলেই প্রতিযোগিতা করতে পারবেন না তবে ওহ ভাল:
ধরে dনেওয়া অ্যারে হয়
d.GroupBy(i=>i).OrderBy(a=>a.Count()).Last().Key;
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বেশ কয়েকটি চরিত্র সংরক্ষণ করে
a{a\-,}$0=
এই উত্তরটি থেকে আমি গল্ফস্ক্রিপ্টে গল্ফ করার জন্য টিপসকে লিখেছিলাম । নামের অ্যারেতে ইনপুট আশা করে a, স্ট্যাকের ফলাফল দেয় result (স্ট্যাকের একটি অ্যারে থেকে ইনপুট পড়তে, :11 বাইটের জন্য প্রিপেন্ড করুন; স্টিডিনের ইনপুট পড়ার জন্য (ফর্ম্যাটে [1 2 1 3 7]), ~12 বাইটের জন্যও প্রিপেন্ড করুন ))
এই কোডটি ইনপুট অ্যারেতে পুনরাবৃত্তি করে, প্রতিটি উপাদানকে মূল অ্যারে থেকে বিয়োগ করে এবং বাম উপাদানগুলির সংখ্যা গণনা করে কাজ করে। এটির পরে মূল অ্যারেটি বাছাই করার জন্য কী হিসাবে ব্যবহৃত হয় এবং সাজানো অ্যারের প্রথম উপাদানটি ফিরে আসে।
গীত। আমার কাছে এই চ্যালেঞ্জটি নির্দেশ করার জন্য পিটার টেলরকে ধন্যবাদ জানাই ।
∘.=⍨dএর d∘.=dপ্রতিচ্ছবি বহিরাগত পণ্য হিসাবে একই =। এটি প্রতিটি জোড় উপাদানগুলির সাথে তুলনা করে একটি বুলিয়ান ম্যাট্রিক্স তৈরি করে d।
+/ অক্ষগুলির একটিতে বরাবর ম্যাট্রিক্স যোগ করে এবং একটি ভেক্টর তৈরি করে।
⍒ভেক্টর গ্রেড করে, অর্থাত সূচকগুলি অনুসারে এটি সাজায়। (গ্লিফগুলি যেমন পরামর্শ দেয়, ⍒অবতরণ ক্রমে ⍋গ্রেড এবং আরোহী ক্রমে গ্রেড হবে))
⊃গ্রেডিং থেকে প্রথম সূচক নেয় takes এর বৃহত্তম উপাদানের সূচক d।
d[...] যে উপাদানটি ফেরত দেয়।
+/∘.=⍨dপ্রতিটি উপাদান জন্য গণনা d। ⊢∘≢⌸dপ্রতিটি উপাদানের জন্য গণনা করা হয় ∪d, সুতরাং সূচকগুলি এর সাথে মিলে না d। Counterexample: d←1 1 2 2 2। এটি কাজ করতে: (∪d)[⊃⍒⊢∘≢⌸d]বা (⊃⍒⊢∘≢⌸d)⊃∪d।
.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আগে কল না হত তবে আমরা পরে কী ছিলাম )
1আপনি যদি টাইয়ের ক্ষেত্রে আবদ্ধ সমস্ত মানটি ফিরিয়ে দিতে চান:
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, যাতে সর্বাধিক দেখা যায় এমন মানগুলির একটি তালিকা আমরা শেষ করি।
1Stream.of(A).collect(Collectors.groupingBy(i -> i, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).findFirst().get().getKey();
ইনপুট এ অবশ্যই টাইপের হতে হবে Integer[]। নোট করুন java.util.*এবং java.util.stream.*আমদানি করা দরকার, তবে স্পিরিট অনেলাইনারে এগুলি বাদ রয়েছে।
(i->i,Collectors.counting())।
STDIN এ অ্যারের আশা করে। ইনপুট বিন্যাসটি গণনা করা হয় না, যতক্ষণ না সংখ্যা অ-নেতিবাচক পূর্ণসংখ্যা হয়।
grep -o [0-9]\*|sort|uniq -c|sort -n|awk 'END{print $2}'
সম্পাদিত: গ্রেপ আর্গুমেন্টে ওয়াইল্ডকার্ড পালিয়ে গেছে। এখন এটি খালি নয় এমন ডিরেক্টরিতে নিরাপদে চালানো যেতে পারে। মানবিক কাজের জন্য ধন্যবাদ।
[0-9]*ফাইলের নামের সাথে মিলে প্রসারিত হতে পারে।
'যুক্তির আশেপাশে রাখুন grep।
<?=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
dimport Data.List
import Data.Ord
g=head.maximumBy(comparing length).group.sort
যদি আমদানি উপেক্ষা করা হয় তবে এটি 45 ।
maximumByপরিবর্তে 2 বাইট সংরক্ষণ করতে পারেন last.sortBy। নতুন কোড হয়ে যাবে g=head.maximumBy(comparing length).group.sort।
g=। 2.) আপনি প্রতিস্থাপন করতে পারেন maximumBy(comparing length)দ্বারা snd.maximum.map((,)=<<length)যা আমদানি করার দরকার নেই Ord, 62 বাইট মোট: এটি অনলাইন ব্যবহার করে দেখুন!
f s=snd$maximum[([1|y<-s,y==x],x)|x<-s]সম্পাদনা করুন: -৩ বাইটের জন্য জগারবকে ধন্যবাদ
sumএখানে অপ্রয়োজনীয় মনে করি ।
ọ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).
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;
}