Đây là câu hỏi golf mã đầu tiên của tôi và là một câu hỏi rất đơn giản, vì vậy tôi xin lỗi trước nếu tôi có thể vi phạm bất kỳ nguyên tắc cộng đồng nào.

Nhiệm vụ là in ra, theo thứ tự tăng dần, tất cả các số nguyên tố nhỏ hơn một triệu. Định dạng đầu ra phải là một số trên mỗi dòng đầu ra.

Mục đích, như với hầu hết các đệ trình golf mã, là để giảm thiểu kích thước mã. Tối ưu hóa cho thời gian chạy cũng là một phần thưởng, nhưng là một mục tiêu thứ yếu.

Toán học , 17 24

Chỉ để so sánh:

Prime@Range@78498

Như đã lưu ý trong một bình luận, tôi đã không cung cấp một số nguyên tố trên mỗi dòng; điều chỉnh:

Column@Prime@Range@78498

Python 3, 46 byte

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

Vào thời điểm vòng lặp đạt đến thử nghiệm k, nó đã tính toán lặp lại giai đoạn bình phương P=(k-1)!^2. Nếu klà số nguyên tố, thì nó không xuất hiện trong sản phẩm 1 * 2 * ... * (k-1), vì vậy nó không phải là một yếu tố P. Nhưng, nếu là tổng hợp, tất cả các yếu tố chính của nó đều nhỏ hơn và do đó trong sản phẩm. Bình phương chỉ thực sự cần thiết để ngăn chặn k=4sai lầm được gọi là nguyên tố.

Mạnh mẽ hơn, nó xuất phát từ Định lý Wilson rằng khi nào klà số nguyên tố thì P%kbằng 1. Mặc dù chúng ta chỉ cần nó không khác ở đây, nhưng nói chung nó hữu ích P%klà một biến chỉ báo cho dù klà số nguyên tố.

C, 61 ký tự

Gần như chính xác như câu hỏi này (câu hỏi cũng gần như giống hệt nhau).

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

MATLAB (16) (12)

Thật không may, điều này xuất ra trên một dòng duy nhất:

primes(1000000)

nhưng điều đó được giải quyết bằng một ma trận chuyển vị đơn giản:

primes(1000000)'

và tôi có thể cắt bỏ một số ký tự bằng cách sử dụng ký hiệu số mũ (như được đề xuất trong các nhận xét):

primes(1e6)'

Bash (37 ký tự)

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

(60 ký tự)

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

trên máy tính của tôi (cpu 2.0 GHz, ram 2 GB) mất 14 giây.

J, 21 ký tự

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

có thể rút ngắn thành

1[\p:i.78498

nếu bạn biết có bao nhiêu số nguyên tố có dưới 1000000.

PowerShell, 47 44 byte

Rất chậm, nhưng ngắn nhất tôi có thể nghĩ ra.

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

PowerShell, 123 byte

Điều này nhanh hơn nhiều; xa tối ưu, nhưng một sự thỏa hiệp tốt giữa hiệu quả và ngắn gọn.

 $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

Vì saeedn sẽ không hành động theo đề nghị của tôi - cả hai đều ngắn hơn và nhanh hơn cách tiếp cận của anh ấy - tôi nghĩ tôi đã đăng câu trả lời của riêng mình:

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

Làm thế nào nó hoạt động

seq 1e6

liệt kê tất cả các số nguyên dương lên tới 1.000.000.

factor

các yếu tố từng cái một. Đối với mười đầu tiên, đầu ra là như sau:

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

Cuối cùng,

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

thay đổi toàn bộ dòng ( $0) thành sản phẩm của trường thứ hai (thừa số nguyên tố thứ nhất) và phủ định logic của trường thứ ba ( 1nếu là một thừa số nguyên tố hoặc ít hơn, 0nếu không).

Điều này thay thế các dòng tương ứng với số nguyên tố bằng chính số đó và tất cả các dòng khác bằng số không. Vì awk chỉ in các giá trị trung thực, nên chỉ số nguyên tố sẽ được in.

Ruby 50 41

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

Bash, 37

Sẽ chơi gôn nhiều hơn, nếu tôi có thể ...

Hầu hết điều này đang cố gắng phân tích factorđịnh dạng đầu ra khó xử.

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

Mất 5,7 giây để hoàn thành trên máy của tôi.

(Nó chỉ xảy ra rằng bài viết của tôi là bài đầu tiên trên trang câu trả lời thứ hai, vì vậy không ai sẽ thấy nó ...)

Giải pháp cũ

Cái này dài hơn và chậm hơn (mất 10 giây).

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

Python 3.x: 66 ký tự

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

Giải pháp hiệu quả hơn: 87 ký tự

Dựa trên sàng của 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

Thông dịch viên của tôi gặp vấn đề về bộ nhớ, nhưng nó hoạt động trên lý thuyết.

Perl, 49 byte

Biểu thức kung fu thường xuyên :)

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

Phiên bản bị đánh cắp:

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

Nó thậm chí không đạt được tiến bộ 10% trong khi tôi gõ bài đăng này!

Nguồn cho regex: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

Julia, 11

primes(10^6)

Có vẻ như những người được xây dựng đang nhận được sự ủng hộ, cộng với tôi cần nhiều từ hơn để trả lời lâu hơn.

J (15 hoặc 9)

Tôi không thể tin được nhịp này Mathicala (ngay cả khi nó chỉ là một ký tự 2 ký tự)

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

Hoặc là:

p:i.78498

gs2, 5 byte

Được mã hóa trong CP437:

∟)◄lT

1C 29đẩy một triệu, 11 6Clà số nguyên tố dưới đây, 54là dòng hiển thị.

GolfScript, 22/20 (20/19) byte

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

Với chi phí tốc độ, mã có thể được thực hiện ngắn hơn hai byte:

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

Nếu định dạng đầu ra được chỉ định trong câu hỏi đã chỉnh sửa bị bỏ qua (đó là điều mà nhiều câu trả lời hiện có làm được), hai byte có thể được lưu trong phiên bản nhanh và một có thể được lưu ở dạng chậm:

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

Điều này sẽ in một số bổ sung sau các số nguyên tố cho phiên bản nhanh và nó sẽ in các số nguyên tố dưới dạng một mảng cho số chậm.

Làm thế nào nó hoạt động

Cả hai phiên bản đều được triển khai sàng của Eratosthenes .

Phiên bản nhanh thực hiện như sau:

1. Đặt A = [ 2 3 4 … 999,999 ]và | = [ 0 1 2 … 999,999 ].

2. Đặt N = A[0]và in N.

3. Thu thập mọi phần tử N-th từ |trong C. Đây là bội số của N.

4. Đặt A = A - C.

5. Nếu Akhông trống, quay lại 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.

Phiên bản chậm hoạt động theo kiểu tương tự, nhưng thay vì loại bỏ liên tiếp các bội số tối thiểu của CÂU (luôn luôn là số nguyên tố), nó sẽ loại bỏ bội số của tất cả các số nguyên dương dưới 1.000.000.

Năng lực cạnh tranh

Trong trường hợp không có bất kỳ hàm toán học tích hợp nào để xác định hoặc kiểm tra tính nguyên thủy, tất cả các giải pháp GolfScript sẽ rất lớn hoặc rất kém hiệu quả.

Mặc dù vẫn còn xa hiệu quả, tôi nghĩ rằng tôi đã đạt được tỷ lệ tốc độ trên kích thước khá. Tại thời điểm đệ trình, phương pháp này dường như là cách ngắn nhất trong số những phương pháp không sử dụng bất kỳ nội dung nào được nói ở trên. Tôi nói dường như bởi vì tôi không biết làm thế nào một số câu trả lời hoạt động ...

Tôi đã điểm chuẩn tất cả bốn giải pháp GolfScript đã gửi: w0lf's (bộ phận dùng thử), câu trả lời khác của tôi (định lý của Wilson) và hai câu trả lời này. Đây là kết quả:

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)

APL NARS2000, 7 ký tự

⍸0π⍳1e6

Golf 26 26 24

Chỉnh sửa (đã lưu thêm một char nhờ Peter Taylor):

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

Mã cũ:

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

Mã này chỉ có giá trị lý thuyết, vì nó cực kỳ chậm và không hiệu quả. Tôi nghĩ rằng nó có thể mất nhiều giờ để chạy.

Nếu bạn muốn kiểm tra nó, hãy thử ví dụ chỉ các số nguyên tố lên tới 100:

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

CJam - 11

1e6,{mp},N*

1e6,- mảng 0 ... 999999
{mp},- chọn số nguyên tố
N*- tham gia với dòng mới

GolfScript, 25 (24) byte

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

Nếu định dạng đầu ra được chỉ định trong câu hỏi đã chỉnh sửa bị bỏ qua, một byte có thể được lưu:

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

Điều này sẽ in các số nguyên tố dưới dạng một mảng (giống như nhiều giải pháp khác làm) chứ không phải một số trên mỗi dòng.

Làm thế nào nó hoạt động

Ý tưởng chung là sử dụng định lý Wilson , trong đó nói rằng n > 1 là số nguyên tố khi và chỉ khi

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

Điểm chuẩn

Nhanh hơn phân chia thử nghiệm, nhưng chậm hơn sàng của Eratosthenes. Xem câu trả lời khác của tôi .

Java, 110 byte

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

Sử dụng phân chia unary thông qua regex như một bài kiểm tra nguyên thủy.

C, 91 88 85 82 81 80 76 72 ký tự

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

Thuật toán này cực kỳ kém hiệu quả, nhưng vì chúng tôi đang chơi golf mã không quan trọng.

Toán học 25

Giả sử bạn không biết số lượng số nguyên tố nhỏ hơn 10 ^ 6:

Prime@Range@PrimePi[10^6]

J, 16 ký tự

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

Nếu không có yêu cầu định dạng đầu ra, điều này có thể giảm xuống còn 13 ký tự:

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

1]\ chỉ cần lấy mảng số 1 của các số nguyên tố, biến nó thành mảng thứ hạng 2 và đặt mỗi số nguyên tố trên hàng riêng của nó - và do đó định dạng đầu ra mặc định của trình thông dịch biến danh sách một dòng thành một số nguyên tố trên mỗi dòng.

(#~ f) yvề cơ bản filter, trong đó ftrả về một boolean cho mỗi phần tử trong y. i.1e6là phạm vi số nguyên [0,1000000) và 1&p:là hàm boolean trả về 1 cho các số nguyên tố.

R, 45 43 ký tự

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

Đối với mỗi số x từ 2 đến 1e6, chỉ cần xuất nó nếu số x mod 2 đến x bằng 0 nhỏ hơn 2.

Bash (433643)

Nỗ lực (không thông minh) của tôi là sử dụng yếu tố để tạo ra sản phẩm.

factor ${PRODUCT}

Thật không may với số lượng lớn sản phẩm tất nhiên là rất lớn. Nó cũng mất hơn 12 giờ để chạy. Tôi quyết định đăng nó mặc dù tôi nghĩ rằng nó là duy nhất.

Đây là mã đầy đủ.

Nếu đó là số nguyên tố dưới sáu thì sẽ hợp lý.

  factor 30

Ồ tốt, tôi đã cố gắng.

C #, 70

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

Bạn sẽ không thấy nhiều ở đây mặc dù trong một thời gian dài ...