编写一个程序或函数，以输出/返回前10000个素数索引质数。

如果我们称第n ^个素数p(n)，则此列表为

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

因为

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

禁止出现标准漏洞，并允许使用标准输出方法。您可以使用完整程序，命名函数或匿名函数来回答。

MATLAB / Octave，25个字节

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

没有比这更直接的了。

Python，72个字节

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]

在打印10000个数字后，这会以“列表索引超出范围错误”结束，默认情况下允许使用。

使用威尔逊定理方法生成l最多至第10000个素数的素数列表。然后，打印具有列表中位置的素数，将其移位1以进行零索引，直到我们在第10000个素数之后超出边界为止。

方便地，1366661可以估计的上限82e5/6为1366666.6666666667，节省一个字符。

我想要一种单循环方法，在我们添加素数索引质数时将其打印出来，但是似乎更长。

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个字节

p:<:p:i.1e4

以以下格式输出素数

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

说明

        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

Mathematica，26 25 23字节

Prime@Prime@Range@1*^4&

纯函数返回列表。

Haskell，65个字节

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

输出： [3,5,11,17,31,41,59,67,83,109,127.....<five hours later>...,1366661]

不太快。它p是如何工作的：是质数的无限列表（天真地检查mod x yy中所有s [2..x-1]）。10000取得0:p!!（的第n个元素p）映射到时获得的列表的第一个元素p。我必须在素数列表前加上一个数字（-> 0:）来调整素数列表，因为索引函数（!!）基于零。

PARI / GP，25个字节

apply(prime,primes(10^4))

AWK-129字节

... oookay ...为紧凑而赢得积分的时间太长了...但是也许它可以因为速度而获得一些荣誉？

该x文件中：

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++}}

运行：

$ 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

可读性：

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++
        }
}

该程序使用L“数字带” 计算素数流，保持发现的素数不断跳L来标记附近已知有除数的数。这些跳跃的素数将继续前进，而“数字带” L将从一开始就被数字切掉。

切掉L[n]空的磁带头意味着没有已知的（质数）除数。

L[n]持有一个值意味着，这个值是质数，并且已知可以除n。

因此，我们找到了素数除数或新质数。然后，素数将前进到L[n+m*p]发现空的磁带上的下一个。

就像是Eratosthenes筛子“通过Klein的瓶子拉过”一样。您总是对磁带开始起作用。您无需使用遍历磁带的多个素数，而可以使用已经发现的素数，因为从磁带上跳下来的光标会以其自身值的多个距离开始，直到找到一个自由位置。

虽然外部循环在每个循环中生成一个素数决定或不素数决定，但是找到的素数被计数并存储P为键，但此（键，值）对的值与程序流无关。

如果它们的键i刚好在P（i in P）中，则我们具有p（p（i））素数。

运行：

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

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

请注意，此代码不使用外部预先计算的素数表。

我的旧ThinkPad T60需要花费时间，因此我认为它应该被称为快速。

经测试mawk，并gawk在Debian8 / AMD64

19岁的CJam

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

您可以在线尝试，但需要一点耐心：p

记录下来，最后一个数字是1366661。

Perl，55个字节

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

对perl 使用@DanaJ的Math::Prime::Util模块（随pragma一起加载ntheory）。通过以下方式获取：

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

05AB1E，7个字节（非竞争）

码：

4°L<Ø<Ø

在线尝试！，请注意，我已将更改4为2。如果您有很多时间，可以将其更改2为4，但这会花费很多时间。我需要为此固定算法。

说明：

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