Viết chương trình hoặc hàm xuất / trả về 10000 số nguyên tố được lập chỉ mục đầu tiên.

Nếu chúng ta gọi số nguyên tố ^thứ n p(n), danh sách này là

3, 5, 11, 17, 31, 41, 59 ... 1366661

bởi vì

p(p(1)) = p(2) = 3
p(p(2)) = p(3) = 5
p(p(3)) = p(5) = 11
p(p(4)) = p(7) = 17
...
p(p(10000)) = p(104729) = 1366661

Các lỗ hổng tiêu chuẩn bị cấm và các phương thức đầu ra tiêu chuẩn được cho phép. Bạn có thể trả lời với một chương trình đầy đủ, một chức năng được đặt tên hoặc một chức năng ẩn danh.

MATLAB / Octave, 25 byte

p=primes(2e6)
p(p(1:1e4))

Nó không nhận được nhiều đơn giản hơn thế này.

Python, 72 byte

P=p=1;l=[]
while p<82e5/6:l+=P%p*[p];P*=p*p;p+=1
for x in l:print l[x-1]

Điều này chấm dứt với "danh sách lỗi ngoài phạm vi" sau khi in 10000 số, được cho phép theo mặc định .

Sử dụng phương pháp Định lý Wilson để tạo danh sách lcác số nguyên tố lên tới số nguyên tố thứ 10000. Sau đó, in các số nguyên tố với các vị trí trong danh sách, được thay đổi 1 cho chỉ số 0, cho đến khi chúng ta hết giới hạn sau số nguyên tố thứ 10000.

Thuận tiện, giới hạn trên 1366661có thể được ước tính 82e5/6, đó là 1366666.6666666667tiết kiệm một char.

Tôi muốn một phương pháp một vòng lặp, in các số nguyên tố được lập chỉ mục chính khi chúng ta thêm chúng, nhưng dường như nó dài hơn.

P=p=1;l=[]
while p<104730:
 l+=P%p*[p]
 if len(l)in P%p*l:print p
 P*=p*p;p+=1

J, 11 byte

p:<:p:i.1e4

Xuất ra các số nguyên tố ở định dạng

3 5 11 17 31 41 59 67 83 109 127 ...

Giải trình

        1e4  Fancy name for 10000
      i.     Integers from 0 to 9999
    p:       Index into primes: this gives 2 3 5 7 11 ...
  <:         Decrement each prime (J arrays are 0-based)
p:           Index into primes again

Toán học, 26 25 23 byte

Prime@Prime@Range@1*^4&

Hàm thuần trả về danh sách.

Haskell, 65 byte

p=[x|x<-[2..],all((>0).mod x)[2..x-1]]
f=take 10000$map((0:p)!!)p

Đầu ra: [3,5,11,17,31,41,59,67,83,109,127.....<five hours later>...,1366661]

Không nhanh lắm. Cách thức hoạt động: plà danh sách vô hạn các số nguyên tố (kiểm tra một cách ngây thơ tất cả mod x ys cho y in [2..x-1]). Lấy các 10000phần tử đầu tiên của danh sách bạn nhận được khi 0:p!!(phần tử thứ n của p) được ánh xạ vào p. Tôi phải điều chỉnh danh sách các số nguyên tố mà tôi lấy các phần tử từ bằng cách thêm một số (-> 0:), vì hàm chỉ mục ( !!) không dựa trên.

PARI / GP, 25 byte

apply(prime,primes(10^4))

AWK - 129 byte

... oookay ... quá lâu để giành điểm vì sự gọn nhẹ ... nhưng có lẽ nó có thể đạt được một số danh dự cho tốc độ?

Các xtập tin:

BEGIN{n=2;i=0;while(n<1366662){if(n in L){p=L[n];del L[n]}else{P[p=n]=++i;if(i in P)print n}j=n+p;while(j in L)j=j+p;L[j]=p;n++}}

Đang chạy:

$ awk -f x | nl | tail
  9991  1365913
  9992  1365983
  9993  1366019
  9994  1366187
  9995  1366327
  9996  1366433
  9997  1366483
  9998  1366531
  9999  1366609
 10000  1366661

Có thể đọc được

BEGIN {
        n=2
        i=0
        while( n<1366662 ) {
                if( n in L ) {
                        p=L[n]
                        del L[n]
                } else {
                        P[p=n]=++i
                        if( i in P ) print n
                }
                j=n+p
                while( j in L ) j=j+p
                L[j]=p
                n++
        }
}

Chương trình tính toán một dòng các số nguyên tố sử dụng Lnhư "băng số" giữ các số nguyên tố tìm thấy nhảy xung quanh Lđể gắn cờ các số gần đó đã biết có một ước số. Các số nguyên tố nhảy này sẽ tiến lên trong khi "băng số" Lbị cắt nhỏ theo số từ đầu.

Trong khi cắt đầu băng L[n]trống rỗng có nghĩa là không có ước số (số nguyên tố) đã biết.

L[n]giữ một giá trị có nghĩa là, giá trị này là một số nguyên tố và được biết để chia n.

Vì vậy, hoặc chúng tôi đã tìm thấy một ước số nguyên tố hoặc một số nguyên tố mới. Sau đó, số nguyên tố sẽ được chuyển sang phần tiếp theo L[n+m*p]trên băng được tìm thấy trống.

Điều này giống như Sàng của Eratosthenes "kéo qua một chai Klein". Bạn luôn luôn hành động trên băng bắt đầu. Thay vì bắn nhiều số nguyên tố qua băng, bạn sử dụng các số nguyên tố đã được tìm thấy khi các con trỏ nhảy ra khỏi băng bắt đầu bằng nhiều khoảng cách giá trị của chúng cho đến khi tìm thấy vị trí tự do.

Mặc dù vòng lặp bên ngoài tạo ra một số nguyên tố hoặc không phải là số nguyên tố trên mỗi vòng lặp, các số nguyên tố được tìm thấy được tính và được lưu trữ Pdưới dạng khóa, giá trị của cặp (khóa, giá trị) này không phù hợp với luồng chương trình.

Nếu khóa của chúng ixảy ra trong P( i in P), chúng ta có một nguyên tố của giống p (p (i)).

Đang chạy:

$ time awk -f x.awk | wc -l
10000

real    0m3.675s
user    0m3.612s
sys     0m0.052s

Hãy xem xét rằng mã này không sử dụng các bảng nguyên tố tiền định sẵn bên ngoài.

Thời gian dành cho Thinkpad T60 cũ tốt của tôi, vì vậy tôi nghĩ rằng nó xứng đáng được gọi là nhanh.

Đã thử nghiệm với mawkvà gawktrên Debian8 / AMD64

CJam, 19

3D#{mp},_1e4<:(\f=p

Bạn có thể thử trực tuyến , nhưng bạn sẽ cần một chút kiên nhẫn: p

Đối với hồ sơ, số cuối cùng là 1366661.

Perl, 55 byte

use ntheory':all';forprimes{print nth_prime$_,$/}104729

Sử dụng mô-đun của @DanaJMath::Prime::Util cho perl (được tải với pragma ntheory). Nhận nó với:

cpan install Math::Prime::Util
cpan install Math::Prime::Util::GMP

05AB1E, 7 byte (không cạnh tranh)

Mã số:

4°L<Ø<Ø

Hãy thử trực tuyến! , lưu ý rằng tôi đã thay đổi 4thành a 2. Nếu bạn có nhiều thời gian, bạn có thể thay đổi 2trở lại 4, nhưng điều này sẽ mất rất nhiều thời gian. Tôi cần phải nhanh chóng thuật toán cho việc này.

Giải trình:

4°       # Push 10000 (10 ^ 4)
  L      # Create the list [1 ... 10000]
   <     # Decrement on every element, [0 ... 9999]
    Ø    # Compute the nth prime
     <   # Decrement on every element
      Ø  # Compute the nth prime