问题

阿柔Germain的素数是素数p使得2P + 1是素数为好。例如，11是Sophie Germain素数，因为23也是素数。编写最短的程序以升序计算Sophie Germain素数

规则

• Sophie Germain素数必须由您的程序生成，而不是从外部源生成。
• 您的程序必须计算2³²-1以下的所有Sophie Germain素数
• 您必须打印程序找到的每个不同的Sophie Germain质数。
• 得分最低的人获胜

计分

• 代码的每个字节2点
• 如果您可以显示程序产生的质数大于2³²-1，则为-10

贾姆

对于17个字符，我们得到的完整枚举最大为2 ^ 32：

G8#,{_mp*2*)mp},`

如果再增加4个字符，我们得到的范围就足以包含大于2 ^ 32的SG素数：

G8#K_*+,{_mp*2*)mp},`

因为4294967681 = 2 ^ 32 + 385 <2 ^ 32 + 400。

当然，我们同样可以免费扩展范围，因为

C9#,{_mp*2*)mp},`

Pyth，19个字节* 2-10 = 28

请注意，在线编译器/执行器不显示输出，因为它是一个无限循环。

K1#~K1I&!tPK!tPhyKK

解释：

K1                      K=1
  #                     While true:
   ~K1                  K+=1
      I                 If
       &                logical AND
        !tPK            K is prime
            !tPhyK      2*K+1 is prime (y is double, h is +1)
                  K     Print K

Pyth-2 * 16字节-10 = 22

在Pyth中使用惯用的素数检查方法，!tP并将其应用于数字及其安全素数，并有一点技巧，可同时检查两者。上升到10^10，所以我要加分。

f!+tPTtPhyTr2^TT

解释即将推出。

f          r2^TT     Filter from 2 till 10^10
 !                   Logical not to detect empty lists
  +                  List concatenation
   tP                All but the firs element of the prime factorization
    T                The filter element
   tP                All but the firs element of the prime factorization
    hyT              2n+1

在线尝试1000以下。

#include<stdio.h>
#include<math.h>

int isprime(int);
int main(){
    int check,n,secondcheck;
    printf("enter how long you want to print\n");
    scanf("%d",&n);
    for(int i=2;i<n;i++){
        check = isprime(i);
        if(check==0){
        secondcheck = isprime(2*i+1);
        if(secondcheck==0){
        printf("%d\t",i);
        }
        else
        continue;
        }
    }
}
int isprime(int num){   
    int check = num,flag=0;
     num = sqrt(num);
    for(int i=2;i<=num;i++){
        if(check%i==0){
            flag=1;
            return 1;
        }
    }
    if(flag==0){
        return 0;
    }
}

CJam，34（2 * 22-10）

C9#{ImpI2*)mp&{Ip}&}fI

打印Sophie Germain下的所有素数12 ** 9，包括4294967681 > 2 ** 32。

我估计这将在我的计算机上花费大约8个小时。我今晚将运行它。

Haskell中，2 * 54-10 = 98 132

i a=all((>0).rem a)[2..a-1]
p=[n|n<-[2..],i n,i$2*n+1]

i是首要检查。p取所有n都为n且2*x+1均为素数的数字。p是无限列表。

编辑：检查是否2*n+1是素数的更好方法。

朱莉娅2 * 49-10 = 88

p=primes(2^33)
print(p[map(n->isprime(2n+1),p)])

以列表格式打印它们[2,3,5,11,...]。如果使用该格式，使用该primes函数或等待所有计算完成后再打印，则在运行时每行将它们打印一次。

isprime=f
for i=1:2^33;f(i)&&f(2i+1)&&println(i)end

有点长，52个字符。两者都计算出Sophie Germain的所有素数2^33，因此应该得到10点的折扣。

Python 3中，124个 123字节

i=3
q=[2]
while 1:
 p=1
 for x in range(2,round(i**.5)+1):p=min(p,i%x)
 if p:
  q+=[i];s=(i-1)/2
  if s in q:print(s)
 i+=2

它是如何工作的？

i=3                                 # Start at 3
q=[2]                               # Create list with first prime (2), to be list of primes.
while 1:                            # Loop forever
 p=1                                # Set p to 1 (true)
 for x in range(2,round(i**0.5)+1): # Loop from 2 to the number's square root. x is the loop value
     p=min(p,i%x)                   # Set p to the min of itself and the modulo of
                                    # the number being tested and loop value (x).
                                    # If p is 0 at the end, a modulo was 0, so it isn't prime.
 if p:                              # Check if p is 0
  q+=[i]                            # Add the current number (we know is prime) to list of primes (q)
  s=(i-1)/2                         # Generate s, the number that you would double and add 1 to make a prime.

  if s in q:print(s)                # If (i-1)/2 is a prime (in the list), then that prime satifies
                                    # the condition 2p+1 is prime because i is 2p+1, and i is prime
 i+=2                               # Increment by 2 (no even numbers are prime, except 2)

在这里在线尝试。

我的计算机说，它已经生成了低于2 ^ 32的所有Sophie Germain素数的0.023283％。

完成后，如果有足够的行，我将其发布到pastebin上。您可以使用它来检查所有内容。

Perl，2 * 57-10 = 104

use ntheory":all";forprimes{say if is_prime(2*$_+1)}2**33

2
3
5
11
...
8589934091
8589934271

42秒到2 ^ 32，1分26秒到2 ^ 33。如果2*$_+1写入，运行速度将提高50％，1+$_<<1但这又是一个字节。

该模块还安装primes.pl了很多过滤器，其中包括一个用于Sophie-Germain素数的过滤器。因此：primes.pl --so 2**33（20个字节）

Ruby，61 * 2-10 = 112

require'prime';Prime.each(1.0/0)do|n|p Prime.prime?(n*2+1)end

永远打印出所有值，直到2 ** 32

编辑

减少了几个字节，将Float :: INFINITY替换为1.0 / 0

PARI / GP，46 * 2-10 = 82

forprime(p=2,2^33,if(isprime(2*p+1),print(p)))