Ini adalah pertanyaan golf kode pertama saya, dan sangat sederhana, jadi saya minta maaf sebelumnya jika saya mungkin telah melanggar pedoman komunitas.

Tugasnya adalah mencetak, dalam urutan menaik, semua bilangan prima kurang dari satu juta. Format output harus satu angka per baris output.

Tujuannya, seperti pada kebanyakan pengiriman kode golf, adalah untuk meminimalkan ukuran kode. Mengoptimalkan runtime juga merupakan bonus, tetapi merupakan tujuan sekunder.

Mathematica , 17 24

Hanya untuk perbandingan:

Prime@Range@78498

Seperti disebutkan dalam komentar saya gagal memberikan satu prime per baris; koreksi:

Column@Prime@Range@78498

Python 3, 46 byte

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

Pada saat loop mencapai pengujian k, iteratif menghitung faktor kuadrat P=(k-1)!^2. Jika kprima, maka itu tidak muncul dalam produk 1 * 2 * ... * (k-1), jadi itu bukan faktor P. Tapi, jika itu komposit, semua faktor utamanya lebih kecil dan begitu juga dalam produk. Kuadrat sebenarnya hanya diperlukan untuk berhenti k=4dari salah disebut prima.

Lebih kuat lagi, teorema Wilson menyatakan bahwa ketika kprima, P%ksama dengan 1. Meskipun kita hanya perlu bukan nol di sini, ini berguna secara umum yang P%kmerupakan variabel indikator untuk apakah kprime.

C, 61 karakter

Hampir persis sama dengan yang ini (pertanyaannya juga hampir sama persis).

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

MATLAB (16) (12)

Sayangnya, ini menghasilkan satu baris:

primes(1000000)

tapi itu diselesaikan dengan transpose matriks sederhana:

primes(1000000)'

dan saya dapat memotong beberapa karakter dengan menggunakan notasi eksponensial (seperti yang disarankan dalam komentar):

primes(1e6)'

Bash (37 karakter)

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

(60 karakter)

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

di komputer saya (cpu 2,0 GHz, ram 2 GB) membutuhkan waktu 14 detik.

J, 21 karakter

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

yang dapat disingkat menjadi

1[\p:i.78498

jika Anda tahu berapa banyak bilangan prima ada di bawah 10.00000.

PowerShell, 47 44 byte

Sangat lambat, tapi yang terpendek yang bisa saya lakukan.

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

PowerShell, 123 byte

Ini jauh lebih cepat; jauh dari optimal, tetapi kompromi yang baik antara efisiensi dan singkatnya.

 $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

Ruby 34

require'prime';p Prime.take 78498

Bash, 30 byte

Karena saeedn tidak akan bertindak atas saran saya - yang lebih pendek dan lebih cepat daripada pendekatannya - saya pikir saya akan memposting jawaban saya sendiri:

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

Bagaimana itu bekerja

seq 1e6

daftar semua bilangan bulat positif hingga 1.000.000.

factor

faktor mereka satu per satu. Untuk sepuluh pertama, hasilnya adalah sebagai berikut:

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

Akhirnya,

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

mengubah seluruh baris ( $0) ke produk dari bidang kedua (faktor prima pertama) dan negasi logis dari bidang ketiga ( 1jika merupakan satu faktor prima atau kurang, 0jika tidak).

Ini menggantikan garis yang sesuai dengan bilangan prima dengan angka itu sendiri dan semua garis lainnya dengan nol. Karena awk hanya mencetak nilai kebenaran, hanya bilangan prima yang akan dicetak.

Ruby 50 41

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

Bash, 37

Akan bermain golf lebih banyak, jika aku bisa ...

Sebagian besar dari ini mencoba mem factor- parsing format output yang canggung.

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

Butuh 5,7 detik untuk menyelesaikannya di mesin saya.

(Kebetulan posting saya adalah yang pertama masuk pada halaman kedua jawaban, jadi tidak ada yang akan melihatnya ...)

Solusi lama

Ini lebih lama dan lebih lambat (butuh 10 detik).

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

Python 3.x: 66 karakter

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

Solusi yang lebih efisien: 87 karakter

Berdasarkan Saringan 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

Penerjemah saya mengalami masalah memori, tetapi itu bekerja secara teori.

Perl, 49 byte

Ekspresi reguler kung fu :)

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

Versi tidak disatukan:

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

Bahkan belum membuat kemajuan 10% saat saya mengetik posting ini!

Sumber untuk regex: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

Julia, 11

primes(10^6)

Sepertinya built in semakin upvotes, ditambah saya membutuhkan lebih banyak kata untuk jawaban yang lebih lama.

J (15 atau 9)

Saya tidak percaya ini mengalahkan Mathematica (bahkan jika itu hanya satu per 2 karakter)

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

Atau:

p:i.78498

gs2, 5 byte

Dikodekan dalam CP437:

∟)◄lT

1C 29mendorong satu juta, 11 6Cadalah bilangan prima di bawah ini, 54adalah menunjukkan garis.

GolfScript, 22/20 (20/19) byte

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

Dengan mengorbankan kecepatan, kode dapat dibuat dua byte lebih pendek:

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

Jika format output yang ditentukan dalam pertanyaan yang diedit diabaikan (yang merupakan jawaban dari banyak jawaban yang ada), dua byte dapat disimpan dalam versi cepat dan satu dapat disimpan dalam versi lambat:

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

Ini akan mencetak LF tambahan setelah bilangan prima untuk versi cepat, dan itu akan mencetak bilangan prima sebagai larik untuk yang lambat.

Bagaimana itu bekerja

Kedua versi ini merupakan implementasi dari saringan Eratosthenes .

Versi cepat melakukan hal berikut:

1. Atur A = [ 2 3 4 … 999,999 ]dan | = [ 0 1 2 … 999,999 ].

2. Atur N = A[0]dan cetak N.

3. Kumpulkan setiap elemen ke-N dari |dalam C. Ini adalah kelipatan dari N.

4. Setel A = A - C.

5. Jika Atidak kosong, kembali ke 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.

Versi lambat bekerja dengan cara yang sama, tetapi alih-alih menghapus kelipatan minimum "A" (yang selalu prima), ia menghapus kelipatan semua bilangan bulat positif di bawah 1.000.000.

Daya saing

Dengan tidak adanya fungsi matematika bawaan untuk memfaktisasi atau memeriksa primality, semua solusi GolfScript akan sangat besar atau sangat tidak efisien.

Meskipun masih jauh dari efisien, saya pikir saya telah mencapai rasio kecepatan-ke-ukuran yang layak. Pada saat pengajuannya, pendekatan ini tampaknya menjadi yang terpendek dari mereka yang tidak menggunakan salah satu built-in yang disebutkan di atas. Saya katakan sepertinya karena saya tidak tahu bagaimana beberapa jawaban bekerja ...

Saya telah membandingkan keempat solusi GolfScript yang diajukan: w0lf's (divisi percobaan), jawaban saya yang lain (teorema Wilson) dan dua jawaban ini. Inilah hasilnya:

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 karakter

⍸0π⍳1e6

Golfscript 26 25 24

Sunting (satu arang tersimpan lagi berkat Peter Taylor):

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

Kode lama:

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

Kode ini hanya memiliki nilai teoritis, karena sangat lambat dan tidak efisien. Saya pikir itu bisa memakan waktu berjam-jam untuk berjalan.

Jika Anda ingin mengujinya, coba misalnya hanya bilangan prima hingga 100:

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

CJam - 11

1e6,{mp},N*

1e6,- array 0 ... 999999
{mp},- pilih bilangan prima
N*- gabung dengan baris baru

GolfScript, 25 (24) byte

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

Jika format output yang ditentukan dalam pertanyaan yang diedit diabaikan, satu byte dapat disimpan:

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

Ini akan mencetak bilangan prima sebagai array (seperti banyak solusi lain lakukan) daripada satu per baris.

Bagaimana itu bekerja

Gagasan umum adalah menggunakan teorema Wilson , yang menyatakan bahwa n > 1 adalah prima jika dan hanya jika

!     # 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.

Tolak ukur

Lebih cepat dari pembagian percobaan, tetapi lebih lambat dari ayakan Eratosthenes. Lihat jawaban saya yang lain .

Java, 110 byte

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

Menggunakan pembagian unary melalui regex sebagai tes primality.

C, 91 88 85 82 81 80 76 72 karakter

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

Algoritma ini sangat tidak efisien, tetapi karena kita melakukan golf kode yang seharusnya tidak masalah.

Mathematica 25

Dengan asumsi Anda tidak tahu jumlah bilangan prima kurang dari 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 karakter

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

Tanpa persyaratan format output, ini dapat dikurangi menjadi 13 karakter:

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

1]\ hanya mengambil array peringkat 1 dari bilangan prima, mengubahnya menjadi array peringkat 2, dan menempatkan setiap prime pada barisnya sendiri - sehingga format output default interpreter mengubah daftar satu baris menjadi satu prima per baris.

(#~ f) ypada dasarnya filter, di mana fmengembalikan boolean untuk setiap elemen dalam y. i.1e6adalah kisaran bilangan bulat [0,1000000), dan 1&p:merupakan fungsi boolean yang mengembalikan 1 untuk bilangan prima.

R, 45 43 karakter

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

Untuk setiap angka x dari 2 hingga 1e6, cukup keluarkan jika jumlah x mod 2 hingga x yang sama dengan 0 kurang dari 2.

Bash (433643)

Upaya saya (tidak begitu pintar) adalah menggunakan faktor untuk faktor produk.

factor ${PRODUCT}

Sayangnya dengan jumlah besar produknya tentu saja besar. Butuh waktu lebih dari 12 jam untuk berlari. Saya memutuskan untuk mempostingnya karena saya pikir itu unik.

Ini kode lengkapnya.

Jika bilangan prima di bawah enam itu akan masuk akal.

  factor 30

Oh well, saya sudah mencoba.

C #, 70

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

Anda tidak akan melihat banyak di sini meskipun untuk waktu yang lama ...