这是我的第一个高尔夫问题代码，也是一个非常简单的问题，因此，如果我可能违反了任何社区准则，我事先表示歉意。

任务是按升序打印所有小于一百万的质数。输出格式应为每行输出一个数字。

与大多数代码高尔夫球提交一样，其目的是最小化代码大小。针对运行时进行优化也是一个奖励，但它是次要目标。

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)'

重击（37个字符）

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

（60个字符）

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

在我的计算机上（2.0 GHz CPU，2 GB内存）需要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％的进步！

正则表达式的来源：http : //montreal.pm.org/tech/neil_kandalgaonkar.shtml

朱莉娅11岁

primes(10^6)

似乎内置组件正在获得好评，再加上我需要更多的单词才能获得更长的答案。

J（15或9）

我不能相信这一掌数学（即使它只是一个由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个元件|在C。这些是的倍数N。

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（试验部门），我的其他答案（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

高尔夫脚本26 25 24

编辑（感谢Peter Taylor，又节省了一个字符）：

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

旧代码：

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

该代码仅具有理论价值，因为它非常慢且效率低下。我认为可能要花几个小时才能运行。

如果要测试，请尝试仅使用最多100的素数：

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

果酱-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"));}

通过正则表达式使用一元除法作为素数测试。

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]\ 只需将素数的第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," ")

对于从2到1e6的每个数字x，如果x mod 2到x的x等于0的数量小于2，则只需输出。

重击（433643）

我的尝试（不是那么聪明）是使用factor来分解产品。

factor ${PRODUCT}

不幸的是，大量产品当然是巨大的。运行还花费了超过12个小时。我决定发布它，因为我认为它是独一无二的。

这是完整的代码。

如果素数小于六，那将是合理的。

  factor 30

哦，我尝试过。

C＃，70

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

你不会在这里看到很多东西了...