দশ লক্ষের অধীনে প্রাইমগুলির তালিকা

56

এটি আমার প্রথম কোড গল্ফ প্রশ্ন, এবং এটিতে খুব সহজ একটি প্রশ্ন, তাই আমি যদি কোনও সম্প্রদায়ে নির্দেশিকা ভঙ্গ করতে পারি তবে আমি আগেই ক্ষমা চাই।

কাজটি হ'ল ক্রম হিসাবে মুদ্রণ করা, সমস্ত মিলিয়ন মিলিয়নের চেয়ে কম সংখ্যক। আউটপুট বিন্যাসে আউটপুট প্রতি লাইন এক নম্বর হওয়া উচিত।

বেশিরভাগ কোড গল্ফ জমা দেওয়ার সাথে সাথে লক্ষ্যটি হ'ল কোডের আকার হ্রাস করা। রানটাইমের জন্য অপ্টিমাইজ করাও বোনাস, তবে এটি একটি গৌণ উদ্দেশ্য।

code-golf  kolmogorov-complexity  primes 
— দেলান আজাবানী
সূত্র
12
এটি হুবহু সদৃশ নয়, তবে এটি মূলত কেবলমাত্র প্রাথমিকতা পরীক্ষা, যা প্রচুর বিদ্যমান প্রশ্নের একটি উপাদান (যেমন কোডগল্ফ.স্ট্যাকেক্সচেঞ্জ / সেকশনস / ১১৩ , কোডগলফ.স্ট্যাকেক্সচেঞ্জ / সেকশনস / 87০87 ,, কোডগলফ.স্ট্যাকেক্সেঞ্জ)। কম / প্রশ্ন / 1977 )। এফডব্লিউআইডাব্লু, একটি নির্দেশিকা যা যথেষ্ট পরিমাণে অনুসরণ করে না (এমনকি যারা আরও ভাল জানেন তাদেরও উচিত) এটি কীভাবে হতে পারে তার সমালোচনা এবং আলোচনার জন্য মেটা স্যান্ডবক্স মেটা কোডেগল্ড.স্ট্যাকেকেক্সচেঞ্জ / প্রশ্নস / ৪৩৩ এ একটি প্রশ্ন প্রাক-প্রস্তাব করতে হবে লোকেরা এর উত্তর দেওয়া শুরু করার আগেই উন্নত।
— পিটার টেলর
হ্যাঁ, হ্যাঁ, আমি এই প্রশ্নটি প্রায় ইতিমধ্যে প্রাইম সংখ্যা-সম্পর্কিত প্রশ্নের আধিক্যের সাথে খুব সাদৃশ্যযুক্ত হয়ে পড়েছিলাম।
— দেলান আজাবানী
2
@ গ্লেনরান্ডার্স-পেহারসন কারণ 10^6আরও খাটো;)
— উস
1
কয়েক বছর আগে আমি একটি আইওসিসি'র এন্ট্রি জমা দিয়েছিলাম যা সিতে মাত্র 68 টি অক্ষর সহ প্রাইমগুলি মুদ্রণ করে - দুর্ভাগ্যক্রমে এটি এক মিলিয়নের চেয়ে কম হয়ে যায় তবে কারও কারও পক্ষে এটি আগ্রহী: computronium.org/ioccc.html
— Computronium
1
@ ɐɔıʇǝɥʇuʎs কেমন 1e6:-D
— তিতাস

উত্তর:

33

গণিত , 17 24

কেবল তুলনার জন্য:

Prime@Range@78498

একটি মন্তব্যে উল্লিখিত হিসাবে আমি প্রতি লাইন প্রতি একটি প্রধান প্রদান করতে ব্যর্থ; সংশোধন:

Column@Prime@Range@78498
— Mr.Wizard
সূত্র
4
Prime~Array~78498এছাড়াও 17 :)
— চ্যানোগ
এটি মুক্তি পেলে এমটিএমসিএর নয়টি বাইট হবে।
— মাইকেল স্টারন
এটি আউটপুট প্রতি লাইন প্রতি এক প্রধান শর্ত লঙ্ঘন করে। 8 টি অতিরিক্ত অক্ষরের ব্যয় করে এস সংশোধনকারীগুলির একটি দীর্ঘ তালিকার আউটপুট প্রতিরোধে এর সাথে উপসর্গ Print/@এবং সমাপ্তি । ;Null
— celtschk
@celtschk আমি জানি না যে আমি পাঁচ বছর আগে এটি মিস করেছি বা অগ্রাহ্য করেছি কিনা।
— মিঃ উইজার্ড
1
ঠিক আছে, আমি অবশ্যই মিস করেছি যে এটি পাঁচ বছর আগে থেকেই ছিল :-)
— সেলটস্ক
27

পাইথন 3, 46 বাইট

k=P=1
while k<1e6:P%k and print(k);P*=k*k;k+=1

লুপটি পরীক্ষায় পৌঁছানোর পরে k, এটি পুনরাবৃত্তভাবে স্কোয়ার-ফ্যাক্টরিয়াল গণনা করে P=(k-1)!^2। যদি kপ্রধান হয়, তবে এটি পণ্যটিতে উপস্থিত হয় না 1 * 2 * ... * (k-1), সুতরাং এটি কোনও কারণ নয় P। তবে, যদি এটি সম্মিলিত হয় তবে এর সমস্ত প্রধান কারণগুলি পণ্যটিতে ছোট। স্কোয়ারিংটি আসলে k=4মিথ্যাভাবে প্রধান বলা থেকে বিরত হওয়ার প্রয়োজন ।

আরও দৃ strongly়ভাবে, এটি উইলসনের উপপাদ্য থেকে অনুসরণ করা হয় যে যখন kপ্রধান হয়, P%kসমান হয় 1। যদিও আমাদের কেবল এটি এখানে ননজারো দরকার, এটি সাধারণভাবে কার্যকর যে এটি প্রাইম P%kকিনা kতার জন্য একটি সূচক পরিবর্তনশীল ।

— xnor
সূত্র
23

সি, 61 টি অক্ষর

এই একের মতো প্রায় একই (প্রশ্নটিও প্রায় একই রকম)।

n=2;main(m){n<1e6&&main(m<2?printf("%d\n",n),n:n%m?m-1:n++);}
— ugoren
সূত্র
SEG-FAULTমুদ্রণের পরে পেয়েছেন881
— মানব এমএন
7
@ মানাভ, সম্ভবত আপনি অপটিমাইজেশন ছাড়াই সংকলন করেছেন। এটি একটি ভাল অপ্টিমাইজারের উপর নির্ভর করে যা পুনরাবৃত্তি সরিয়ে ফেলবে।
— উগোরেন
4
হ্যাঁ যোগ -O3করার gccসমস্যার সমাধান !!
— মানব
এই পদ্ধতিটি পাগল। আমি এটা ভালোবাসি.
— টড লেহম্যান
2
আমি আপনাকে 57 বাইটে পেতে পারিn=2;main(m){n<1e6&&main(m<2?printf("%d\n",n),n:m-++n%m);}
— অ্যালবার্ট রেনশওয়া
22

ম্যাটল্যাব (16) (12)

দুর্ভাগ্যক্রমে, একক লাইনে এই ফলাফলগুলি:

primes(1000000)

তবে এটি একটি সাধারণ ম্যাট্রিক্স ট্রান্সপোজ দ্বারা সমাধান করা হয়েছে:

primes(1000000)'

এবং আমি সূচকীয় স্বরলিপি ব্যবহার করে কিছু চরিত্রগুলি কেটে ফেলতে পারি (মন্তব্যে প্রস্তাবিত হিসাবে):

primes(1e6)'
— MBraedley
সূত্র
5
1e6পরিবর্তে ব্যবহার 1000000এখানে খুব সাহায্য করে।
— প্রাচ্য 18
অরিওরেন এটি এটিকে 11 টি অক্ষর তৈরি করবে
— অ্যাকোরেন
@ অ্যাকোরেন যা 'শেষে অন্তর্ভুক্ত করে না
— স্টান স্ট্রাম
20

বাশ (37 টি)

seq 2 1e6|factor|sed 's/.*: //g;/ /d'

(Rs০ টি)

seq 2 1000000|factor|sed -e 's/[0-9]*: //g' -e '/^.* .*$/ d'

আমার কম্পিউটারে (2.0 গিগাহার্টজ সিপিইউ, 2 জিবি র‌্যাম) 14 সেকেন্ড সময় নেয় takes

— saeedn
সূত্র
এটি এতে উন্নত করা যেতে পারে: seq 2 1000000|factor|sed 's/[0-9]*: //g;/^.* .*$/ d'
— ডেলান আজাবানী
হ্যাঁ আপনি ঠিক. আমি আমার সেড কমান্ড পরিষ্কার লিখেছি, গল্ফ করা হয়নি: পি
— সা saদেন
3
seq 1e6|factor|awk '$0=$2*!$3'কিছুটা খাটো
— ডেনিস 23
1
সিক, ফ্যাক্টর এবং সেড বাহ্যিক প্রোগ্রাম, এটি একই সাথে হতে পারে c pযেখানে সি বিড়ালের জন্য একটি সিমিলিংক এবং পি একটি মিলিয়ন পর্যন্ত প্রাইম সহ একটি পাঠ্য ফাইল ... আপনি শেল বিল্টিন দিয়ে এটি করতে পারেন?
— টেকনোসরাস
7
@ টেকনোসরাস seqএবং এতে factorরয়েছে coreutilsতাই এটি বৈধ। sedএছাড়াও বেশ সর্বব্যাপী। coreutilsএকটি অন্তর্নির্মিত মত চিকিত্সা করা যেতে পারে। কোর্টিল ব্যতীত ব্যাশ এসটিএল ছাড়াই সি ++ এর মতো।
16

জে, 21 অক্ষর

1[\p:i.(_1 p:1000000)

যা সংক্ষিপ্ত করা যেতে পারে 

1[\p:i.78498

যদি আপনি জানেন 1000000 এর নীচে কতগুলি প্রাইম রয়েছে।

— গ্যারেথ
সূত্র
2
,.একটি অক্ষর সংরক্ষণ করার জন্য 1 [of এর পরিবর্তে এনফাইল আইটেমগুলি ব্যবহার করা হচ্ছে । অপ্রয়োজনীয় প্রথম বন্ধনী সরান, এবং সূচকীয় স্বরলিপি ব্যবহার করুন: 1e6।
— ওমর
এটি নিয়ে এসেছি: ,.i.&.(p:^:_1)1e6সংক্ষিপ্ত নয় (@ ওমরের পরামর্শগুলি প্রয়োগ করার পরে) তবে আমি এটির অধীনে আকর্ষণীয় ব্যবহারটি পেয়েছি।
— KaoD
10

পাওয়ারশেল, 47 44 বাইট

খুব ধীর, তবে সবচেয়ে সংক্ষিপ্ততম আমিও সামনে আসতে পেরেছি।

$p=2..1e6;$p|?{$n=$_;!($p-lt$_|?{!($n%$_)})}

পাওয়ারশেল, 123 বাইট

এটি অনেক দ্রুত; সর্বোত্তম থেকে অনেক দূরে, তবে দক্ষতা এবং সংকোচনের মধ্যে একটি ভাল সমঝোতা।

 $p=2..1e6;$n=0
 while(1){$p=@($p[0..$n]|?{$_})+($p[($n+1)..($p.count-1)]|?{$_%$p[$n]});$n++;if($n-ge($p.count-1)){break}}
 $p
— Rynant
সূত্র
9

বাশ, 30 বাইট

যেহেতু সাইদেন আমার পরামর্শ অনুযায়ী কাজ করবে না - যা তার পদ্ধতির চেয়েও কম এবং দ্রুত - তাই আমি ভেবেছিলাম আমি নিজের উত্তর পোস্ট করব:

seq 1e6|factor|awk '$0=$2*!$3'

কিভাবে এটা কাজ করে

seq 1e6

1000,000 পর্যন্ত সমস্ত ধনাত্মক পূর্ণসংখ্যা তালিকাভুক্ত করে।

factor

একের পর এক সেগুলি তৈরি করে। প্রথম দশের জন্য, আউটপুটটি নিম্নলিখিত:

1:
2: 2
3: 3
4: 2 2
5: 5
6: 2 3
7: 7
8: 2 2 2
9: 3 3
10: 2 5

অবশেষে,

awk '$0=$2*!$3'

সম্পূর্ণ $0ক্ষেত্রটি () দ্বিতীয় ক্ষেত্রের (প্রথম মৌলিক ফ্যাক্টর) এবং তৃতীয় ক্ষেত্রের যৌক্তিক অবহেলা ( 1যদি এটি একটি মৌলিক ফ্যাক্টর বা তার চেয়ে কম হয় তবে 0) পরিবর্তন করে।

এটি মৌলিক সংখ্যার সাথে সম্পর্কিত লাইনগুলি নিজেই সংখ্যার সাথে এবং অন্য সমস্ত লাইনের সাথে জিরোগুলিকে প্রতিস্থাপন করে। যেহেতু awk কেবল সত্যবাদী মানগুলি প্রিন্ট করে, কেবলমাত্র প্রাথমিক সংখ্যা মুদ্রিত হবে।

— ডেনিস
সূত্র
4
awk '$0=$2*!$3'দারুণ সুন্দর!
— ইয়েতি
8

রুবি 50 41

require'mathn'
p (2..1e6).select &:prime?
— ক্রিশ্চিয়ান লুপাস্কু
সূত্র
2
এর দরকার নেই .to_a, কারণ গণ্যমানের ইতিমধ্যে অন্তর্ভুক্ত রয়েছে select। আপনি আরও ছোট করতে সিম্বল # টু_প্রোকের জন্য শর্টহ্যান্ড স্বরলিপিটি ব্যবহার করতে পারেন : p (2..1e6).select &:prime?(1 প্রধান নয়)
— ভেন্টোরো
@ ভেন্টো অনেক ধন্যবাদ! আমি # টি_প্রোক সিম্বল সম্পর্কে জানতাম না। আমি রুবি অফার শর্টকাটগুলিতে আরও মনোযোগ দিতে চাই।
— ক্রিশ্চিয়ান লুপাস্কু
2
সংক্ষিপ্ত সংস্করণ require'prime';p Prime.take 78498।
— হাউলেথ
@ AsukaszNiemier দুর্দান্ত! আমি মনে করি এটি এত আলাদা যে আপনি এটি আলাদা উত্তর হিসাবে পোস্ট করতে পারেন।
— ক্রিশ্চিয়ান লুপাস্কু
কিছু ভাল ওল 'কান্ট্রি বয় ম্যাথন' এর ভাল ব্যবহার
— ডক্টরহেকল
8

বাশ, 37

আমি আরও যদি গল্ফ করতে পারি ...

এর বেশিরভাগই factorবিশ্রী আউটপুট ফর্ম্যাটটি বিশ্লেষণ করার চেষ্টা করছে।

seq 1e6|factor|grep -oP "(?<=: )\d+$"

আমার মেশিনে সম্পূর্ণ করতে 5.7 বা তাই সেকেন্ড সময় নেয়।

(এমনটি ঘটেছিল যে আমার পোস্টটি উত্তরগুলির দ্বিতীয় পৃষ্ঠায় প্রথম গেছে , তাই কেউ এটি দেখতে পাবে না ...)

পুরানো সমাধান

এটি দীর্ঘ এবং ধীর (10 সেকেন্ড সময় নেয়)।

seq 1e6|factor|egrep ':.\S+$'|grep -oE '\S+$'
2
বাহ - আমি এর factorআগে কখনই পারিনি , তবে কোর্টিলগুলিতে এটি ঠিক আছে!
— ডিজিটাল ট্রমা
1
একটি চরিত্র শেভ করুন: seq 1e6|factor|grep -oP "(?<=: )\d+$"পার্ল-গ্রেপ বর্ণমালার পিছনে
— ডিজিটাল ট্রমা
1
-Pপার্ল-স্টাইলের রেজেক্সগুলি সক্ষম করে। (?<=: )একটি হল ইতিবাচক lookbehind স্ট্রিং এর জন্য ":"। মূলত এটি বলে যে ":" অবশ্যই ম্যাচগুলির আগে আসবে \d+$, তবে এটি ম্যাচের অংশ নয়, সুতরাং -oবিকল্পটি কোলনের পরে কেবল একটি মিলে যাওয়া নম্বর দেয়, যেখানে কেবলমাত্র একটি মাত্র আছে, যেমন প্রাইম রয়েছে সেখানে সংখ্যা দেয়।
— ডিজিটাল ট্রমা
8

পাইথন 3.x: 66 টি অক্ষর rs

for k in range(2,10**6):
 if all(k%f for f in range(2,k)):print(k)

আরও কার্যকর সমাধান: 87 টি অক্ষর

ইরোটোথিনিসের সিভির উপর ভিত্তি করে।

p=[];z=range(2,10**6)
while z:f=z[0];p+=[f];z=[k for k in z if k%f]
for k in p:print(k)
— dan04
সূত্র
1
প্রথমটি ভুল করে প্রিন্ট করে 0এবং 1। পরিবর্তে ব্যবহার করে আপনি এটি ঠিক করতে পারেন range(2,10**6)। এছাড়াও, আমি মনে করি ifবিবৃতিটি বাইরে থেকে আলাদা লাইনে থাকতে হবে forবা আপনি একটি ত্রুটি পান।
— xnor
@ এক্সনর: এটি স্থির করে দিয়েছে।
— dan04
8

হাস্কেল, ৫১

mapM print [n|n<-[2..10^6],all((>0).rem n)[2..n-1]]
— pt2121
সূত্র
আপনি এতে পরিবর্তন mapM_করতে mapMপারেন, ফেরতের মান মুদ্রণ করা হবে না এবং এটি কোড গল্ফ। ;)
— ডগবার্ট
মুদ্রণের পরে এবং (> 0) এ অতিরিক্ত স্থান কেন আছে?
— গর্বিত হাসেল্লার 4:54
চমৎকার ধরা! ধন্যবাদ
— pt2121
আপনি 99 99 9999 কে 10 ^ 6 দিয়ে প্রতিস্থাপন করতে পারেন। এবং দয়া করে আপনার বাইট গণনা আপডেট করুন - 63 সম্ভবত সঠিক হতে পারে না।
— ব্যবহারকারী 2845840
@ ব্যবহারকারী 2845840 ঠিক আছে ধন্যবাদ। ভাল ধারণা!
— pt2121
8

এপিএল, 15

p~,p∘.×p←1↓⍳1e6

আমার দোভাষী মেমরির সমস্যায় পড়েছিলেন তবে এটি তত্ত্বের সাথে কাজ করে।

— TwiNight
সূত্র
কিভাবে? আপনি একটি ডেস্ক্রিপশন দিতে পারেন?
— রাসমাস দামগার্ড নীলসন
আপনি একটি প্রয়োজন ⍪প্রতি লাইনে একটি সংখ্যা তৈরি করতে সামনে, এবং আপনি প্রয়োজন হবে না ,।
— Adám
@RasmusDamgaardNielsen ⍳প্রথম পূর্ণসংখ্যা। 1↓প্রথম এক ড্রপ। p←পি। p∘.×pএকটি গুণ টেবিল তোলে। p~ডানদিকে যা আছে তা পি থেকে সরিয়ে দেয়। ( ,প্রয়োজন নেই, এটি তালিকায় টেবিলটি ছড়িয়ে
— দিচ্ছে
8

পার্ল, 49 বাইট

নিয়মিত অভিব্যক্তি কুংফু :)

for(1..1E6){(1x$_)=~/^(11+?)\1+$/ or print"$_\n"}

অবরুদ্ধ সংস্করণ:

for(1 .. 1_000_000) { 
    (1x$_) =~ /^(11+?)\1+$/ or print "$_\n";
}

এমনকি আমি এই পোস্টটি টাইপ করার সময় এটি 10% অগ্রগতিও করতে পারেনি!

রেজেক্সের জন্য উত্স: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

— Gowtham
সূত্র
2
আমাকে পেরিল version সংস্করণ লিখতে অনুপ্রাণিত করেছিল। এছাড়াও, 1000000লেখা যেতে পারে10**6
— পাবো
1
এছাড়াও, 1000000 লেখা যেতে পারে 1E6
— ভিড়
আমার উত্তর আপডেট। ধন্যবাদ @mob
— Gowtham
সর্বদা আমার পছন্দসই রেজেক্স ছিল, তবে আপনার মনে রাখতে হবে যে আপনি একবারে উচ্চতর সংখ্যায় পৌঁছানোর পরে এটি দর্শনীয়ভাবে ব্যর্থ হয় - কারণ এটি বিশাল সংখ্যাকে অ্যানারিতে রূপান্তরিত করে। এই
— রেজেক্সটি
7

জুলিয়া, 11

primes(10^6)

দেখে মনে হচ্ছে বিল্ট ইনগুলি উপবিষ্ট হচ্ছে এবং আরও উত্তর দেওয়ার জন্য আমার আরও শব্দের দরকার ছিল।

— gggg
সূত্র
7

জে (15 বা 9)

আমি বিশ্বাস করি না যে এই ম্যাথমেটেমিকে বীট করা হয়েছে (এমনকি এটি কেবল ২ টি অক্ষরের দ্বারা একক হলেও )

a#~1 p:a=:i.1e6

বা:

p:i.78498
— ɐɔıʇǝɥʇuʎs
সূত্র
1
... The output format should be one number per line of output.সে কারণেই আমার উত্তরটি শুরু হয় 1[\ ।
— গ্যারেথ
6

জিএস 2, 5 বাইট

সিপি 437 এ এনকোড হয়েছে:

∟)◄lT

1C 29এক মিলিয়ন ধাক্কা দেয়, 11 6Cনীচে প্রাইম 54হয়, শো লাইন।

— লিন
সূত্র
5

গল্ফস্ক্রিপ্ট, 22/20 (20/19) বাইট

n(6?,:|2>{(.p|%-.}do:n

গতির ব্যয়ে, কোডটি দুটি বাইটকে খাটো করা যায়:

n(6?,:|2>.{|%2>-}/n*

যদি সম্পাদিত প্রশ্নে উল্লিখিত আউটপুট ফর্ম্যাটটিকে যদি অবহেলা করা হয় (যা বিদ্যমান উত্তরগুলির বেশিরভাগই তাই করে), দুটি বাইট দ্রুত সংস্করণে সংরক্ষণ করা যায় এবং একটি ধীর ধীরে সংরক্ষণ করা যায়:

n(6?,:|2>{(.p|%-.}do
n(6?,:|2>.{|%2>-}/`

এটি দ্রুত সংস্করণের জন্য প্রাইমগুলির পরে একটি অতিরিক্ত এলএফ মুদ্রণ করবে এবং এটি প্রাইমগুলি ধীর সংস্করণের জন্য অ্যারে হিসাবে মুদ্রণ করবে।

কিভাবে এটা কাজ করে

উভয় সংস্করণ হ'ল ইরোটোস্টিনিসের চালনী কার্যকরকরণ ।

দ্রুত সংস্করণ নিম্নলিখিতগুলি করে:

  1. সেট A = [ 2 3 4 … 999,999 ]এবং | = [ 0 1 2 … 999,999 ]।

  2. সেট N = A[0]এবং মুদ্রণ N।

  3. থেকে n- তম উপাদান সংগ্রহ |মধ্যে C। এগুলো গুণিতক N।

  4. সেট A = A - C।

  5. যদি Aখালি না থাকে তবে 2 এ ফিরে যান।

n(6?   # Push "\n".pop() ** 6 = 1,000,000.
,:|    # Push | = [ 0 1 2 … 999,999 ].
,2>    # Push A = [ 2 3 4 … 999,999 ].
{      #
  (    # Unshift the first element (“N”) of “A”.
  .p   # Print “N”.
  |%   # Collect every N-th element from “A” into a new array, starting with the first.
  -    # Take the set difference of “A” and the array from above.
  .    # Duplicate the set difference.
}do    # If the set difference is non-empty, repeat.
:n     # Store the empty string in “n”, so no final LF will get printed.

ধীর সংস্করণটি একই ধরণের কাজ করে, তবে সর্বনিম্ন "এ" (যা সর্বদা প্রধান) এর গুণকগুলি সরিয়ে দেওয়ার পরিবর্তে এটি সমস্ত ধনাত্মক পূর্ণসংখ্যকে এক হাজারের নীচে সরিয়ে দেয়।

প্রতিযোগিতামূলক

প্রাথমিকতা পরীক্ষা করতে বা পরীক্ষা করার জন্য কোনও অন্তর্নির্মিত গাণিতিক ক্রিয়াকলাপের অভাবে, সমস্ত গল্ফস্ক্রিপ্ট সমাধানগুলি খুব বড় বা খুব অকার্যকর হবে।

দক্ষ হওয়ার থেকে এখনও দূরে থাকা অবস্থায়, আমি মনে করি আমি একটি শালীন গতি থেকে আকারের অনুপাত অর্জন করেছি। জমা দেওয়ার সময়, এই পদ্ধতির সংক্ষিপ্ততম মনে হয় যারা পূর্বোক্ত বিল্ট-ইনগুলির কোনও ব্যবহার করে না। আমি বলেছি বলে মনে হচ্ছে কারণ উত্তরগুলির কয়েকটি কীভাবে কাজ করে তা আমার কোনও ধারণা নেই ...

আমি চারটি জমা দেওয়া গল্ফস্ক্রিপ্ট সমাধানগুলি বেঞ্চমার্ক করেছি: ডাব্লুফিল্ফের (ট্রায়াল বিভাগ), আমার অন্য উত্তর (উইলসনের উপপাদ্য) এবং এই উত্তর দুটি। এই ফলাফল ছিল:

Bound     | Trial division     | Sieve (slow)       | Wilson's theorem | Sieve (fast)
----------+--------------------+--------------------+------------------+----------------
1,000     | 2.47 s             | 0.06 s             | 0.03 s           | 0.03 s
10,000    | 246.06 s (4.1 m)   | 1.49 s             | 0.38 s           | 0.14 s
20,000    | 1006.83 s (16.8 m) | 5.22 s             | 1.41 s           | 0.38 s
100,000   | ~ 7 h (estimated)  | 104.65 (1.7 m)     | 35.20 s          | 5.82 s
1,000,000 | ~ 29 d (estimated) | 111136.97s (3.1 h) | 3695.92 s (1 h)  | 418.24 s (7 m)
— ডেনিস
সূত্র
"ধীর" চালনা কি কেবল ইরোটোথিনিসের চালনী?
— dorukayhan
দুই জন ই. ধীর সংস্করণটি কেবল একটি ভয়াবহ বাস্তবায়ন।
— ডেনিস
4

গল্ফস্ক্রিপ্ট 26 25 24

সম্পাদনা করুন (পিটার টেলরকে আরও একটি চরিত্রের জন্য ধন্যবাদ সংরক্ষণ করা হয়েছে):

10 6?,{:x,{)x\%!},,2=},`

পুরানো কোড:

10 6?,{.,{)\.@%!},,2=*},`

এই কোডটির কেবলমাত্র তাত্ত্বিক মান রয়েছে কারণ এটি অবিশ্বাস্যরূপে ধীর এবং অদক্ষ। আমি মনে করি এটি চালাতে কয়েক ঘন্টা সময় নিতে পারে।

আপনি যদি এটি পরীক্ষা করতে চান তবে উদাহরণস্বরূপ 100 টি পর্যন্ত প্রাইমগুলি চেষ্টা করুন:

10 2?,{:x,{)x\%!},,2=},`
— ক্রিশ্চিয়ান লুপাস্কু
সূত্র
আপনি প্রতিস্থাপন একটি অক্ষর সংরক্ষণ করতে পারবেন \;সঙ্গে *। (আপনি সকলের চেয়ে প্রথম বিভাজকের সন্ধানের মাধ্যমে আপনি বর্তমান চরিত্রের গণনার জন্য আরও দ্রুত গতি পেতে পারেন:10 6?,2>{.),2>{1$\%!}?=},`
— পিটার টেলর
@ পিটারটেলর ধন্যবাদ, গুণ ব্যবহার করে খুব ঝরঝরে কৌশল আছে।
— ক্রিশ্চিয়ান লুপাস্কু
একটি ভেরিয়েবলের সাথে আরও একটি চর সঞ্চয় রয়েছে: এর .,সাথে :x,এবং এর \.@সাথে প্রতিস্থাপন করুন x\ (মন্তব্যে এমডি সহ সমস্যাগুলি ছাঁটাই করার কারণে সাদা অংশ) এবং সরান *।
— পিটার টেলর
@ পিটারটেলর ভাল, ধন্যবাদ! আমি আমার কোড সম্পাদনা করেছি।
— ক্রিশ্চিয়ান লুপাস্কু
4

সিজোম - 11

1e6,{mp},N*

1e6,- 0 ... 999999 এর অ্যারে
{mp},- প্রাইমগুলি নির্বাচন করুন
N*- নতুন লাইনের সাথে যোগ দিন

— aditsu
সূত্র
1
সিজেম কি এই প্রশ্নের চেয়ে সাম্প্রতিক নয়?
— পিটার টেলর
@ পিটারটেলর ওহ, হ্যাঁ
— আদিতু
4

গল্ফস্ক্রিপ্ট, 25 (24) বাইট

!10 6?,2>{.(@*.)@%!},n*\;

সম্পাদিত প্রশ্নে বর্ণিত আউটপুট ফর্ম্যাটটিকে যদি অবহেলা করা হয় তবে একটি বাইট সংরক্ষণ করা যায়:

!10 6?,2>{.(@*.)@%!},`\;

এটি প্রাইমগুলি প্রতি লাইনে একের পরিবর্তে অ্যারে হিসাবে (অন্যান্য অনেকগুলি সমাধানের মতো) মুদ্রণ করবে।

কিভাবে এটা কাজ করে

সাধারণ ধারণাটি হ'ল উইলসনের উপপাদ্যটি ব্যবহার করা , যা বলে যে n > 1 প্রধান এবং যদি কেবলমাত্র

                                                      (এন - 1)! = -1 (মোড এন)

!     # Push the logical NOT of the empty string (1). This is an accumulator.
10 6? # Push 10**6 = 1,000,000.
,2>   # Push [ 2 3 4 … 999,999 ].
{     # For each “N” in this array:
  .(  # Push “N - 1”.
  @   # Rotate the accumulator on top of the stack.
  *   # Multiply it with “N - 1”. The accumulator now hold “(N - 1)!”.
  .)  # Push “(N - 1)! + 1”
  @   # Rotate “N” on top of the stack.
  %!  # Push the logical NOT of “((N - 1)! + 1) % N”.
},    # Collect all “N” for which “((N - 1)! + 1) % N == 0” in an array.
n*    # Join that array by LF.
\;    # Discard the accumulator.

benchmarks

ট্রায়াল বিভাগের চেয়ে দ্রুত, তবে ইরোটোথিনিসের চালনীয়ের চেয়ে ধীর। দেখুন আমার অন্যান্য জবাব ।

— ডেনিস
সূত্র
4

জাভা, 110 বাইট

void x(){for(int i=1;i++<1e6;)System.out.print(new String(new char[i]).matches(".?|(..+?)\\1+")?"":(i+"\n"));}

প্রিমিটিটি টেস্ট হিসাবে রেগেক্সের মাধ্যমে অ্যানারি ডিভিশন ব্যবহার করা।

— অ্যাডিসন ক্রম্প
সূত্র
1
চমৎকার পন্থা। এই প্রাইম-রেজেক্স আগে কখনও দেখেনি। আমার কাছ থেকে +1 যদিও, প্রাইম-চেকিংয়ের জন্য নেস্টেড ফর-লুপ ব্যবহার করা কিছুটা ছোট । :)
— কেভিন ক্রুইজসেন
3

সি, 91 88 85 82 81 80 76 72 টি অক্ষর

main(i,j,b){for(;i++<1e6;b++&&printf("%d\n",i))for(j=2;j<i;)b=i%j++&&b;}

অ্যালগরিদম মারাত্মকভাবে অদক্ষ, তবে যেহেতু আমরা কোড-গল্ফ করছি যে বিষয়টি বিবেচনা করা উচিত নয়।

— গ্যারেথ
সূত্র
1
আপনি এটি সহজেই ছোট করতে পারেন: main(i,j,b){for(;i++<1e6;b++&&printf("%d\n",i))for(j=2;j<i;)b=i%j++&&b;}বা এর মতো কিছু ধারণা (যেহেতু আমি আসলে এটি সংকলন করি নি)
— Ali1S232
i0 হবে কিভাবে নিশ্চিত? আমি মনে করি, আপনি যদি কোনও যুক্তি সরবরাহ করেন তবে এটি ব্যর্থ হবে। এছাড়াও, আমি মনে করি jকিছু ধরণের ত্রুটি থাকবে। bযদিও নিশ্চিত না ।
— এরিক আউটগল্ফার 21
3

গণিত 25

ধরে নিচ্ছি যে আপনি 10 ^ 6 এর চেয়ে কম সংখ্যক প্রাইমসের সংখ্যা জানেন না:

Prime@Range@PrimePi[10^6]
— DavidC
সূত্র
3

জে, 16 অক্ষর

1]\(#~1&p:)i.1e6

আউটপুট বিন্যাসের প্রয়োজনীয়তা ছাড়াই, এটি 13 টির মধ্যে হ্রাস করা যেতে পারে :

(#~1&p:)i.1e6

1]\ কেবল প্রাইমগুলির 1 টি অ্যারে নেয়, এটিকে র‌্যাঙ্ক 2 অ্যারে রূপান্তর করে এবং প্রতিটি প্রাইমকে তার নিজস্ব সারিতে রাখে - এবং তাই অনুবাদকের ডিফল্ট আউটপুট ফর্ম্যাটটি একটি লাইন তালিকাকে প্রতি লাইনে এক মৌলিক করে তোলে।

(#~ f) yমূলত filter, যেখানে fপ্রতিটি উপাদানের জন্য একটি বুলিয়ান দেয় y। i.1e6পূর্ণসংখ্যার পরিসীমা [0,1000000), এবং 1&p:একটি বুলিয়ান ফাংশন যা প্রাইমগুলির জন্য 1 প্রদান করে।

— rationalis
সূত্র
3

আর, 45 43 টি অক্ষর

for(i in 2:1e6)if(sum(!i%%2:i)<2)cat(i," ")

2 থেকে 1e6 পর্যন্ত প্রতিটি সংখ্যার এক্সের জন্য, x মড 2 থেকে x এর সাথে 0 এর সমান সংখ্যা 2 এর চেয়ে কম হলে কেবল আউটপুট করুন।

— plannapus
সূত্র
এই কোড দ্বারা উত্পাদিত প্রথম সংখ্যাটি 1, তবে 1 টি প্রধান নয়।
— সোভেন হোহেনস্টাইন
@ সেনহোহেনস্টেইন ধন্যবাদ, সংশোধন হয়েছে।
— প্ল্যানাপাস
3

বাশ (433643)

আমার (এত চালাক নয়) চেষ্টা ছিল পণ্যকে ফ্যাক্টর করার জন্য ফ্যাক্টরটি ব্যবহার করা।

factor ${PRODUCT}

দুর্ভাগ্যক্রমে বৃহৎ সংখ্যার সাথে পণ্যটি অবশ্যই বিশাল। এটি চালাতে 12 ঘন্টাও বেশি সময় নিয়েছে। যদিও আমি ভেবেছিলাম এটি অনন্য বলে আমি এটি পোস্ট করার সিদ্ধান্ত নিয়েছি।

এখানে সম্পূর্ণ কোড।

এটি ছয় বছরের নিচে প্রাইম হলে এটি যুক্তিসঙ্গত হবে।

  factor 30

ওহ ভাল, আমি চেষ্টা করেছি।

— কেভিন কক্স
সূত্র
+1 এই উত্তরটি সত্যই ডায়াবোলিকাল। একেবারে পূর্বনির্ধারিত ফলাফল নয় (এটি অক্ষরগুলির বেশ কিছুটা সাশ্রয় করে) এবং গণনা করা আরও অনেক ভয়ঙ্কর :) এটি সম্ভবত একটি সম্ভাব্য উদাহরণও যা অনুকূলিতগুলি factorমৌলিক পরীক্ষার বিভাগ অ্যালগরিদমের চেয়ে আরও খারাপ সম্পাদন করে।
— প্রাচ্য
3

সি #, 70

Enumerable.Range(1,1e6).Where(n=>Enumerable.Range(2,n).All(x=>x%n!=0))

আপনি দীর্ঘ সময় ধরে হলেও এখানে খুব বেশি কিছু দেখতে যাচ্ছেন না ...

— It'sNotALie।
সূত্র
এটি ভুল হওয়ার কয়েকটি কারণ রয়েছে। (1) আপনি পরোক্ষভাবে A থেকে রূপান্তর করতে পারবেন না double 1e6একটি থেকে int, কিন্তু intদ্বারা প্রয়োজন বোধ করা হয় Range। (২) অন্তঃস্থলকে Rangeঅবশ্যই বেশিরভাগ n-2পদ গ্রহণ করতে হবে, অন্যথায় আপনি n % nযা পরীক্ষা করবেন তা স্পষ্ট 0। (3) আপনি x%nযখন চান লিখুন n%x। এই সমস্যাগুলির সমাধান করা, এর মতো কিছু কাজ করবে: Enumerable.Range(2,999999).Where(n=>Enumerable.Range(2,n-2).All(x=>n%x!=0))তবে এটি এখনও সংখ্যাগুলি আউটপুট দেয় না; লাইন প্রতি প্রয়োজন ছিল।
— জেপ্পে স্টিগ নীলসেন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.