27

বন্ধ । এই প্রশ্নের বিশদ বা স্পষ্টতা দরকার । এটি বর্তমানে উত্তর গ্রহণ করছে না।

এই প্রশ্নটি উন্নত করতে চান? বিশদ যুক্ত করুন এবং এই পোস্টটি সম্পাদনা করে সমস্যাটি পরিষ্কার করুন ।

গত বছর বন্ধ ছিল ।

বিধিগুলি সহজ:

প্রথম এন মৌলিক (নীচে না primes এন ), মানক আউটপুটে প্রিন্ট করা উচিত নতুন লাইন দিয়ে আলাদা (মৌলিক কোডের ভিতর উত্পন্ন করা উচিত)
প্রাইমগুলি ইনবিল্ট ফাংশন বা একটি লাইব্রেরির মাধ্যমে উত্পন্ন করা যায় না , যেমন ইনবিল্ট বা লাইব্রেরি ফাংশন যেমন প্রাইম = get_nth_prime (এন), is_a_prime (সংখ্যা), বা ফ্যাক্টরলিস্ট = list_all_factors (সংখ্যা) খুব সৃজনশীল হবে না।
স্কোরিং - বলুন, আমরা স্কোর = এফ ([কোডের অক্ষরের সংখ্যা]) সংজ্ঞায়িত করি , হে ( চ (এন)) আপনার অ্যালগরিদমের জটিলতা যেখানে n এটি খুঁজে পাওয়া সংখ্যার সংখ্যা। সুতরাং উদাহরণস্বরূপ, যদি আপনার ও (n ^ 2) জটিলতার সাথে 300 চর কোড থাকে তবে স্কোর 300 (2 900 = 90000) , ও (এন * এলএন (এন)) সহ 300 টি চর জন্য , স্কোর 300 * 5.7 = 1711.13 ( আসুন সমস্ত লগকে সরলতার জন্য প্রাকৃতিক লগ হিসাবে ধরে নেওয়া যাক)
যে কোনও বিদ্যমান প্রোগ্রামিং ভাষা ব্যবহার করুন, সর্বনিম্ন স্কোর জয়

সম্পাদনা করুন: ও (এফ (এন)) এ 'এন' কী, তা নিয়ে বিভ্রান্তির কারণে 'প্রথম 1000000 প্রাইমস' খুঁজে 'ফার্স্ট এন প্রাইমস' করার সমস্যাটি পরিবর্তন করা হয়েছে, এন আপনি যে প্রাইমগুলি খুঁজে পান তা হ'ল (প্রাইম সন্ধান করা হ'ল) এখানে সমস্যা এবং সমস্যার এত জটিলতা খুঁজে পাওয়া সংখ্যার উপর নির্ভর করে)

দ্রষ্টব্য: জটিলতার উপর কিছু বিভ্রান্তি স্পষ্ট করার জন্য, 'এন' যদি আপনি খুঁজে পাওয়া প্রাইমগুলির সংখ্যা এবং 'এন' পাওয়া যায় নবম প্রাইম, এন এর ক্ষেত্রে জটিলতা হয় এবং এন সমান নয় যেমন হে (এফ (এন))! = ও (এফ (এন)) হিসাবে, চ (এন)! = ধ্রুবক * এফ (এন) এবং এন! = ধ্রুবক * এন, কারণ আমরা জানি যে নবম প্রাইম ফাংশন রৈখিক নয়, যদিও আমি 'এন' খুঁজে পেয়েছি প্রাইমস জটিলতা 'এন' এর ক্ষেত্রে সহজেই প্রকাশযোগ্য হওয়া উচিত।

কিব্বির নির্দেশ অনুসারে, আপনার সমাধানগুলি যাচাই করতে আপনি এই সাইটটিতে যেতে পারেন ( এখানে পুরানো গুগল ডক্স তালিকা রয়েছে)

এগুলি আপনার সমাধানগুলিতে অন্তর্ভুক্ত করুন -

আপনার প্রোগ্রামের কী জটিলতা রয়েছে (তুচ্ছ না হলে মূল বিশ্লেষণ অন্তর্ভুক্ত করুন)
কোডের চরিত্রের দৈর্ঘ্য
চূড়ান্ত গণনা করা স্কোর

এটি আমার প্রথম কোডগলফ প্রশ্ন তাই উপরের বিধিগুলিতে যদি কোনও ভুল বা ফাঁক থাকে তবে দয়া করে সেগুলি উল্লেখ করুন।

code-challenge primes

— অপ্টিমাস
সূত্র

5

এটি কোডগলফ.স্ট্যাকেক্সেঞ্জার.কম / সেকশনস /5977/… এর সাথে খুব মিল ।

— গ্যারেথ

2

যে এক জন্য 1[\p:i.78498আমার উত্তর ছিল এই জন্য আমার উত্তর হবে 1[\p:i.1000000। এমনকি ধরে নিও যে জে অভ্যন্তরীণ প্রধান অ্যালগরিদম হে (n ^ 2) আমার স্কোরটি এখনও কেবল 196।

— গ্যারেথ

2

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

— ugoren

3

কে-বিট সংখ্যার জন্য বর্তমান সর্বাধিক জ্ঞাত প্রাথমিকতা পরীক্ষা O-tilde(k^6)। এর ফলে এই বোঝা যায় যে যে কেউ চলমান সময়ের চেয়ে O-tilde(n ln n (ln(n ln n))^6)তার চেয়ে ভাল সময় দাবি করে যে সমস্যার কিছু অংশকে ভুল বোঝে; এবং O-tildeস্কোরিংয়ে কীভাবে জটিলতাগুলি পরিচালনা করা উচিত সেই প্রশ্নে ।

— পিটার টেলর

2

কেউ উল্লেখ করেননি যে ও (এন) জটিলতার ক্ষেত্রে ও (ন) (ধ্রুবক কে জন্য) সমতুল্য, তবে স্কোর পদে নয়। উদাহরণস্বরূপ, ধরুন আমার জটিলতা হ'ল O (n ^ 10)। এটি ও এর সমতুল্য (n ^ 10 * 1E-308), এবং আমি এখনও ভয়ঙ্কর জটিলতার সাথে একটি বিশাল প্রোগ্রামের সাথে চ্যালেঞ্জটি জিততে পারি।

— JDL

10

পাইথন (129 অক্ষর, ও (এন * লগ লগ এন), 203.948 এর স্কোর)

আমি বলব এরিটোস্টেনিসের চালন চলার উপায়। খুব সহজ এবং তুলনামূলক দ্রুত।

N=15485864
a=[1]*N
x=xrange
for i in x(2,3936):
 if a[i]:
  for j in x(i*i,N,i):a[j]=0
print [i for i in x(len(a))if a[i]==1][2:]

আগের থেকে উন্নত কোড

পাইথন ( 191 156 152 চর, ও (এন * লগ লগ এন) (?), 252.620 এর স্কোর (?))

আমি জটিলতাটি মোটেও গণনা করতে পারি না, এটি আমি দিতে পারে সবচেয়ে ভাল অনুমান।

from math import log as l
n=input()
N=n*int(l(n)+l(l(n)))
a=range(2,N)
for i in range(int(n**.5)+1):
 a=filter(lambda x:x%a[i] or x==a[i],a)
print a[:n]

n*int(l(n)+l(l(n)))হয় শীর্ষ সীমানা এর nম মৌলিক সংখ্যা।

— beary605
সূত্র

1

জটিলতা (এবং এইভাবে স্কোর) গণনা উপরের বাউন্ডের উপর ভিত্তি করে nতবে প্রাইমগুলির সংখ্যার ভিত্তিতে নয়। সুতরাং, আমি ধরে নিয়েছি স্কোরটি আরও বেশি হতে হবে। আমার মন্তব্য উপরে দেখুন।

— হাওয়ার্ড

উপরের আবদ্ধ n? ওটা কী?

— beary605

উপরের আবদ্ধ এখানে N=15485864। ভিত্তিক জটিলতার গণনার জন্য n=1000000, আপনি বলতে পারেন N=n*log(n)(প্রাইমগুলির ঘনত্বের কারণে)।

— উগোরেন

যদি আমার স্কোরটি স্থির করার দরকার হয় তবে দয়া করে আমার জন্য এটি ঠিক করুন, আমার এখনও স্কোরিং সিস্টেম সম্পর্কে ভাল ধারণা নেই।

— beary605

@ beary605 যদি আমি প্রথম এন প্রাইমগুলি খুঁজে পেতে সমস্যাগুলি সংশোধন করি তবে ঠিক হবে? এটি জটিলতার উপর অনেক বিভ্রান্তির সমাধান করবে এবং ও (এফ (এন)) এ কী রয়েছে

— অপ্টিমাস

7

হাস্কেল, এন ^ 1.1 অভিজ্ঞতামূলক বৃদ্ধি হার, 89 টি চর, স্কোর 139 (?)

নীচেরগুলি GHCi প্রম্পটে কাজ করে যখন এটি ব্যবহার করে এমন সাধারণ গ্রন্থাগারটি আগে লোড করা হয়েছিল। এন- তম প্রাইম, 1-ভিত্তিক মুদ্রণ করুন :

let s=3:minus[5,7..](unionAll[[p*p,p*p+2*p..]|p<-s])in getLine>>=(print.((0:2:s)!!).read)

অর্ডার তালিকাগুলির জন্য সাধারণ-ব্যবহারের লাইব্রেরি ব্যবহার করে এটি ইরোটোস্টিনিসের সীমাহীন চালনী। 100,000 এবং 200,000 মৌলিক মধ্যে গবেষণামূলক জটিলতা O(n^1.1)। ফিট O(n*log(n)*log(log n))।

জটিলতার অনুমান সম্পর্কে

আমি 100k এবং 200k প্রাইমগুলির জন্য রান সময় পরিমাপ করেছিলাম, তারপরে গণনা করা হয় logBase 2 (t2/t1), যা উত্পাদন করে n^1.09। সংজ্ঞা g n = n*log n*log(log n), গণনা logBase 2 (g 200000 / g 100000)দেয় n^1.12।

তারপর, 89**1.1 = 139যদিও g(89) = 600। --- (?)

দেখে মনে হচ্ছে স্কোর করার জন্য অনুমানযোগ্য বৃদ্ধির হারকে জটিলতার ফাংশনের পরিবর্তে ব্যবহার করা উচিত। উদাহরণস্বরূপ, এর g2 n = n*((log n)**2)*log(log n)চেয়ে অনেক ভাল n**1.5তবে 100 টি চর জন্য যথাক্রমে দুটি উত্পাদন স্কোর 3239এবং 1000। এটা ঠিক হতে পারে না। 200k / 100k রেঞ্জের উপর অনুমান দেয় logBase 2 (g2 200000 / g2 100000) = 1.2এবং এইভাবে স্কোর করে 100**1.2 = 251।

এছাড়াও, আমি সমস্ত প্রাইমগুলি মুদ্রণ করার চেষ্টা করি না, পরিবর্তে কেবল এন- থাইম প্রাইম।

কোনও আমদানি নেই, 240 টি অক্ষর। n ^ 1.15 অভিজ্ঞতা অভিজ্ঞতা বৃদ্ধি, স্কোর 546।

main=getLine>>=(print.s.read)
s n=let s=3:g 5(a[[p*p,p*p+2*p..]|p<-s])in(0:2:s)!!n
a((x:s):t)=x:u s(a$p t)
p((x:s):r:t)=(x:u s r):p t
g k s@(x:t)|k<x=k:g(k+2)s|True=g(k+2)t
u a@(x:r)b@(y:t)=case(compare x y)of LT->x:u r b;EQ->x:u r t;GT->y:u a t

— নেস
সূত্র

5

হাস্কেল, 72 89 অক্ষর, ও (এন ^ 2), স্কোর 7921

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

অনুযায়ী উইল নেস নীচে একটি পূর্ণ Haskell, প্রোগ্রাম নয় (এটা আসলে REPL উপর নির্ভর)। নীচে একটি সিউডো-চালুনি সহ আরও একটি সম্পূর্ণ প্রোগ্রাম রয়েছে (আমদানিগুলি আসলে একটি চর সংরক্ষণ করে তবে কোড গল্ফে আমদানি অপছন্দ করি)।

main=getLine>>= \x->print.take(read x).(let s(x:y)=x:s(filter((>0).(`mod`x))y)in s)$[2..]

এই সংস্করণটি নিঃসন্দেহে (n ^ 2)। অ্যালগরিদম হ'ল নিষ্পাপ `ieve চালুনি '' এর একটি গল্ফ সংস্করণ, এখানে দেখা গেছে ওল্ড জিসিসি 1 লাইনার

getLine>>= \x->print.take(read x)$Data.List.nubBy(\x y->x`mod`y==0)[2..]

পুরানো, প্রতারণামূলক উত্তরটি ছেড়ে দেওয়া কারণ এটি যে লাইব্রেরির সাথে লিঙ্ক করেছে এটি বেশ সুন্দর।

print$take(10^6)Data.Numbers.Primes.primes

বাস্তবায়নের জন্য এবং সময় জটিলতার জন্য লিঙ্কগুলি এখানে দেখুন । দুর্ভাগ্যক্রমে চাকাগুলির একটি লগ (এন) দেখার সময় থাকে যা আমাদেরকে একটি ফ্যাক্টর দ্বারা কমিয়ে দেয়।

— walpen
সূত্র

• প্রাইমগুলি ইনবিল্ট ফান্টন বা একটি লাইব্রেরির মাধ্যমে তৈরি করা যায় না

— beary605

@ ওয়ালপেন আমি দুঃখিত দুঃখিত, আমি বিজ্ঞপ্তি ছাড়াই নিয়মগুলি সংশোধন করেছি, দয়া করে আপনি উপযুক্ত হিসাবে দেখুন পরিবর্তনগুলি করুন

— অপ্টিমাস

জটিলতা কি ও ((এন ln এন) ^ 1.5 এলএন (এন এলএন এন) ^ 0.585) এর মতো কিছু হবে না? (অথবা হে ((এনএলএন এন) ^ 1.5 এলএন (এনএলএন এন)) যদি হাস্কেল কৃত্তসুবা হিসাবে ধরে নিয়েছেন, বরং ভদ্র বিভাজন ব্যবহার করে)

— পিটার টেলর

না, কারণ এটি আমাকে ভয়ঙ্কর স্কোর দেয়: /। তবে আমি নিশ্চিত আপনি ঠিক বলেছেন। এটি কেবল বিচার বিভাগের মতো দেখায় এবং এটিই সময় বিভাগের জটিলতা (সম্ভবত, সম্ভবত কোনও ভুল উত্স সম্পর্কে আমার খারাপ পাঠ্য অনুধাবন অনুসারে) তাই আমি এটি বেছে নিয়েছি। আপাতত আমি আমার স্কোরকে NaN বলব, এটি নিরাপদ বলে মনে হচ্ছে।

— ওয়ালপেইন

আমি ধরে নিচ্ছি (আমার হাস্কেল নগণ্য, তবে আমি জানি এটি এসএমএলে করা কীভাবে স্বাভাবিক হবে ...) আপনি কেবল ছোট প্রাইম দ্বারা ট্রায়াল বিভাগ করছেন, যে ক্ষেত্রে পি-তে ট্রায়াল ডিভিশন ও হয় ( পি ^ 0.5 / ln পি) বিভাগগুলি। তবে যদি পি-কে বিট থাকে, একটি বিভাগে ও (কে ^ 1.585) (করাতসুবা) বা ও (কে ^ 2) (ভীরু) সময় নেয় এবং আপনাকে O (n lg n) দৈর্ঘ্যের O (ln ( n lg n)) বিট।

— পিটার টেলর

5

সি #, 447 অক্ষর, বাইট 452, স্কোর?

using System;namespace PrimeNumbers{class C{static void GN(ulong n){ulong primes=0;for (ulong i=0;i<(n*3);i++){if(IP(i)==true){primes++;if(primes==n){Console.WriteLine(i);}}}}static bool IP(ulong n){if(n<=3){return n>1;}else if (n%2==0||n%3==0){return false;}for(ulong i=5;i*i<=n;i+=6){if(n%i==0||n%(i+2)==0){return false;}}return true;}static void Main(string[] args){ulong n=Convert.ToUInt64(Console.ReadLine());for(ulong i=0;i<n;i++){GN(i);}}}}

স্ক্রিপ্টস ভেরিয়েন্ট, 381 টি অক্ষর, 385 বাইট, স্কোর?

using System;static void GetN(ulong n){ulong primes=0;for (ulong i=0;i<(n*500);i++){if(IsPrime(i)==true){primes++;if(primes==n){Console.WriteLine(i);}}}}public static bool IsPrime(ulong n){if(n<=3){return n>1;}else if (n%2==0||n%3==0){return false;}for(ulong i=5;i*i<=n;i+=6){if(n%i==0||n%(i+2)==0){return false;}}return true;}ulong n=Convert.ToUInt64(Console.ReadLine());for(ulong i=0;i<n;i++){GetN(i);}

আপনি যদি স্ক্রিপ্টস ইনস্টল করেন তবে এটি চালাতে পারবেন।

পিএস আমি ভিম এ লিখেছি :D

— XiKuuKy
সূত্র

2

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

— প্রোগ্রামএফক্স

2

ওহ ধন্যবাদ, এটি আমার প্রথম কোডগল্ফ!

— XiKuuKy

4

গল্ফস্ক্রিপ্ট (45 টি অক্ষর, স্কোর দাবি করেছে ~ 7708)

~[]2{..3${1$\%!}?={.@\+\}{;}if)1$,3$<}do;\;n*

এটি প্রাইমস দ্বারা সাধারণ ট্রায়াল বিভাগ করে। রুবির কাটিয়া প্রান্তের নিকটে (অর্থাত্ 1.9.3.0 ব্যবহার করে) গাণিতিকগুলি টুম-কুক 3 গুণটি ব্যবহার করে, সুতরাং একটি পরীক্ষামূলক বিভাগ হ'ল (এন ^ 1.465) এবং বিভাগগুলির সামগ্রিক ব্যয় O((n ln n)^1.5 ln (n ln n)^0.465) = O(n^1.5 (ln n)^1.965)† † তবে গল্ফস্ক্রিপ্টে অ্যারেতে একটি উপাদান যুক্ত করতে অ্যারের অনুলিপি করা দরকার। প্রাইমগুলির তালিকাটি অনুলিপি করার জন্য আমি এটি অনুকূলিত করেছি যখন এটি কোনও নতুন প্রাইমকে খুঁজে পায়, কেবলমাত্র nমোটবার। প্রতিটি কপি অপারেশন O(n)আকারের আইটেম O(ln(n ln n)) = O(ln n)† দান, O(n^2 ln n)।

এবং এটি, ছেলেরা এবং মেয়েরা, এজন্য গল্ফস্ক্রিপ্ট গুরুতর প্রোগ্রামিংয়ের চেয়ে গল্ফিংয়ের জন্য ব্যবহৃত হয়।

† O(ln (n ln n)) = O(ln n + ln ln n) = O(ln n)। বিভিন্ন পোস্টে মন্তব্য করার আগে আমার এই স্পট করা উচিত ছিল ...

— পিটার টেলর
সূত্র

4

এটি খুব সহজ এমনকি আমার পাঠ্য সম্পাদকও এটি করতে পারেন!

ভিম: 143 কীস্ট্রোক (115 ক্রিয়া): ও (n ^ 2 * লগ (এন)): স্কোর: 101485.21

জমা:

qpqqdqA^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"ddmpqdmd"bywo^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc>0*w*wyiWdd@0qqpmp"aywgg@dqgg@p

ইনপুট: এন খালি নথির প্রথম লাইনে থাকা উচিত। এটি শেষ হওয়ার পরে, 2 থেকে N পর্যন্ত প্রতিটি প্রধান পৃথক লাইন হবে।

কমান্ডগুলি পরিচালনা:

প্রথমে নোট করুন যে তাদের সামনে ক্যারেটের সাথে কোনও কমান্ডের অর্থ হল আপনাকে সিটিআরএল ধরে রাখা উচিত এবং পরবর্তী অক্ষরটি টাইপ করতে হবে (যেমন ^ ভি হয় Ctrl-vএবং ^ আর হয় Ctrl-r)।

এটি আপনার @a, @b, @d, এবং @p রেজিস্টারগুলিতে যে কোনও কিছু ওভাররাইট করবে।

কারণ qএটি কমান্ড ব্যবহার করে, এটি কেবল ম্যাক্রোতে রাখা যাবে না। তবে এটি চালানোর জন্য এখানে কয়েকটি টিপস।

qpqqdq শুধু রেজিস্টার সাফ করে
A^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"dd2 থেকে N + 1 নম্বরগুলির তালিকা তৈরি করবে। এটি দুটি প্রধান অংশের মধ্যে বিরতি, সুতরাং এটি একবার হয়ে গেলে, আপনার এটি আর করা উচিত নয়
mpqdmd"bywo^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc>0*w*wyiWdd@0qqpmp"aywgg@dqgg@pএকবারে টাইপ করা দরকার। ব্যাকস্পেস এড়ানোর চেষ্টা করুন কারণ এতে কিছু সমস্যা হতে পারে।
- আপনি যদি ভুল করে থাকেন qdqqpqতবে টাইপ করে আবার এই লাইনটি ব্যবহার করে দেখুন।

বড় এন এর জন্য এটি খুব ধীর slow এন = 5000 চালাতে প্রায় 27 মিনিট সময় লেগেছে; নিজেকে সতর্ক করে বিবেচনা করুন

অ্যালগরিদম:

এটি প্রাইমগুলি সন্ধানের জন্য একটি প্রাথমিক পুনরাবৃত্তির অ্যালগরিদম ব্যবহার করে। 1 এবং A এর মধ্যে সমস্ত প্রাইমগুলির একটি তালিকা দেওয়া হয়েছে, প্রাইম তালিকার কোনও সংখ্যার দ্বারা বিভাজ্য না হলে এ + 1 প্রাইম। এ = 2 থেকে শুরু করুন এবং প্রাইমগুলি পাওয়া গেলে সেগুলি তালিকায় যুক্ত করুন। এন পুনরাবৃত্তির পরে, তালিকায় এন পর্যন্ত সমস্ত প্রাইম থাকবে will

জটিলতা

এই অ্যালগরিদমে ও (এনএন) এর একটি জটিলতা রয়েছে, যেখানে এন ইনপুট নম্বর এবং এন এন পর্যন্ত প্রাইমগুলির সংখ্যা Each

যাইহোক, এন ~ n * লগ (এন), ও (এন ² * লগ (এন)) হিসাবে চূড়ান্ত জটিলতা দেয় ( https://en.wikedia.org/wiki/Prime_number_theorem# অ্যাপ্লিক্সিমেশনস_স_এই_এন্টি_প্রাইম_নিবার )

ব্যাখ্যা

ভিএম কমান্ডগুলি থেকে প্রোগ্রামের প্রবাহটি সনাক্ত করা সহজ নয়, সুতরাং আমি একই প্রবাহটি অনুসরণ করে পাইথনে এটি পুনরায় লিখেছি। ভিম কোডের মতো পাইথন কোডটি শেষের দিকে পৌঁছলে ত্রুটি ঘটবে। পাইথন খুব বেশি পুনরাবৃত্তি পছন্দ করে না; আপনি যদি এই কোডটি N> 150 বা আরও কিছু দিয়ে চেষ্টা করেন তবে এটি সর্বাধিক পুনরাবৃত্তির গভীরতায় পৌঁছে যাবে

N = 20
primes = range(2, N+1)

# Python needs these defined.
mark_p = b = a = -1

# Check new number for factors. 
# This macro could be wrapped up in @d, but it saves space to leave it separate.
def p():
    global mark_d, mark_p, primes, a
    mark_d = 0
    print(primes)
    a = primes[mark_p]
    d()      

# Checks factor and determine what to do next
def d():
    global mark_d, mark_p, a, b, primes
    b = primes[mark_d]
    if(a == b): # Number is prime, check the next number
        mark_p += 1
        p()
    else:
        if(a%b == 0): # Number is not prime, delete it and check next number
            del(primes[mark_p])
            p()
        else: # Number might be prime, try next possible factor
            mark_d += 1
            d()

mark_p = 0 #Start at first number         
p()

এখন, আসল কীস্ট্রোকগুলি ভেঙে ফেলার জন্য!

qpqqdq@ D এবং @p রেজিস্টারগুলি সাফ করে। এই পুনরাবৃত্তির ম্যাক্রোগুলি সেট আপ করার সময় কোনও কিছুই রান না হওয়া নিশ্চিত করবে।
A^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"ddইনপুটটিকে 2 থেকে N + 1 এ সংখ্যার তালিকায় পরিণত করে। N + 1 এন্ট্রি @ ডি ম্যাক্রো সেট আপ করার পার্শ্ব প্রতিক্রিয়া হিসাবে মোছা হয়েছে।
- বিশেষত, একটি ম্যাক্রো লিখুন যা একটি সংখ্যা বাড়িয়ে তোলে, তারপরে এটি পরবর্তী লাইনে অনুলিপি করে, তারপরে এটি একটি 1 লিখে এবং এই ম্যাক্রো এন বার কার্যকর করে।
mpqdmd"bywo^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc>0*w*wyiWdd@0q@d ম্যাক্রো লিখেছেন, যা উপরের d () ফাংশনটি প্রয়োগ করে। "যদি" বিবৃতিগুলি ভিমে প্রয়োগ করা আকর্ষণীয়। অনুসন্ধান অপারেটর * ব্যবহার করে, অনুসরণ করার জন্য কোনও নির্দিষ্ট পথ বেছে নেওয়া সম্ভব। কমান্ডটি আরও ভেঙে আমরা আরও পেতে পারি
- mpqdপি চিহ্নটি এখানে সেট করুন এবং @ ডি ম্যাক্রো রেকর্ডিং শুরু করুন। পি চিহ্ন সেট করা দরকার তাই এই রানগুলি হিসাবে ঝাঁপ দেওয়ার জন্য একটি পয়েন্ট রয়েছে
- o^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc> যদি / অন্য বিবৃতি পাঠ্য লেখেন
- 0*w*wyiWdd@0 আসলে if স্টেটমেন্টটি কার্যকর করে।
- এই আদেশটি কার্যকর করার আগে, লাইনটি থাকবে will @a @b 0 0 `pj@p @a 0 (@a%@b) `pdd@p 0 `dj@d
- 0 কার্সারটিকে লাইনের শুরুতে সরানো হয়
- *w*w পরবর্তীটি সম্পাদন করতে কোডটিতে কার্সারটি সরানো হয়
  1. যদি @a == @ বি, এটি `pj@p, যা @a এর জন্য পরবর্তী সংখ্যাতে চলে যায় এবং এটিতে @p চালায়।
  2. যদি @a! = @ বি এবং @ a% @ b == 0 `pdd@p, যা বর্তমান নম্বর @ এ মুছে দেয়, তারপরে পরবর্তী একটিতে @ পি চালায়।
  3. যদি @a! = @ বি এবং @ a %% বি! = 0, যা @ বি `dj@dএর পরবর্তী সংখ্যাটি এটি @a এর একটি ফ্যাক্টর কিনা তা দেখার জন্য এটি পরীক্ষা করে
- yiWdd@0 0 টি রেজিস্টারে কমান্ডটি yanks, লাইনটি মুছে ফেলে এবং কমান্ডটি চালায় runs
- q @ ম্যাক্রোর রেকর্ডিং শেষ করে
এটি যখন প্রথম চালানো হবে তখন `pdd@pকমান্ডটি চালানো হবে, এন + 1 লাইনটি মুছে ফেলবে।
qpmp"aywgg@dq @p ম্যাক্রো লিখেছেন, যা কার্সারের নীচে সংখ্যাটি সংরক্ষণ করে, তারপরে প্রথম প্রবেশে যায় এবং এটিতে @d চালায় runs
gg@p আসলে @ পি কার্যকর করে যাতে এটি পুরো ফাইলটিতে পুনরাবৃত্তি হয়।

— ডমিনিক এ।
সূত্র

3

কিউবিসিক, 98 টি চর, জটিলতা এন স্ক্র্যাট (এন), স্কোর 970

I=1
A:I=I+2
FOR J=2 TO I^.5
    IF I MOD J=0 THEN GOTO A
NEXT
?I
K=K+1
IF K=1e6 THEN GOTO B
GOTO A
B:

— Kibbee
সূত্র

আমি সমস্যার বিবৃতিটি কিছুটা সংশোধন করেছি, এটি এখন প্রথম 'এন' প্রাইমগুলি খুঁজে পেয়েছি, কোনও বিজ্ঞপ্তির জন্য আমি দুঃখিত

— অপটিমাস

আমি মনে করি আমরা এই প্রোগ্রামটির জন্য "ইন-উত্স" ইনপুট ধরে নিতে পারি; অর্থাত্, ইনপুটটি হ'ল অঙ্কের পরে IF K=(সুতরাং প্রোগ্রামের দৈর্ঘ্যে অঙ্কটি অন্তর্ভুক্ত হবে না)। এটি যেমন দাঁড়িয়েছে, প্রোগ্রামটি 2 টি সহ প্রথম এন প্রাইমগুলি মুদ্রণ করে যা ?2শুরুতে যুক্ত করে এবং এতে পরিবর্তন করে স্থির K=...করা যায় K=...-1। প্রোগ্রাম থেকে বের স্পেস গ্রহণ করে একটু golfed যাবে J=2 TO, J=0 THEN, K=...-1 THEN, এবং ইন্ডেন্টিং সরিয়ে। আমি বিশ্বাস করি এটি একটি 96-চরিত্রের প্রোগ্রামে ফলাফল করে।

— মাঝামাঝি

3

স্কেল 263 টি অক্ষর

নতুন প্রয়োজনীয়তার সাথে মানিয়ে নিতে আপডেট হয়েছে। কোডের 25% নীচে নীচে প্রাইমগুলি গণনা করার জন্য একটি যুক্তিসঙ্গত আপার সীমাবদ্ধ সন্ধানের সাথে ডিল করে।

object P extends App{
def c(M:Int)={
val p=collection.mutable.BitSet(M+1)
p(2)=true
(3 to M+1 by 2).map(p(_)=true)
for(i<-p){
var j=2*i;
while(j<M){
if(p(j))p(j)=false
j+=i}
}
p
}
val i=args(0).toInt
println(c(((math.log(i)*i*1.3)toInt)).take(i).mkString("\n"))
}

আমি একটি চালনি পেয়েছি।

বিশ্লেষণের জন্য নিখরচায় গণনা ব্যয়ের একটি পরীক্ষামূলক পরীক্ষা এখানে দেওয়া হয়েছে:

object PrimesTo extends App{
    var cnt=0
    def c(M:Int)={
        val p=(false::false::true::List.range(3,M+1).map(_%2!=0)).toArray
        for (i <- List.range (3, M, 2)
            if (p (i))) {
                var j=2*i;
                while (j < M) {
                    cnt+=1
                    if (p (j)) 
                        p(j)=false
                    j+=i}
            }
        (1 to M).filter (x => p (x))
    }
    val i = args(0).toInt
    /*
        To get the number x with i primes below, it is nearly ln(x)*x. For small numbers 
        we need a correction factor 1.13, and to avoid a bigger factor for very small 
        numbers we add 666 as an upper bound.
    */
    val x = (math.log(i)*i*1.13).toInt+666
    println (c(x).take (i).mkString("\n"))
    System.err.println (x + "\tcount: " + cnt)
}
for n in {1..5} ; do i=$((10**$n)); scala -J-Xmx768M P $i ; done

নিম্নলিখিত গণনা বাড়ে:

List (960, 1766, 15127, 217099, 2988966)

আমি কীভাবে স্কোর গণনা করব তা নিশ্চিত নই। এটি আরও 5 টি চরিত্র লেখার মূল্য?

scala> List(4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534).map(x=>(math.log(x)*x*1.13).toInt+666) 
res42: List[Int] = List(672, 756, 1638, 10545, 100045, 1000419, 10068909, 101346800, 1019549994)

scala> List(4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534).map(x=>(math.log(x)*x*1.3)toInt) 
res43: List[Int] = List(7, 104, 1119, 11365, 114329, 1150158, 11582935, 116592898, 1172932855)

বড় এন এর জন্য এটি এই পরিসরে প্রায় 16% গণনা হ্রাস করে, তবে স্কোর সূত্রের জন্য আফিক, আমরা ধ্রুবক উপাদানগুলি বিবেচনা করি না?

নতুন বিগ-ও বিবেচনাগুলি:

1 000, 10 000, 100,000 প্রাইমস এবং আরও খুঁজে পেতে, আমি প্রাইমগুলির ঘনত্ব সম্পর্কে একটি সূত্র ব্যবহার করি x => (গণিত.লগ (এক্স) * x * 1.3 যা আমি চালিত বাইরের লুপটি নির্ধারণ করে।

সুতরাং মানগুলির জন্য আমি 1 থেকে 6 => এনপ্রাইমস (10 ^ i) 9399, 133768 ... বাইরের লুপের বার চলে runs

আমি এই ও-ফাংশনটি পুনরাবৃত্তভাবে পিটার টেলরের মন্তব্যে পেয়েছি, যারা এক্সফেনশনেশনের জন্য অনেক বেশি মূল্য প্রস্তাব করেছিল, তার পরিবর্তে 1.01 তিনি 1.5 পরামর্শ করেছিলেন:

def O(n:Int) = (math.pow((n * math.log (n)), 1.01)).toLong

ও: (এন: ইন্ট) দীর্ঘ

val ns = List(10, 100, 1000, 10000, 100000, 1000*1000).map(x=>(math.log(x)*x*1.3)toInt).map(O)

এনএস: তালিকা [দীর্ঘ] = তালিকা (102, 4152, 91532, 1612894, 25192460, 364664351)

 That's the list of upper values, to find primes below (since my algorithm has to know this value before it has to estimate it), send through the O-function, to find similar quotients for moving from 100 to 1000 to 10000 primes and so on: 

(ns.head /: ns.tail)((a, b) => {println (b*1.0/a); b})
40.705882352941174
22.045279383429673
17.62109426211598
15.619414543051187
14.47513863274964
13.73425213148954

এটি উদ্ধৃতি হিসাবে যদি আমি 1.01 ব্যবহারকারীর হিসাবে ব্যবহার করি। এখানে কাউন্টারটি অভিজ্ঞতাকে খুঁজে পেয়েছে:

ns: Array[Int] = Array(1628, 2929, 23583, 321898, 4291625, 54289190, 660847317)

(ns.head /: ns.tail)((a, b) => {println (b*1.0/a); b})
1.799140049140049
8.051553431205189
13.649578085909342
13.332251210010625
12.65003116535112
12.172723833234572

প্রথম দুটি মান হ'ল বিদেশী, কারণ আমি ক্ষুদ্র মানের (1000 অবধি) জন্য আমার অনুমানের সূত্র ধরে ধ্রুবক সংশোধন করেছি।

পিটার টেলররা 1.5 এর পরামর্শের সাথে এটির মতো দেখতে পাবেন:

245.2396265560166
98.8566987153728
70.8831374743478
59.26104390040363
52.92941829568069
48.956394784317816

এখন আমার মূল্য দিয়ে আমি:

O(263)
res85: Long = 1576

তবে আমি নিশ্চিত নই, আমি আমার ও-ফাংশনটি পর্যবেক্ষণকৃত মানগুলির সাথে কতটা কাছে আসতে পারি।

— অজানা ব্যবহারকারী
সূত্র

দুঃখিত জটিলতার সাথে সম্পর্কিত কিছু অস্পষ্টতা হ্রাস করার জন্য আমি সমস্যার বিবৃতিতে কিছু পরিবর্তন করেছি, (আমি নিশ্চিত যে আপনার সমাধানটি খুব বেশি বদলাবে না)

— অপ্টিমাস

এটি প্রাইমস দ্বারা কার্যকরভাবে বিভাগ বিভাজন। অভ্যন্তরীণ লুপের মাধ্যমে বারের সংখ্যা O(M^1.5 / ln M)এবং আপনার মাধ্যমে প্রতিটি সময় O(ln M)কাজ (সংযোজন) করা হয়, তাই সামগ্রিকভাবে এটি O(M^1.5) = O((n ln n)^1.5)।

— পিটার টেলর

^ 1.5 এর পরিবর্তে ^ 1.02 এর সাথে def O(n:Int) = (math.pow((n * math.log (n)), 1.02)).toLongআমি মানগুলির আরও কাছাকাছি যাই, আমার কাউন্টারটির সাথে অভিজ্ঞতার সাথে পাওয়া যায়। আমি আমার পোস্টে আমার অনুসন্ধানগুলি .োকান।

— ব্যবহারকারী অজানা

3

রুবি 66 টি অক্ষর, হে (n ^ 2) স্কোর - 4356

lazyরুবি ২.০ থেকে পাওয়া যায় এবং 1.0/0এটি অসীম পরিসর পাওয়ার জন্য দুর্দান্ত কৌশল:

(2..(1.0/0)).lazy.select{|i|!(2...i).any?{|j|i%j==0}}.take(n).to_a

— উরি আগাসি
সূত্র

1

আপনি একটি চর এটিকে পরিবর্তন করে শেভ করতে পারেন(2..(1.0/0)).lazy.select{|i|!(2...i).any?{|j|i%j<1}}.take(n).to_a

— Qqwy

বা এমনকি: (এটি সমাধানটিকে কম দক্ষ করে তোলে তবে এটি ওপরের ও (N²) সীমা পরিবর্তন করে না) (2..(1.0/0)).lazy.select{|i|(2..i).one?{|j|i%j<1}}.take(n).to_a। এটি আরও দুটি চরিত্রকে ছাঁটাই করে দেয়।

— কিউকিউই

এটিতে ভাল পরিবর্তন করলে (2..(1.0/0)).lazy.select{|i|!(2...i).any?{|j|i%j<1}}.first(n)61 টি অক্ষর আসবে।

— রিচি

2

রুবি, ৮৪ টি চর, ৮৪ বাইট, স্কোর?

এটি সম্ভবত এই অংশগুলির জন্য কিছুটা নববধূ, তবে আমি এটি করার জন্য বেশ মজা পেয়েছি। এটি কেবলমাত্র লুপ হয় যতক্ষণ না f(প্রাইমগুলি পাওয়া যায়) সমান হয় n, পছন্দসই প্রাইমগুলির সন্ধান করা যায়।

মজাদার অংশটি হ'ল প্রতিটি লুপের জন্য এটি পরিদর্শন করা সংখ্যার চেয়ে 2 থেকে এক কম এ্যরে তৈরি করে। তারপরে এটি অ্যারের প্রতিটি উপাদানকে মূল সংখ্যা এবং উপাদানটির মডুলাস হিসাবে মানচিত্র করে এবং ফলাফলগুলির কোনও শূন্য কিনা তা পরীক্ষা করে দেখুন।

এছাড়াও, এটি কীভাবে স্কোর করতে হয় সে সম্পর্কে আমার কোনও ধারণা নেই।

হালনাগাদ

কোড কম্প্যাক্ট এবং এর জন্য একটি (সম্পূর্ণ স্বেচ্ছাচারিত) মান অন্তর্ভুক্ত n

n,f,i=5**5,0,2
until f==n;f+=1;p i if !(2...i).to_a.map{|j|i%j}.include?(0);i+=1;end

মূল

f, i = 0, 2
until f == n
  (f += 1; p i) if !(2...i).to_a.map{|j| i % j}.include?(0)
  i += 1
end

i += 1বিট এবং untilলুপ উন্নতির জন্য এলাকাসমূহ হিসাবে আমার দিকে লাফিয়ে সাজানোর, কিন্তু এই ট্র্যাক উপর আমি আটকে সাজানোর আছি। যাইহোক, এটি সম্পর্কে মজা ছিল।

— tydotg
সূত্র

2

স্কালা, 124 টি অক্ষর

object Q extends App{Stream.from(2).filter(p=>(2 to p)takeWhile(i=>i*i<=p)forall{p%_!= 0})take(args(0)toInt)foreach println}

বর্গমূল পর্যন্ত সহজ পরীক্ষার বিভাগ। জটিলতা সুতরাং O (n ^ (1.5 + অ্যাপসিলন) হওয়া উচিত

124 ^ 1.5 <1381, সুতরাং এটি আমার অনুমান হবে?

— জীন
সূত্র

1

পার্ল - 94 টি অক্ষর, হে (এন লগ (এন)) - স্কোর: 427

perl -wle '$n=1;$t=1;while($n<$ARGV[0]){$t++;if((1x$t)!~/^1?$|^(11+?)\1+$/){print $t;$n++;}}'

পাইথন - 113 টি অক্ষর

import re
z = int(input())
n=1
t=1
while n<z:
    t+=1
    if not re.match(r'^1?$|^(11+?)\1+$',"1"*t):
        print t
        n+=1

— alfasin
সূত্র

1

এডাব্লুকে, 96 86 বাইট

সাবটাইটেল: দেখো মা! শুধু যুক্ত এবং কিছু বুককিপিং!

ফাইল fsoe3.awk:

{for(n=2;l<$1;){if(n in L)p=L[n]
else{print p=n;l++}
for(N=p+n++;N in L;)N+=p
L[N]=p}}

চালান:

$ awk -f fsoe3.awk <<< 5
2
3
5
7
11
$ awk -f fsoe3.awk <<< 1000 | wc -l
1000

বেস, 133 বাইট

ফাইল x.bash:

a=2
while((l<$1));do if((b[a]))
then((c=b[a]));else((c=a,l++));echo $a;fi;((d=a+c))
while((b[d]));do((d+=c));done
((b[d]=c,a++));done

চালান:

$ bash x.bash 5
2
3
5
7
11
$ bash x.bash 1000 | wc -l
1000

ইতিমধ্যে পাওয়া প্রাইমগুলি "ধনাত্মক পূর্ণসংখ্যার টেপ" এ ঝাঁপিয়ে দিয়ে পুরস্কার গণনা করা হয়। মূলত এটি সিরিয়ালাইজড সিভী অফ ইরোটোথিনিস।

from time import time as t

L = {}
n = 2
l = 0

t0=t()

while l<1000000:

        if n in L:
                P = L[n]
        else:
                P = n
                l += 1
                print t()-t0

        m = n+P
        while m in L:
                m += P
        L[m] = P

        n += 1

... পাইথনে একই অ্যালগরিদম এবং সেই সময়টি প্রিন্ট করে যখন lপ্রাইমটির পরিবর্তে থিম - প্রাইমটি পাওয়া যায়।

আউটপুট gnuplotনিম্নলিখিত ফলন দিয়ে প্লট করা হয়েছে :

ডিস্কে বাফার ডেটা লেখার কারণে ফাইলটি I / o বিলম্বের সাথে লাফিয়ে লাফানোর কিছুটা সম্ভবত রয়েছে ...

অনেক বড় সংখ্যক প্রাইমগুলি সন্ধানের জন্য, অতিরিক্ত সিস্টেম নির্ভরশীল বিলম্বগুলি গেমটিতে আনবে, যেমন "ধনাত্মক পূর্ণসংখ্যার টেপ" উপস্থাপনকারী অ্যারে ক্রমাগত বৃদ্ধি পায় এবং যত তাড়াতাড়ি বা পরে প্রতিটি কম্পিউটার আরও র‌্যামের (বা পরে অদলবদ) জন্য কাঁদবে।

... সুতরাং পরীক্ষামূলক ডেটা দেখে জটিলতার ধারণা পাওয়া সত্যিই খুব বেশি সাহায্য করে না ... :-(

nপ্রাইমগুলি সন্ধানের জন্য প্রয়োজনীয় সংযোজনগুলি এখন গণনা করুন :

cells = {}
current = 2
found = 0

additons = 0

while found < 10000000:

        if current in cells:
                candidate = cells[current]
                del cells[current] # the seen part is irrelevant
        else:
                candidate = current
                found += 1 ; additons += 1
                print additons

        destination = current + candidate ; additons += 1
        while destination in cells:
                destination += candidate ; additons += 1
        cells[destination] = candidate

        current += 1 ; additons += 1

আপনি কীভাবে এই গ্রাফগুলি তৈরি করবেন?

— বিড়াল

1

Gnuplotএর সাথে set term xtermএবং xtermএর গ্রাফিক্স উইন্ডোটির স্ক্রিনশট (সম্ভবত ভুলে যাওয়া বৈশিষ্ট্যের কাছাকাছি)। ;-)

0

স্কেল 121 (99 মেন ক্লাসের বয়লারপ্লেট ছাড়াই)

object Q extends App{Stream.from(2).filter{a=>Range(2,a).filter(a%_==0).isEmpty}.take(readLine().toInt).foreach(println)}

— ক্রিজিসটফ ভেন্ডি
সূত্র

0

পাইথন 3, 117 106 বাইট

এই দ্রষ্টব্যটি সামান্য তুচ্ছ, কারণ এটি 0 আউটপুট দেয় যেখানে একটি সংখ্যা প্রধান নয়, তবে আমি তা পোস্ট করব:

r=range
for i in[2]+[i*(not 0 in[i%j for j in r(3,int(i**0.5)+1,2)])for i in r(3,int(input()),2)]:print(i)

এছাড়াও, আমি জানি না কীভাবে একটি অ্যালগরিদমের জটিলতাটি কার্যকর করা যায়। এই কারণে দয়া করে ডাউনोट করবেন না। পরিবর্তে, সুন্দর হন এবং আমি কীভাবে এটি কাজ করতে পারি তা মন্তব্য করুন। এছাড়াও, আমাকে বলুন আমি কীভাবে এটি সংক্ষিপ্ত করতে পারি।

— 0WJYxW9FMN
সূত্র

আমার মনে হয় আপনি লাগাতে পারেন print(i)লুপ জন্য একই লাইনে এবং স্পেস অপসারণ in [2], 0 if, 0 in [i%jএবং +1,2)] else।

— অ্যাক্রোলিথ

@ দাগ হাগলেনি ওয়া, অনেক ধন্যবাদ! আমি আমার পোস্টটি এক সেকেন্ডে সম্পাদনা করব। :-D

— 0WJYxW9FMN

@daHugLenny আপনি কীভাবে কোনও সুযোগেই দক্ষতা গণনা করতে জানবেন?

— 0WJYxW9FMN

না, দুঃখিত। (মন্তব্যগুলি কমপক্ষে 15 টি দীর্ঘ হতে হবে)

— অ্যাক্রোলিথ

যাই হোক ধন্যবাদ. আপনি আমার প্রোগ্রামটি এখানে সবচেয়ে স্বল্পতম করেছেন!

— 0WJYxW9FMN

0

হাস্কেল (52² = 2704)

52`take`Data.List.nubBy(((1<).).gcd)[2..]`forM_`print

— রোমান সিজবোরা
সূত্র

0

পার্ল 6, 152 বাইট, ও (এন লগ এন লগ (এন লগ এন) লগ (লগ (এন লগ এন))) (?), 9594.79 পয়েন্ট

এই পৃষ্ঠা অনুসারে , এন পর্যন্ত সমস্ত প্রাইম সন্ধান করার বিট জটিলতা হ'ল ও (এন লগ এন লগ লগ এন); উপরের জটিলতাটি এই সত্যটি ব্যবহার করে যে n তম প্রাইম n লগ এন এর সমানুপাতিক।

my \N=+slurp;my \P=N*(N.log+N.log.log);my @a=1 xx P;for 2..P.sqrt ->$i {if @a[$i] {@a[$_*$i]=0 for $i..P/$i}};say $_[1] for (@a Z ^P).grep(*[0])[2..N+1]

— bb94
সূত্র

যোগ্যতা অর্জন করে না, কোয়ালিফাই করার জন্য ওয়েনেটলে এটি করুন

— noɥʇʎԀʎzɐɹƆ

ক্ষমা করবেন, তবে আপনার অর্থ কী?

— bb94

খয়রাত জন্য (fiiiiiiiiilerrrrr)

— noɥʇʎԀʎzɐɹƆ

0

গ্রোভি (50 বাইট) - ও (এন * স্ক্রুট (এন)) - স্কোর 353.553390593

{[1,2]+(1..it).findAll{x->(2..x**0.5).every{x%it}}}

এন নেয় এবং সমস্ত সংখ্যা 1 থেকে n এর আউটপুট দেয় যা প্রধান।

অ্যালগরিদম আমি কেবল আউটপুট প্রাইমগুলি এন> 2 বেছে নিয়েছি, সুতরাং শুরুতে 1,2 যোগ করা প্রয়োজন।

ভাঙ্গন

x%it - বিভাজ্য না হলে নিখুঁত সত্য, যদি তা মিথ্যা হয়।

(2..x**0.5).every{...}- 2 এবং বর্গমূল (x) এর মধ্যে সব মান জন্য, নিশ্চিত করুন যে তারা বিভাজ্য নয় এই সত্য ফিরে আসার জন্য সত্য ফিরে আসবে যে ।

(1..it).findAll{x->...} - 1 এবং n এর মধ্যে থাকা সমস্ত মানগুলির জন্য, 2 এবং বর্গ (এন) এর মধ্যে বিভাজনযোগ্য হওয়ার মাপদণ্ডের সাথে মানানসই সমস্ত সন্ধান করুন।

{[1,2]+...} - 1 এবং 2 যোগ করুন, কারণ এগুলি সর্বদা প্রাথমিক এবং কখনই অ্যালগরিদম দ্বারা আচ্ছাদিত হয় না।

— ম্যাজিক অক্টোপাস উরন
সূত্র

0

র‌্যাকেট 155 বাইট

(let p((o'(2))(c 3))(cond[(>=(length o)n)(reverse o)][(ormap(λ(x)(= 0(modulo c x)))
(filter(λ(x)(<= x(sqrt c)))o))(p o(add1 c))][(p(cons c o)(add1 c))]))

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

Ungolfed:

(define(nprimes n)
  (let loop ((outl '(2))                   ; outlist having primes being created
             (current 3))                  ; current number being tested
  (cond
    [(>= (length outl) n) (reverse outl)]  ; if n primes found, print outlist.
    [(ormap (λ(x) (= 0 (modulo current x))) ; test if divisible by any previously found prime
            (filter                         ; filter outlist till sqrt of current number
             (λ(x) (<= x (sqrt current)))
             outl))
     (loop outl (add1 current)) ]           ; goto next number without adding to prime list
    [else (loop (cons current outl) (add1 current))] ; add to prime list and go to next number
    )))

পরীক্ষামূলক:

(nprimes 35)

আউটপুট:

'(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149)

— rnso
সূত্র

0

45 ডাব্লু (জটিলতা এন ^ 2)

আরেকটি awk, 100 টি পর্যন্ত প্রাইমগুলির জন্য এটি ব্যবহার করুন

awk '{for(i=2;i<=sqrt(NR);i++) if(!(NR%i)) next} NR>1' <(seq 100)

কোড গল্ফ গণনা অংশ হয়

{for(i=2;i<=sqrt(NR);i++)if(!(NR%i))next}NR>1

যা কোনও স্ক্রিপ্ট ফাইলের মধ্যে রাখা যায় এবং চালানো যেতে পারে awk -f prime.awk <(seq 100)

— karakfa
সূত্র

0

জাভাস্ক্রিপ্ট, 61 টি অক্ষর

f=(n,p=2,i=2)=>p%i?f(n,p,++i):i==p&&n--&alert(p)||n&&f(n,++p)

O (n ^ 2) এর চেয়ে কিছুটা খারাপ, বৃহত্তর এন এর জন্য স্ট্যাকের স্থান শেষ হয়ে যাবে।

— SudoNhim
সূত্র

সর্বাধিক দক্ষতার সাথে এবং সংক্ষিপ্ততম কোডে [বন্ধ] প্রথম এন প্রাথমিক সংখ্যাগুলির তালিকা

পাইথন (129 অক্ষর, ও (এন * লগ লগ এন), 203.948 এর স্কোর)

পাইথন ( 191 156 152 চর, ও (এন * লগ লগ এন) (?), 252.620 এর স্কোর (?))

হাস্কেল, এন ^ 1.1 অভিজ্ঞতামূলক বৃদ্ধি হার, 89 টি চর, স্কোর 139 (?)

জটিলতার অনুমান সম্পর্কে

কোনও আমদানি নেই, 240 টি অক্ষর। n ^ 1.15 অভিজ্ঞতা অভিজ্ঞতা বৃদ্ধি, স্কোর 546।

হাস্কেল, 72 89 অক্ষর, ও (এন ^ 2), স্কোর 7921

সি #, 447 অক্ষর, বাইট 452, স্কোর?

স্ক্রিপ্টস ভেরিয়েন্ট, 381 টি অক্ষর, 385 বাইট, স্কোর?

গল্ফস্ক্রিপ্ট (45 টি অক্ষর, স্কোর দাবি করেছে ~ 7708)

ভিম: 143 কীস্ট্রোক (115 ক্রিয়া): ও (n ^ 2 * লগ (এন)): স্কোর: 101485.21

জমা:

কমান্ডগুলি পরিচালনা:

অ্যালগরিদম:

জটিলতা

ব্যাখ্যা

স্কেল 263 টি অক্ষর

নতুন বিগ-ও বিবেচনাগুলি:

রুবি, ৮৪ টি চর, ৮৪ বাইট, স্কোর?

হালনাগাদ

মূল

স্কালা, 124 টি অক্ষর

পার্ল - 94 টি অক্ষর, হে (এন লগ (এন)) - স্কোর: 427

পাইথন - 113 টি অক্ষর

এডাব্লুকে, 96 86 বাইট

বেস, 133 বাইট

স্কেল 121 (99 মেন ক্লাসের বয়লারপ্লেট ছাড়াই)

পাইথন 3, 117 106 বাইট

হাস্কেল (52² = 2704)

পার্ল 6, 152 বাইট, ও (এন লগ এন লগ (এন লগ এন) লগ (লগ (এন লগ এন))) (?), 9594.79 পয়েন্ট

গ্রোভি (50 বাইট) - ও (এন * স্ক্রুট (এন)) - স্কোর 353.553390593

ভাঙ্গন

র‌্যাকেট 155 বাইট

জাভাস্ক্রিপ্ট, 61 টি অক্ষর