นี่เป็นคำถามเกี่ยวกับกอล์ฟรหัสแรกของฉันและเป็นคำถามที่ง่ายมากดังนั้นฉันจึงขออภัยล่วงหน้าหากฉันอาจทำผิดหลักเกณฑ์ของชุมชน

งานคือการพิมพ์ออกมาตามลำดับจำนวนเฉพาะทั้งหมดน้อยกว่าหนึ่งล้าน รูปแบบเอาต์พุตควรเป็นหนึ่งหมายเลขต่อหนึ่งบรรทัดของเอาต์พุต

จุดมุ่งหมายเช่นเดียวกับการส่งรหัสกอล์ฟส่วนใหญ่คือการลดขนาดรหัส การเพิ่มประสิทธิภาพสำหรับรันไทม์เป็นโบนัส แต่เป็นวัตถุประสงค์รอง

Mathematica , 17 24

เพื่อการเปรียบเทียบ:

Prime@Range@78498

ตามที่ระบุไว้ในความคิดเห็นฉันล้มเหลวในการให้หนึ่งนายกต่อบรรทัด; การแก้ไข:

Column@Prime@Range@78498

Python 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การถูกเรียกว่าสำคัญ

มากขึ้นอย่างมากก็ดังมาจากทฤษฏีของวิลสันว่าเมื่อkเป็นสำคัญเท่ากับP%k 1แม้ว่าเราต้องการเพียงว่ามันไม่ใช่ศูนย์ที่นี่ แต่มีประโยชน์โดยทั่วไปที่P%kเป็นตัวแปรตัวบ่งชี้ว่าkสำคัญ

C, 61 ตัวอักษร

เกือบเหมือนกันกับคำถามนี้ (คำถามก็เกือบเหมือนกันทุกประการ)

n=2;main(m){n<1e6&&main(m<2?printf("%d\n",n),n:n%m?m-1:n++);}

MATLAB (16) (12)

น่าเสียดายที่ผลลัพธ์นี้ในบรรทัดเดียว:

primes(1000000)

แต่นั่นถูกแก้ไขโดยเมทริกซ์ง่าย ๆ :

primes(1000000)'

และฉันสามารถตัดอักขระบางตัวออกโดยใช้สัญกรณ์เอ็กซ์โพเนนเชียล (ตามที่แนะนำในความคิดเห็น):

primes(1e6)'

Bash (37 ตัวอักษร)

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

(60 ตัวอักษร)

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

บนคอมพิวเตอร์ของฉัน (cpu 2.0 GHz, 2 GB ram) ใช้เวลา 14 วินาที

J, 21 ตัวอักษร

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

ซึ่งสามารถย่อให้เล็กลงได้

1[\p:i.78498

ถ้าคุณรู้ว่ามีจำนวนเฉพาะต่ำกว่า 1000000 เท่าไหร่

PowerShell, 47 44 ไบต์

ช้ามาก แต่สั้นที่สุดที่ฉันสามารถหาได้

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

PowerShell ขนาด 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

ทับทิม 34

require'prime';p Prime.take 78498

Bash ขนาด 30 ไบต์

เนื่องจากsaeednจะไม่ทำตามคำแนะนำของฉัน - ซึ่งทั้งสั้นและเร็วกว่าวิธีการของเขา - ฉันคิดว่าฉันโพสต์คำตอบของตัวเอง:

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

มันทำงานอย่างไร

seq 1e6

แสดงจำนวนเต็มบวกทั้งหมดได้สูงสุด 1,000,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 พิมพ์เฉพาะค่าจริงจำนวนเฉพาะเฉพาะเท่านั้นจึงจะถูกพิมพ์

ทับทิม50 41

require'mathn'
p (2..1e6).select &:prime?

Bash, 37

จะตีกอล์ฟมากกว่านี้ไหมถ้าฉันสามารถ ...

สิ่งเหล่านี้ส่วนใหญ่พยายามแยกfactorรูปแบบเอาต์พุตที่น่าอึดอัดใจ

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

ใช้เวลา 5.7 วินาทีหรือมากกว่านั้นจึงจะเสร็จสิ้นในเครื่องของฉัน

(มันเพิ่งเกิดขึ้นที่โพสต์ของฉันเป็นคนแรกที่ไปที่หน้าสองของคำตอบดังนั้นไม่มีใครจะเห็นมัน ... )

วิธีการแก้ปัญหาเก่า

สิ่งนี้ยาวและช้าลง (ใช้เวลา 10 วินาที)

seq 1e6|factor|egrep ':.\S+$'|grep -oE '\S+$'

Python 3.x: 66 ตัวอักษร

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

โซลูชันที่มีประสิทธิภาพมากขึ้น: 87 ตัวอักษร

ขึ้นอยู่กับตะแกรงของ Eratosthenes

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)

Haskell, 51

mapM print [n|n<-[2..10^6],all((>0).rem n)[2..n-1]]

APL, 15

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

ล่ามของฉันมีปัญหาเรื่องความจำ แต่ใช้งานได้ในทางทฤษฎี

Perl, 49 ไบต์

การแสดงออกปกติกังฟู :)

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

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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

มันไม่ได้คืบหน้าแม้แต่ 10% ในขณะที่ฉันพิมพ์โพสต์นี้!

แหล่งที่มาสำหรับ regex: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

จูเลียอายุ 11 ปี

primes(10^6)

ดูเหมือนว่าบิลด์อินจะได้รับอัปโหลดแล้วและฉันต้องการคำเพิ่มเติมสำหรับการตอบอีกต่อไป

J (15 หรือ 9)

ฉันไม่สามารถเชื่อว่านี่ชนะ Mathematica (ถึงแม้ว่ามันจะเป็นเพียงคนเดียว 2 ตัวอักษร)

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

หรือ:

p:i.78498

gs2, 5 ไบต์

เข้ารหัสใน CP437:

∟)◄lT

1C 29ดันล้าน11 6Cเป็นค่าช่วงล่าง, 54เป็นเส้นแสดง

GolfScript, 22/20 (20/19) ไบต์

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

ที่ความเร็วโค้ดสามารถทำให้โค้ดสั้นลงสองไบต์:

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

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

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

นี้จะพิมพ์ LF เพิ่มเติมหลังจากช่วงเวลาสำหรับรุ่นที่รวดเร็วและมันจะพิมพ์ช่วงเวลาที่เป็นอาร์เรย์สำหรับคนที่ช้า

มันทำงานอย่างไร

ทั้งสองรุ่นมีการใช้งานของตะแกรงของ Eratosthenes

เวอร์ชันที่รวดเร็วทำสิ่งต่อไปนี้:

1. ตั้งค่าและA = [ 2 3 4 … 999,999 ]| = [ 0 1 2 … 999,999 ]

2. ชุดและพิมพ์N = A[0]N

3. รวบรวมทุกองค์ประกอบ N-TH จากใน| เหล่านี้เป็นทวีคูณของCN

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.

เวอร์ชั่นช้านั้นทำงานในรูปแบบที่คล้ายกัน แต่แทนที่จะทำการลบทวีคูณอย่างน้อยที่สุดของ“ A” (ซึ่งเป็นตำแหน่งที่ดีที่สุดเสมอ) มันจะลบจำนวนทวีคูณของจำนวนเต็มบวกทั้งหมดต่ำกว่า 1,000,000

สามารถในการแข่งขัน

ในกรณีที่ไม่มีฟังก์ชั่นทางคณิตศาสตร์ใด ๆ ในตัวที่จะแยกตัวประกอบหรือตรวจสอบสภาพดั้งเดิมโซลูชั่น GolfScript ทั้งหมดจะมีขนาดใหญ่มากหรือไม่มีประสิทธิภาพมาก

ในขณะที่ยังห่างไกลจากการมีประสิทธิภาพฉันคิดว่าฉันได้รับอัตราส่วนความเร็วต่อขนาดที่เหมาะสม ในช่วงเวลาของการส่งของวิธีการนี้ดูเหมือนว่าจะสั้นที่สุดของผู้ที่ไม่ได้ใช้ในตัวดังกล่าวข้างต้น ฉันพูดเหมือนเพราะฉันไม่รู้ว่าคำตอบบางอย่างทำงานอย่างไร ...

ฉันเปรียบเทียบมาตรฐาน GolfScript ที่ส่งมาทั้งสี่โซลูชัน: w0lf's (แผนกทดลอง) คำตอบอื่น ๆ ของฉัน (ทฤษฎีของ Wilson) และคำตอบสองข้อนี้ ผลลัพธ์เหล่านี้คือ:

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)

NARS2000 APL, 7 ตัวอักษร

⍸0π⍳1e6

Golfscript 26 25 24

แก้ไข (บันทึกอีกหนึ่งถ่านขอบคุณ Peter Taylor):

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

รหัสเก่า:

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

รหัสนี้มีค่าตามทฤษฎีเท่านั้นเพราะมันช้าและไม่มีประสิทธิภาพอย่างไม่น่าเชื่อ ฉันคิดว่าอาจใช้เวลาหลายชั่วโมงกว่าจะทำงานได้

หากคุณต้องการทดสอบลองใช้เฉพาะช่วงเวลาที่มีค่ามากถึง 100:

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

CJam - 11

1e6,{mp},N*

1e6,- อาร์เรย์ 0 ... 999999
{mp},- เลือกช่วงเวลา
N*- เข้าร่วมกับสายใหม่

GolfScript 25 ไบต์ (24)

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

หากรูปแบบเอาต์พุตที่ระบุในคำถามที่แก้ไขนั้นถูกเพิกเฉยสามารถบันทึกได้หนึ่งไบต์:

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

สิ่งนี้จะพิมพ์จำนวนเฉพาะเป็นอาร์เรย์ (เช่นเดียวกับวิธีแก้ปัญหาอื่น ๆ ) มากกว่าหนึ่งรายการต่อบรรทัด

มันทำงานอย่างไร

ความคิดทั่วไปคือการใช้ทฤษฎีบทของวิลสันซึ่งระบุว่าn > 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.

มาตรฐาน

เร็วกว่าแผนกทดลอง แต่ช้ากว่าตะแกรงของ Eratosthenes ดูคำตอบอื่น ๆ ของฉัน

Java, 110 ไบต์

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

ใช้การแบ่งเอกด้วยการทดสอบ regex

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

อัลกอริทึมนั้นไม่มีประสิทธิภาพอย่างมาก แต่เนื่องจากเรากำลังทำโค้ดกอล์ฟซึ่งไม่สำคัญ

Mathematica 25

สมมติว่าคุณไม่รู้จำนวนช่วงเวลาน้อยกว่า 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 ตัวอักษร

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

หากไม่มีข้อกำหนดรูปแบบเอาต์พุตสามารถลดได้ถึง13ตัวอักษร:

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

1]\ เพิ่งใช้เวลาช่วง primes อันดับ 1 เปลี่ยนเป็นอาร์เรย์อันดับ 2 และวางนายกแต่ละตัวไว้ในแถวของตัวเอง - และดังนั้นรูปแบบเอาต์พุตเริ่มต้นของล่ามจะเปลี่ยนรายการหนึ่งบรรทัดเป็นหนึ่งรายการต่อหนึ่งบรรทัด

(#~ f) yเป็นพื้นฐานfilterที่fส่งกลับบูลีนสำหรับแต่ละองค์ประกอบyมา i.1e6คือช่วงของจำนวนเต็ม [0,1000000) และ1&p:เป็นฟังก์ชั่นบูลีนที่ส่งกลับ 1 สำหรับช่วงเวลา

R, 45 43 ตัวอักษร

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

สำหรับแต่ละหมายเลข x จาก 2 ถึง 1e6 ให้ส่งออกมันถ้าจำนวนของ x mod 2 ถึง x ที่เท่ากับ 0 น้อยกว่า 2

Bash (433643)

ความพยายามของฉัน (ไม่ฉลาด) คือการใช้ปัจจัยเพื่อแยกแยะผลิตภัณฑ์

factor ${PRODUCT}

น่าเสียดายที่มีผลิตภัณฑ์จำนวนมากเป็นจำนวนมาก มันใช้เวลานานกว่า 12 ชั่วโมงในการวิ่ง ฉันตัดสินใจที่จะโพสต์มันเพราะฉันคิดว่ามันเป็นเอกลักษณ์

นี่คือรหัสเต็ม

ถ้ามันเป็นช่วงเวลาที่ต่ำกว่าหกปีมันจะสมเหตุสมผล

  factor 30

โอ้ดีฉันพยายาม

C #, 70

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

คุณจะไม่เห็นมากที่นี่แม้ว่าเป็นเวลานาน ...