กฎง่าย ๆ :

• First n primes (ไม่ใช่ primes ต่ำกว่าn ) ควรพิมพ์ไปยังเอาต์พุตมาตรฐานคั่นด้วย newlines (primes ควรสร้างขึ้นภายในโค้ด)
• primes ไม่สามารถสร้างได้โดยฟังก์ชัน inbuilt หรือผ่านทางไลบรารีเช่นการใช้ฟังก์ชัน inbuilt หรือไลบรารีเช่น prime = get_nth_prime (n), is_a_prime (ตัวเลข) หรือ factorlist = list_all_factors (number) จะไม่สร้างสรรค์มาก

• การให้คะแนน - สมมติว่าเรากำหนดคะแนน = f ([จำนวนตัวอักษรในรหัส]), O ( f (n)) เป็นความซับซ้อนของอัลกอริทึมของคุณโดยที่ n คือจำนวนช่วงเวลาที่พบ ตัวอย่างเช่นหากคุณมีรหัสชาร์ล 300 ตัวที่มีความซับซ้อนO (n ^ 2) คะแนนคือ 300 ^ 2 = 90000สำหรับ 300 ตัวอักษรที่มีO (n * ln (n)) คะแนนกลายเป็น 300 * 5.7 = 1711.13 ( สมมติว่าบันทึกทั้งหมดเป็นบันทึกธรรมดาสำหรับความเรียบง่าย)

• ใช้ภาษาการเขียนโปรแกรมใด ๆ ที่มีอยู่คะแนนต่ำสุดชนะ

แก้ไข:ปัญหาถูกเปลี่ยนจากการค้นหา '1000000 ช่วงแรก' เป็น 'ช่วงเวลาแรก' เนื่องจากความสับสนเกี่ยวกับสิ่งที่ 'n' ใน O (f (n)) คือnคือจำนวนช่วงเวลาที่คุณพบ (การค้นหาช่วงเวลาคือ ปัญหาที่นี่และความซับซ้อนของปัญหาขึ้นอยู่กับจำนวนของช่วงเวลาที่พบ)

หมายเหตุ:เพื่อชี้แจงความสับสนในความซับซ้อนหาก 'n' เป็นจำนวนเฉพาะที่คุณพบและ 'N' เป็นจำนวนเฉพาะที่พบความซับซ้อนในแง่ของ n คือและ N ไม่เทียบเท่านั่นคือO (f (n))! = O (f (N))เป็น, f (N)! = ค่าคงที่ * f (n) และ N! = ค่าคงที่ * n, เพราะเรารู้ว่าหน้าที่เฉพาะของ nth ไม่เชิงเส้น แต่ถึงแม้ว่าเราจะหา 'n' ความซับซ้อนเฉพาะช่วงเวลาควรจะแสดงออกได้อย่างง่ายดายในแง่ของ 'n'

ตามที่ Kibbee ชี้ให้เห็นคุณสามารถเยี่ยมชมไซต์นี้เพื่อตรวจสอบการแก้ปัญหาของคุณ ( ที่นี่เป็นรายการ Google เอกสารเก่า)

โปรดระบุสิ่งเหล่านี้ในโซลูชันของคุณ -

• โปรแกรมของคุณมีความซับซ้อนเพียงใด (รวมถึงการวิเคราะห์ขั้นพื้นฐานหากไม่สำคัญ)

• ความยาวอักขระของรหัส

• คะแนนจากการคำนวณขั้นสุดท้าย

นี่เป็นคำถาม CodeGolf แรกของฉันดังนั้นหากมีข้อผิดพลาดหรือช่องโหว่ในกฎข้างต้นโปรดชี้พวกเขาออกมา

Python (129 chars, O (n * log log n), คะแนน 203.948)

ฉันว่า Sieve of Eratosthenes เป็นวิธีที่จะไป ง่ายมากและค่อนข้างเร็ว

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:]

ปรับปรุงรหัสจากก่อน

Python ( 191 156 152 ตัวอักษร, O (n * บันทึกการทำงาน n) (?), คะแนน 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จำนวนเฉพาะ

Haskell, n ^ 1.1 อัตราการเติบโตเชิงประจักษ์ 89 ตัวอักษร 139 คะแนน (?)

การทำงานต่อไปนี้ที่พร้อมต์ GHCi เมื่อโหลดไลบรารีทั่วไปที่ใช้แล้วก่อนหน้านี้ พิมพ์n- th prime, 1-based:

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

นี่คือตะแกรงที่ไม่ จำกัด ของ Eratosthenes โดยใช้ไลบรารีที่ใช้งานทั่วไปสำหรับรายการที่สั่ง ความซับซ้อนเชิงประจักษ์ระหว่าง 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.2100**1.2 = 251

นอกจากนี้ฉันไม่ได้พยายามพิมพ์เฉพาะช่วงเวลาทั้งหมดเฉพาะไพรม์n- th แทน

ไม่มีการนำเข้า 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

Haskell, 72 89 ตัวอักษร, O (n ^ 2), คะแนน 7921

คะแนนสูงสุดต่อการนับถ่านชนะใช่ไหม? ปรับเปลี่ยนเป็นครั้งแรกและเห็นได้ชัดว่าฉันไม่สามารถใช้เครื่องคิดเลขได้ดังนั้นคะแนนของฉันจึงไม่แย่อย่างที่คิด (ใช้ความซับซ้อนสำหรับการแบ่งการทดลองขั้นพื้นฐานตามที่พบในแหล่งที่มาด้านล่าง)

ตามWill Nessด้านล่างไม่ใช่โปรแกรม 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) อัลกอริทึมเป็นเพียงเวอร์ชั่นกอล์ฟของตะแกรงที่ไร้เดียงสาดังที่เห็นในที่นี้คือ Old ghci 1 liner

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

ทิ้งคำตอบการโกงเก่าไว้เพราะห้องสมุดที่ลิงก์ไปนั้นค่อนข้างดี

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

ดูที่นี่สำหรับการนำไปใช้และลิงก์สำหรับความซับซ้อนของเวลา น่าเสียดายที่ล้อมีเวลาค้นหา log (n) ทำให้เราช้าลงด้วยปัจจัย

C #, 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);}}}}

ตัวแปร scriptcs, 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);}

หากคุณติดตั้ง scriptcs จากนั้นคุณสามารถเรียกใช้

ป.ล. ฉันเขียนสิ่งนี้เป็นกลุ่ม :D

GolfScript (45 ตัวอักษรให้คะแนน ~ 7708)

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

นี่เป็นการแบ่งการทดลองอย่างง่ายตามช่วงเวลา หากใกล้กับขอบของทับทิม (เช่นใช้ 1.9.3.0) เลขคณิตจะใช้การคูณ Toom-Cook 3 ดังนั้นแผนกทดลองใช้คือ O (n ^ 1.465) และค่าใช้จ่ายโดยรวมของแผนกคือO((n ln n)^1.5 ln (n ln n)^0.465) = O(n^1.5 (ln n)^1.965)† อย่างไรก็ตามใน GolfScript การเพิ่มองค์ประกอบไปยังอาร์เรย์ต้องคัดลอกอาร์เรย์ ฉันได้เพิ่มประสิทธิภาพสิ่งนี้เพื่อคัดลอกรายการของช่วงเวลาเฉพาะเมื่อพบว่ามีนายกใหม่ดังนั้นnรวมครั้งเท่านั้น ดำเนินการคัดลอกแต่ละคนเป็นO(n)รายการขนาด†ให้O(ln(n ln n)) = O(ln n)O(n^2 ln n)

และนี่คือเหตุผลว่าทำไมจึงใช้ GolfScript เพื่อเล่นกอล์ฟแทนการเขียนโปรแกรมอย่างจริงจัง

O(ln (n ln n)) = O(ln n + ln ln n) = O(ln n)† ฉันควรจะเห็นสิ่งนี้ก่อนที่จะแสดงความคิดเห็นในโพสต์ต่างๆ ...

มันง่ายมากแม้โปรแกรมแก้ไขข้อความของฉันก็สามารถทำได้!

เป็นกลุ่ม: 143 การกดแป้น (115 การกระทำ): O (n ^ 2 * บันทึก (n)): คะแนน: 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

อินพุต: N ควรอยู่ในบรรทัดแรกของเอกสารเปล่า หลังจากเสร็จสิ้นแล้วแต่ละไพรม์จาก 2 ถึง N จะเป็นบรรทัดแยกต่างหาก

เรียกใช้คำสั่ง:

ก่อนอื่นให้สังเกตว่าคำสั่งใด ๆ ที่มีเครื่องหมายรูปหมวกอยู่ข้างหน้าหมายความว่าคุณต้องกด Ctrl ค้างไว้และพิมพ์ตัวอักษรถัดไป (เช่น ^ V คือCtrl-vและ ^ R คือCtrl-r)

สิ่งนี้จะเขียนทับอะไรก็ได้ในการลงทะเบียน @a, @b, @d และ @p ของคุณ

เนื่องจากสิ่งนี้ใช้qคำสั่งจึงไม่สามารถอยู่ในแมโครได้ อย่างไรก็ตามนี่คือคำแนะนำสำหรับการใช้งาน

• qpqqdq ล้างการลงทะเบียน
• A^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"ddจะสร้างรายการหมายเลข 2 ถึง 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ลองบรรทัดนี้อีกครั้ง

สำหรับ N ขนาดใหญ่มันช้ามาก ใช้เวลาประมาณ 27 นาทีในการเรียกใช้ N = 5,000 พิจารณาตัวเองเตือน

ขั้นตอนวิธีการ:

สิ่งนี้ใช้อัลกอริทึมแบบเรียกซ้ำพื้นฐานสำหรับการค้นหาช่วงเวลา รับรายการของช่วงเวลาทั้งหมดระหว่าง 1 ถึง A, A + 1 นั้นดีถ้าไม่สามารถหารด้วยตัวเลขใด ๆ ในรายการของช่วงเวลา เริ่มต้นที่ A = 2 และเพิ่มจำนวนเฉพาะลงในรายการตามที่พบ หลังจากการเรียกซ้ำ N รายการจะมีช่วงเวลาทั้งหมดจนถึง N

ความซับซ้อน

อัลกอริทึมนี้มีความซับซ้อนของ O (nN) โดยที่ N คือหมายเลขอินพุตและ n คือจำนวนของจำนวนเฉพาะถึง N การเรียกซ้ำแต่ละครั้งทดสอบหมายเลข n และดำเนินการเรียกซ้ำ N โดยให้ O (nN)

อย่างไรก็ตาม N ~ n * log (n) ให้ความซับซ้อนสุดท้ายเป็น O (n ² * log (n)) ( https://en.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number )

คำอธิบาย

การแยกโฟลว์ของโปรแกรมจากคำสั่ง vim นั้นไม่ใช่เรื่องง่ายดังนั้นฉันจึงเขียนมันใหม่ใน Python หลังจากโฟลว์เดียวกัน เช่นเดียวกับรหัส Vim รหัส python จะเกิดข้อผิดพลาดเมื่อถึงจุดสิ้นสุด Python ไม่ชอบการเรียกซ้ำมากเกินไป หากคุณลองใช้รหัสนี้ด้วย 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 จะถูกลบเป็นผลข้างเคียงของการตั้งค่าแมโคร @d

  • โดยเฉพาะเขียนแมโครที่เพิ่มจำนวนแล้วคัดลอกมาที่บรรทัดถัดไปจากนั้นจะเขียน 1 และเรียกใช้แมโคร N นี้

• 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 () ด้านบน ข้อความ "If" น่าสนใจที่จะใช้ใน Vim ด้วยการใช้โอเปอเรเตอร์การค้นหา * คุณสามารถเลือกเส้นทางที่ต้องการติดตามได้ ทำลายคำสั่งลงไปอีกเราจะได้รับ

  • mpqdตั้งค่าเครื่องหมาย p ที่นี่และเริ่มการบันทึกมาโคร @d เครื่องหมาย p ต้องถูกตั้งค่าเพื่อให้มีจุดที่รู้จักในการข้ามไปที่การทำงานนี้
  • o^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc> เขียนข้อความคำสั่ง if / else
  • 0*w*wyiWdd@0 จริงดำเนินการคำสั่ง if
  • ก่อนดำเนินการคำสั่งนี้บรรทัดจะมี @a @b 0 0 `pj@p @a 0 (@a%@b) `pdd@p 0 `dj@d
  • 0 เลื่อนเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัด

  • *w*w เลื่อนเคอร์เซอร์ไปที่รหัสเพื่อดำเนินการต่อไป

    1. หาก @a == @b นั่นคือ`pj@pซึ่งจะย้ายไปที่หมายเลขถัดไปสำหรับ @a และรัน @p บน
    2. หาก @a! = @b และ @ a% @ b == 0 นั่นคือ`pdd@pซึ่งจะลบหมายเลขปัจจุบัน @a จากนั้นเรียกใช้ @p บนอีกรายการหนึ่ง
    3. หาก @a! = @b และ @ a %% b! = 0 นั่นคือ`dj@dซึ่งจะตรวจสอบหมายเลขถัดไปสำหรับ @b เพื่อดูว่าเป็นปัจจัยของ @a หรือไม่

  • yiWdd@0 yanks คำสั่งในการลงทะเบียน 0 ลบบรรทัดและเรียกใช้คำสั่ง

  • q สิ้นสุดการบันทึกของแมโคร @d

• เมื่อสิ่งนี้ถูกเรียกใช้ครั้งแรก`pdd@pคำสั่งจะถูกเรียกใช้ลบบรรทัด N + 1

• qpmp"aywgg@dq เขียนแมโคร @p ซึ่งบันทึกหมายเลขใต้เคอร์เซอร์จากนั้นไปที่รายการแรกและรัน @d บนนั้น

• gg@p จริงๆแล้วจะรัน @p เพื่อให้มันวนซ้ำทั้งไฟล์

QBASIC 98 ตัวอักษรความซับซ้อน N Sqrt (N) คะแนน 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:

สกาล่า 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)

สำหรับ n ที่ใหญ่กว่าจะลดการคำนวณลงประมาณ 16% ในช่วงนั้น แต่ afaik สำหรับสูตรคะแนนเราไม่พิจารณาปัจจัยคงที่หรือไม่

ข้อควรพิจารณา Big-O ใหม่:

ในการหา 1, 000, 10, 000, 000 ช่วงเวลาและอื่น ๆ ฉันใช้สูตรเกี่ยวกับความหนาแน่นของช่วงเวลา x => (math.log (x) * x * 1.3 ซึ่งกำหนดวงรอบนอกที่ฉันกำลังทำงาน

ดังนั้นสำหรับค่า i ใน 1 ถึง 6 => NPrimes (10 ^ i) รัน 9399, 133768 ... คูณลูปด้านนอก

ฉันพบฟังก์ชัน O ซ้ำ ๆ นี้ด้วยความช่วยเหลือจากข้อคิดเห็นของ Peter Taylor ผู้แนะนำค่าที่สูงขึ้นมากสำหรับการยกกำลังแทน 1.01 เขาแนะนำ 1.5:

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

O: (n: Int) ยาว

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

ns: รายการ [ยาว] = รายการ (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

สองค่าแรกเป็นค่าผิดปกติเนื่องจากฉันได้ทำการแก้ไขค่าคงที่อย่างเป็นทางการสำหรับสูตรการประมาณค่าขนาดเล็ก (สูงถึง 1,000)

ด้วยคำแนะนำของ Peter Taylors ที่ 1.5 จะมีลักษณะดังนี้:

245.2396265560166
98.8566987153728
70.8831374743478
59.26104390040363
52.92941829568069
48.956394784317816

ตอนนี้ฉันจะไปที่:

O(263)
res85: Long = 1576

แต่ฉันไม่แน่ใจว่าฉันจะเข้าใกล้ O-function ของฉันกับค่าที่สังเกตได้อย่างไร

Ruby 66 chars, O (n ^ 2) คะแนน - 4356

lazyมีให้ตั้งแต่ Ruby 2.0 และ1.0/0เป็นเคล็ดลับที่ยอดเยี่ยมในการหาช่วงอนันต์:

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

Ruby, 84 chars, 84 bytes, ให้คะแนน?

อันนี้น่าจะเป็นสามเณรน้อยเกินไปสำหรับชิ้นส่วนเหล่านี้ แต่ฉันมีเวลาสนุกที่จะทำมัน มันวนซ้ำจนกว่าจะ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ห่วงจะเรียงลำดับของการกระโดดออกที่ฉันเป็นพื้นที่สำหรับการปรับปรุง แต่บนเส้นทางนี้ฉันเรียงลำดับของการติด อย่างไรก็ตามมันสนุกที่จะคิด

สกาลา, 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 + epsilon))

124 ^ 1.5 <1381 ดังนั้นฉันจะเดาว่าคะแนนของฉันคืออะไร?

Perl - 94 ตัวอักษร, O (n log (n)) - คะแนน: 427

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

Python - อักขระ 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

AWK, 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

BASH, 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

จำนวนเฉพาะได้รับการคำนวณโดยให้จำนวนที่พบแล้วกระโดดขึ้นไปบน "เทปจำนวนเต็มบวก" โดยทั่วไปมันเป็นตะแกรงของ Eratosthenes

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

... เป็นอัลกอริธึมเดียวกันใน Python และพิมพ์เวลาที่lพบไพรม์ -th แทนไพรม์เอง

เอาต์พุตที่ลงจุดพร้อมกับgnuplotผลตอบแทนต่อไปนี้:

การกระโดดอาจมีบางอย่างที่เกี่ยวข้องกับความล่าช้าของไฟล์ i / o เนื่องจากการเขียนข้อมูลบัฟเฟอร์ลงดิสก์ ...

การใช้จำนวนเฉพาะจำนวนมากเพื่อค้นหาจะนำความล่าช้าในการพึ่งพาระบบเพิ่มเติมเข้ามาในเกมเช่นอาร์เรย์ที่แสดง "เทปจำนวนเต็มบวก" เติบโตอย่างต่อเนื่องและไม่ช้าก็เร็วจะทำให้คอมพิวเตอร์ทุกเครื่องร้องขอ RAM มากกว่า (หรือสลับในภายหลัง)

... ดังนั้นการได้รับแนวคิดเรื่องความซับซ้อนโดยการดูข้อมูลการทดลองนั้นไม่ได้ช่วยอะไรมากมาย ... :-(

ตอนนี้การเพิ่มส่วนที่จำเป็นในการค้นหา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

Scala 121 (99 ที่ไม่มีต้นแบบสำเร็จรูประดับหลัก)

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

Python 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)

นอกจากนี้ฉันไม่แน่ใจว่าจะแก้ไขความซับซ้อนของอัลกอริทึมได้อย่างไร กรุณาอย่าลงคะแนนเพราะสิ่งนี้ จงเป็นคนดีและให้ความเห็นว่าฉันจะทำมันออกมาได้อย่างไร บอกฉันหน่อยได้ไหมว่าฉันจะย่อขนาดนี้ได้อย่างไร

Haskell (52² = 2704)

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

Perl 6, 152 bytes, O (n log n log (n log n)) (log (n log n))) (?), 9594.79 จุด

ตามหน้านี้ความซับซ้อนเล็กน้อยในการค้นหาช่วงเวลาทั้งหมดถึง n คือ O (n log n log log n); ความซับซ้อนข้างต้นใช้ความจริงที่ว่านายกลำดับที่ 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]

Groovy (50 Bytes) - O (n * sqrt (n)) - คะแนน 353.553390593

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

ใช้ n และส่งออกตัวเลขทั้งหมดจาก 1 ถึง n ซึ่งเป็นจำนวนเฉพาะ

อัลกอริทึมที่ฉันเลือกเพียงแค่แสดงเฉพาะช่วง n> 2 ดังนั้นต้องเพิ่ม 1,2 ที่จุดเริ่มต้น

ทำให้พังถล่ม

x%it - บอกความจริงโดยนัยถ้ามันไม่สามารถหารได้, ถ้าเป็นเท็จ

(2..x**0.5).every{...}- สำหรับค่าทั้งหมดระหว่าง 2 ถึง sqrt (x) ตรวจสอบให้แน่ใจว่าค่าเหล่านั้นไม่สามารถหารได้เพื่อให้ผลลัพธ์เป็นจริงต้องส่งคืนค่าจริงทุกค่า

(1..it).findAll{x->...} - สำหรับค่าทั้งหมดระหว่าง 1 ถึง n ให้ค้นหาค่าทั้งหมดที่ตรงกับเกณฑ์การแบ่งไม่ได้ระหว่าง 2 ถึง sqrt (n)

{[1,2]+...}​ - เพิ่ม 1 และ 2 เนื่องจากมันเป็นไพรม์เสมอและไม่ครอบคลุมโดยอัลกอริทึม

แร็กเก็ต 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)

awk 45 (ความซับซ้อน N ^ 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)

Javascript, 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) เล็กน้อยจะมีพื้นที่ว่างเหลืออยู่สำหรับขนาดใหญ่ n