소수를 찾는 것은 프로그래밍의 전례이며, 종종 누군가가 처음 시도하는 심각한 프로그램입니다 (보통 시험 분할).

그러나 소수는 이미 마모되었습니다. 다음으로 더 흥미로운 것은 소수의 격차를 얻는 것입니다 : 연속적인 소수 사이의 가장 긴 간격. 이들은 매우 희귀하고 "귀중한"것입니다. 처음 몇 쌍과 그 차이점은 다음과 같습니다.

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
...

아버지는 10K까지의 재미를 위해 이것을 손으로 계산했습니다. 코드가 얼마나 짧은 지 보자.

규칙 :

• 프라임 테스트, 프라임 생성 또는 프라임 갭을위한 내장 함수 없음
• http://oeis.org/A002386 또는 이와 유사한 정보를 검색하지 않음 (원격에서 사기꾼 냄새를 맡을 수 있습니다 :))
• 사전 계산 된 배열이 없음
• 내부 정수 유형이 실패 할 때까지 계속 인쇄

캐릭터 수가 가장 적습니다. 소수없이 공백 만 인쇄하는 경우 +10 자

내장 함수가있는 버전을 흥미로울 수도 있습니다. 창의력을 발휘하십시오.

설명 : 소수를 살펴보고 이전에 본 격차보다 큰 격차를 볼 때마다보고합니다. 예를 들어, 3에서 5 사이의 너비는 2 단위입니다. 5와 7 사이의 격차도 2이지만 오래된 뉴스입니다. 더 이상 걱정하지 않습니다. 새로운 가장 큰 차이가있을 때만보고합니다. 이것은 격차가 넓어지고 넓어짐에 따라 소수가 점점 줄어들고 있음을 반영합니다.

편집 : 대부분의 답변은 훌륭하고 더 많은 인정을받을 가치가 있습니다. 그러나 지금까지 48 자로 된 GolfScript 항목이 가장 짧습니다.

GolfScript 66 59 57 49 48

[2.0{:d{;\;.{).{(1$1$%}do(}do.2$-.d>!}do].p~.}do

여기에서 http://golfscript.apphb.com/을 실행하는 데 문제가 있지만 (사이트는 무한 루프를 좋아하지 않습니까?) golfscript.rb를 사용하여 컴퓨터에서 실행할 때 제대로 작동합니다. 저는 GolfScript를 처음 사용하므로 골프를 더 많이 할 수 있습니다. 업데이트 : 알고리즘을 변경하지 않고도 이것이 훨씬 더 많이 줄어들 수 있다고 생각하지 않습니다.

처음 몇 줄이 인쇄됩니다 ( ""인쇄가 마음에 들지 않으면 스크립트의 시작 부분에 추가 할 수 있지만 최대 49 자까지 가능합니다) :

[2 3 1]
["" 3 5 2]
["" 7 11 4]
["" 23 29 6]
["" 89 97 8]
["" 113 127 14]
["" 523 541 18]
["" 887 907 20]
["" 1129 1151 22]
...

이것이 어떻게 작동하는지에 대한 일반적인 사람이 읽을 수있는 아이디어 (이 버전에서는 스택을 사용하지 않기 때문에 약간 다릅니다) :

cur_prime = 2
next_prime = 2
gap = 0        

do {
    do {
        cur_prime = next_prime
        do {
            next_prime = next_prime + 1
            possible_factor = next_prime
            do {
                possible_factor = possible_factor - 1
            } while (next_prime % possible_factor > 0)
        } while (possible_factor != 1)
    } while (next_prime - cur_prime <= gap)

    gap = next_prime - cur_prime
    print [cur_prime next_prime gap]
} while (true)

파이썬 121 개 110 109 108 104 103 문자

p,n,m=[2],3,0
while 1:
 if all(n%x for x in p):
  c=n-p[0]
  if m<c:m=c;print(p[0],n,c)
  p=[n]+p
 n+=1

처음 여기에 대답하려고했을 때, 나는 그것을 올바르게했으면 좋겠다.

흠, 파이썬 2.x로 다운 그레이드하여 인쇄물에 다른 문자를 저장할 수 있습니다 ...

자바 스크립트, 90 85 78 74 자

짧은 코드 (Google Closure Compiler-고급 최적화, 일부 수동 편집, @ MT0 추가 편집 )

for(a=b=2,c=0;b++;)for(d=b;b%--d;)d<3&&(c<b-a&&console.log(a,b,c=b-a),a=b)

긴 코드

var lastPrime = 2,
    curNumber = lastPrime,
    maxDistance = 0,
    i;

// check all numbers
while( curNumber++ ) {

  // check for primes
  i = curNumber;
  while( curNumber % --i != 0 ) {}

  // if prime, then i should be equal to one here
  if( i == 1 ) {

    // calc distance
    i=curNumber-lastPrime;

    // new hit
    if( maxDistance < i ) {
      maxDistance = i;
      console.log( lastPrime, curNumber, maxDistance );
    }

    // remember prime
    lastPrime = curNumber;
  }
}

산출

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52
31397 31469 72
...

소수에 대해서는 매우 비효율적 인 테스트이지만 더 적은 문자를 사용합니다.

^{여기에 첫 번째 게시물이므로 실수를 용서하십시오.}

매스 매 티카, 114 108

시퀀스의 특정 지점이 지나면 팬이 회전하고 CPU가 프리셀을 재생하는 동안 바쁘게 보이도록 최선을 다하고 있음을 의심하기 시작하지만 무한 출력을 허용합니다.

p@x_:=NestWhile[#+1&,x+1,Divisors@#≠{1,#}&];m=0;q=1;While[1<2,If[p@q-q>m,Print@{q,p@q,p@q-q};m=p@q-q];q=p@q]

출력 샘플 (이것은 처음 ~ 30 초에 픽업 된 샘플입니다) :

{1,2,1}
{3,5,2}
{7,11,4}
{23,29,6}
{89,97,8}
{113,127,14}
{523,541,18}
{887,907,20}
{1129,1151,22}
{1327,1361,34}
{9551,9587,36}
{15683,15727,44}
{19609,19661,52}
{31397,31469,72}
{155921,156007,86}
{360653,360749,96}
{370261,370373,112}
{492113,492227,114}
{1349533,1349651,118}
{1357201,1357333,132}
{2010733,2010881,148}

Ungolfed 코드 :

p@x_ := NestWhile[
   # + 1 &,
   x + 1,
   Divisors@# ≠ {1, #} &];
m = 0;
q = 1;
While[
 1 < 2,
 If[
  p@q - q > m,
  Print@{q, p@q, p@q - q}; m = p@q - q];
 q = p@q]

하스켈 - 122 116 114 112 110

q=[n|n<-[3..],all((>0).rem n)[2..n-1]]
d m((p,q):b)|q-p>m=print(p,q,q-p)>>d(q-p)b|q>p=d m b
main=d 0$zip(2:q)q

Will Ness 에서 도난당한 (비효율적 인) 프라임리스트 표현 .

-편집-나는 x|y=z|w=q유효한지 몰랐다 .

MATLAB 104 89

가능한 모든 부서를 확인하여 기본 방법을 구현했습니다.

a=2;g=0;for n=3:inf;b=n*(sum(mod(n,1:n)<1)<3);h=b-a;if(h>g)g=h;[a,b,h]
end;a=max(a,b);end

산출:

  2     3     1
  3     5     2
  7    11     4
 23    29     6
 89    97     8
113   127    14
523   541    18
887   907    20

도 렐랑 76 자

내 파이썬 버전 에서 변환 :

g=0
i=l=2
while i+=1=>all$map(i%)(2..i)=>(i-l>g=>(g=i-l),print(l,i,g)),(l=i)

산출:

(2, 3, 1)
(3, 5, 2)
(7, 11, 4)
(23, 29, 6)
(89, 97, 8)
(113, 127, 14)
(523, 541, 18)
(887, 907, 20)
(1129, 1151, 22)
...

골프 스크립트, 59 51 50 자

각 캐릭터는 잃기 매우 어렵습니다.

0[2.{).,2>{\.@%!},{.2$-.4$>{].p~\[}{;\;}if..}or}do

출력 :

[2 3 1]
[3 5 2]
[7 11 4]
[23 29 6]
[89 97 8]
[113 127 14]
...

설명 :

스택은 각 반복이 이와 같은 스택으로 시작하도록 설정되며 상단은 오른쪽입니다. 은 [통역자가 발생할 때 즉, 현재의 배열을 나타내는 마커 ]배열에 넣고 가기 마크로부터 스택에 다.

g [ last | cur

g지금까지 최대 간격입니다. 위에서 아래로 :

 command         | explanation
-----------------+----------------------------------------
 0[2.            | initialize vars g=0, last=2, cur=2
 {...}do         | loop forever...

루프 내부 :

 )               | cur += 1
 .,2>{\.@%!},    | put all divisors of cur into a list
 {...}or         | if the list is empty, cur is prime, so
                 | the block is executed. otherwise,
                 | 'do' consumes the stack, sees it is truthy,
                 | and loops again

모든 제수를 목록에 어떻게 넣습니까? 단계별로 해보자

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack                                | n
 .,              | make list of 0..n-1                          | n [0,1,...,n-1]
 2>              | take elements at index 2 and greater         | n [2,3,...,n-1]
 {...},          | take list off stack, then iterate through    |
                 | the list. on each iteration, put the current |
                 | element on the stack, execute the block, and |
                 | pop the top of the stack. if the top is      |
                 | true then keep the element, else drop it.    |
                 | when done, push list of all true elements    |
                 | So, for each element...                      | n x
   \.            |   Swap & dup                                 | x n n 
   @             |   Bring x around                             | n n x
   %             |   Modulo                                     | n (n%x)
   !             |   Boolean not. 0->1, else->0. Thus this is 1 |
                 |   if x divides n.                            | n (x divides n)
                 | So only the divisors of n are kept           | n [divisors of n]

제수가 비어 있으면 어떻게합니까?

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack                                | g [ last | cur
  .              | dup                                          | g [ l | c | c
  2$             | copy 3rd down                                | g [ l | c | c | l
  -              | sub. This is the current gap, cur-last       | g [ l | c | c-l
  .              | dup                                          | g [ l | c | c-l | c-l
  4$             | copy 4th down                                | g [ l | c | c-l | c-l | g
  >              | is cur gap > max gap so far?                 | g [ l | c | c-l | c-l>g
  {#1}{#2}if..   | #1 if c-l > g, #2 otherwise, and do ".." in  | ... | g [ c | c | c
                 | either situation                             | 

두 가지 경로 : 예와 아니오. 예인 경우 ( if스택에서 최상위 값 을 소비 함)

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack. note that now the old `g` is  | XX [ l | c | g
                 | garbage and `c-l` is the new `g`.            |
 ]               | close the array                              | XX [l, c, g]
 .p              | duplicate it and print it, consuming the dup | XX [l, c, g]
 ~               | pump array back onto the stack. Note now the | XX | l | c | j
                 | array marker [ is gone.                      | 
 \               | swap.                                        | XX | l | g | c                         
 [               | mark the array                               | XX | l | g | c [
 .               | this is the part after the if. dups the top, | XX | l | g [ c | c
                 | but it does this in two steps, first popping | 
                 | c then putting two copies on top, so the     | 
                 | array marker moves                           | 
 .               | dup again                                    | XX | l | g [ c | c | c

그렇지 않은 경우 :

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack. In this case g is still the   | g [ l | c | c-l
                 | max gap so far                               | 
 ;\;             | dump top of stack, swap, and dump again      | g [ c
 ..              | the part after the if. dup twice             | g [ c | c | c

두 경우 모두 스택은 이제 형식 ... | g [ c | c | c입니다.

이제는 do스택에서 최상위 값을 팝하고 항상 c양수이면 루프합니다. c항상 증가 하기 때문에 이것은 항상 사실이므로 영원히 반복됩니다.

팝되면, 스택의 상단이되고 g [ c | c, 마지막으로 업데이트되었습니다하는 의미 c, 배열 마크는 같은 장소에서, 그리고 g우리가 그것을 기대하는 곳 아직도있다.

이것들은 복잡한 GolfScript 작업입니다. 나는 당신이 함께 따라 즐기기를 바랍니다!

루비, 110

다음 lazy방법 으로 인해 Ruby 2.0에만 해당됩니다 .

(2..1.0/0).lazy.select{|n|!(2...n).any?{|m|n%m==0}}.reduce([2,0]){|(l,t),c|d=c-l;p [l,c,d]if d>t;[c,d>t ?d:t]}

산출:

[2, 3, 1]
[3, 5, 2]
[7, 11, 4]
[23, 29, 6]
[89, 97, 8]
[113, 127, 14]
[523, 541, 18]
[887, 907, 20]
[1129, 1151, 22]
[1327, 1361, 34]
[9551, 9587, 36]
[15683, 15727, 44]
[19609, 19661, 52]
[31397, 31469, 72]
[155921, 156007, 86]
[360653, 360749, 96]
[370261, 370373, 112]
[492113, 492227, 114]
...

펄, 105 바이트

$p=2;$d=0;L:for($i=2;++$i>2;){!($i%$_)&&next L for 2..$i-1;if($i-$p>$d){$d=$i-$p;print"$p $i $d\n"}$p=$i}

언 골프 드 :

$p = 2;
$d = 0;
L: for ($i = 2; ++$i > 2; ){
    !($i % $_) && next L for 2..$i-1;
    if ($i - $p > $d) {
        $d = $i - $p;
        print "$p $i $d\n"
    }
    $p = $i
}  

알고리즘은 간단 $p하며 이전 소수를 기억합니다. 그런 다음 $ i 유형이 "나에게 실패"하거나 오버플로로 인해 음수가되면 위로 올라 $i갑니다 3. $i모든 제수를 2에서$i-1 . 현재 차이가 이전 인쇄 차이보다 큰 경우 선이 인쇄됩니다 $d.

더 많은 바이트를 사용하면 런타임을 향상시킬 수 있습니다.

$p = 2;
$d = 0;
L: for ($i=3; $i > 2; $i += 2){
    for ($j=3; $j <= sqrt($i); $j += 2){
        next L if !($i%$j)
    }
    if ($i - $p > $d) {
        $d = $i - $p;
        print "$p $i $d\n"
    }
    $p = $i
}

결과 로 시작

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52
31397 31469 72
155921 156007 86
360653 360749 96
370261 370373 112
492113 492227 114
1349533 1349651 118
1357201 1357333 132
2010733 2010881 148
4652353 4652507 154
17051707 17051887 180
20831323 20831533 210
47326693 47326913 220
...

파이썬, 93 91 문자

순진한 프라임 검사 (2에서 n(로 미만의 문자 n/2) 로 나눌 수 있는지 확인 ) :

g=0;i=l=2
while 1:
 i+=1
 if all(i%x for x in range(2,i)):
    if i-l>g:g=i-l;print l,i,g
    l=i

들여 쓰기의 두 번째 수준은 하나의 탭 문자입니다.

산출:

2 3 1
5 7 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
...

프라임 정규식에 대한 Bash 및 일부 Perl ( 167157143112112 바이트)

n=2
c=2
while p=$c
do perl -e\(1x$[++n]')=~/^(11+?)\1+$/&&exit 1'&&c=$n
((c-p>g))&&g=$[c-p]&&echo $p $c $g
done

일부 출력 :

$./golfd.sh
2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22

펄 95 90 바이트

for($n=$c=2;$p=$c;$c-$p>$g&&printf"$p $c %d\n",$g=$c-$p){$c=$n if(1x++$n)!~/^(11+?)\1+$/}

오래된 비 골프 버전 :

$n=$c=2;
while($p=$c){
    $c=$n if (1x++$n)!~/^(11+?)\1+$/;
    if ($c-$p>$g) {$g=$c-$p;print "$p $c $g\n"}
}

이것은 다른 제출물 인 sans bash와 비슷합니다.

C (100)

내 자신의 공헌, 특별한 알고리즘, 골프 :

i,g,r,p=2;main(){for(;r=p;p-r>g?printf("%d %d %d\n",r,p,g=p-r):0)for(i=0;i-p;)for(i=1,++p;p%++i;);}

하스켈, 134C

골프 :

c n=null[x|x<-[2..n-1],n`mod`x==0]&&n>1
p=filter c[1..]
g l(m:n:o)
 |(n-m)>l=do print(m,n,n-m);g(n-m)(n:o)
 |True=g l(n:o)
main=g 0 p

언 골프 드 :

-- c function checks if n is a prime number
c n=null[x|x<-[2..n-1],n`mod`x==0]&&n>1

-- p is an infinite list of primes
p=filter c[1..]

-- g function prints a list of primes and differences.
--   l is the maximum difference seen so far
--   (m:n:o) is the list of unprocessed primes
g l(m:n:o)
 |(n-m)>l=do print(m,n,n-m);g(n-m)(n:o)
 |True=g l(n:o)

-- main starts the ball rolling with a default max-seen value of 0
main=g 0 p

C : 493 302 272 246

int e(int j){for(int i=2;i<j;i++)if(j%i<1)return 0;return 1;}void f(int a,int b,int c){if(e(a)&e(b))if(c<b-a){printf("%d %d %d\n",a,b,b-a);f(a+1,b+1,b-a);}else f(a+1,b+1,c);if(e(b))f(a+1,b,c);if(e(a))f(a,b+1,c);f(a+1,b+1,c);}int main(){f(2,3,0);}

나는하지의 일반적인 루프를 재귀를 사용 for하거나 while.

int isPrime(int num){
    for( int i=2; i<num; i++ )
        if(num%i < 0) return 0;
    return 1;
}
void fun(int n1, int n2, int gap){
   if( isPrime(n1) & isPrime(n2) ){
        if( gap < n2-n1 ){
           printf("%d %d %d\n", n1, n2, n2-n1);
           fun(n1+1, n2+1, n2-n1);
        }else{
           fun(n1+1, n2+1, gap);
        }
   }
   if( isPrime(n2) ){
       fun(n1+1, n2, gap);
   }
   if( isPrime(n1) ){
       fun(n1, n2+1, gap);
   }
   fun(n1+1, n2+1, gap);
}

int main(){
   fun(2,3,0);
}

산출:

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52

오라클 SQL, 216 (202) 196 172 + 10 = 182

질문에서 이것을 발견했습니다.

캐릭터 수가 가장 적습니다. 소수없이 공백 만 인쇄하는 경우 +10 자

이것이 SQL이고 키워드가 너무 길기 때문에 실제로 다음과 같이 패널티를 취하는 것이 좋습니다. 원본과 같은 생각입니다.

with c as(select level+1n from dual connect by level<1e124)select lead(n)over(order by n) from(select*from c a where not exists(select*from c where n<a.n and mod(a.n,n)=0))

다음과 같이

with c as ( 
 select level + 1 n 
   from dual 
connect by level < 1e124
        )
select lead(n) over ( order by n ) 
  from ( select *
           from c a 
          where not exists( select * 
                              from c 
                             where n < a.n 
                               and mod(a.n, n) = 0
                                   )
                )

옛 대답 (196)

with c as(select level+1n from dual connect by level<1e124)select n,p,p-n from(select n,lead(n)over(order by n)p from(select*from c a where not exists(select*from c where n<a.n and mod(a.n,n)=0)))

그리고 읽을 수있는 형식으로 :

with c as ( 
 select level + 1 n 
   from dual 
connect by level < 1e124
        )
select n, p, p-n 
  from ( select n, lead(n) over ( order by n ) p 
           from ( select * 
                    from c a 
                   where not exists (
                                select * 
                                  from c
                                 where n < a.n 
                                   and mod(a.n, n) = 0
                                       )
                         )
                )

이것은 숫자 생성기를 만듭니다 c 내부 , 가장 안쪽의 하위 선택은 에라토스테네스의 체 (Sieve of Eratosthenes)를 사용하여 소수를 생성하고, 외부는 이전 소수를 계산하고 마지막으로 마지막 선택을 서로 빼냅니다.

1 x 10 ¹²⁴ 재귀 쿼리를 수행하기 때문에 아무것도 반환하지 않습니다 . 따라서이 숫자를 합리적인 것으로 낮추려면 작동합니다.

D-153 + 10 = 163

나는 여기에 +10의 페널티를 기꺼이 받는다. 왜냐하면 소수는 내가 소수를 인쇄했을 때보 다 여전히 적기 때문이다.

골프 :

import std.stdio;bool p(int l){int n;foreach(i;1..l+1)n+=l%i==0?1:0;return n==2;}void main(){int g;foreach(l;0..int.max)if(l.p){if(g>0)(l-g).write;g=l;}}

읽을 수있는 버전 :

import std.stdio;

bool prime( int number )
{
    int divisors;

    foreach( i; 1 .. number + 1 )
        divisors += number % i == 0 ? 1 : 0;

    return divisors == 2;
}

void main()
{
    int lastPrime;

    foreach( number; 0 .. int.max )
        if( number.prime )
        {
            if( lastPrime > 0 )
                ( number - lastPrime ).write;

            lastPrime = number;
        }
}

자바 174 문자

var p=[2],l=2,g=0;
for(var n=3;n>0;n+=2){
  var o=0;
  for(var t=0;t<p.length;++t){
    if(n/p[t] == parseInt(n/p[t])){
      o=1;
    }
  }
  if(o==0){
    p.push(n);
    if(n-l>g){
      g=n-l;
      console.log(l,n,g);
    }
    l=n;
  }
}

짧은 버전 :

var p=[2],l=2,g=0;for(var n=3;n>0;n+=2){var o=0;for(var t=0;t<p.length;++t){if(n/p[t] == parseInt(n/p[t])){o=1;}}if(o==0){p.push(n);if(n-l>g){g=n-l;console.log(l,n,g);}l=n;}}

자바 스크립트 138

for(var a=2,b=0,c=0;a++;){var d;a:{for(var e=a,f=2;f<e;f++)if(0==e%f){d=!1;break a}d=!0}d&&(0!=b&&a-b>c&&(c=a-b,console.log(b,a,c)),b=a)}

이 코드를 브라우저 콘솔에 복사하십시오. 최대 숫자가 주변에 있기 때문에 영원히 좋아할 것 1.79*10^308입니다.

언 골프 드 :

var number = 2;
var lastPrime = 0;
var gap = 0;

while(number++)
{
    if (isPrime(number)) {
        if (lastPrime != 0) {            
            if (number - lastPrime > gap)
            {
                gap = number - lastPrime;
                console.log(lastPrime, number, gap);
            }
        }

        lastPrime = number;
    }
}

function isPrime(n){
    for (var i = 2; i < n; i++) {
        if (n % i == 0)
            return false;
    }
    return true;
}

C 번호 162 161 문자

151 자 + 페널티 문자 10 = 161 자

짧은 버전 :

using System;class P{static void Main(){int p=2,g=0;for(int i=3;;i++){for(int j=2;j<i;j++)if(i%j==0)goto e;if(i-p>g)Console.WriteLine(g=i-p);p=i;e:;}}}

긴 버전 :

using System;

class PrimeGaps
{
    private static void Main()
    {
        int lastPrime = 2;
        int largestGap = 0;

        for (int i = 3; true; i++)
        {
            // Prime test
            for (int j = 2; j < i; j++)
                if (i%j == 0)
                    goto nextI; // Skip to next iteration of i

            // Largest gap check
            if (i - lastPrime > largestGap)
            {
                largestGap = i - lastPrime;
                Console.WriteLine(largestGap);
            }

            // Remember last prime
            lastPrime = i;

            nextI:
                ; // Do nothing
        }
    }
}

실제로는 10 문자 페널티를받는 것이 더 낫습니다. 왜냐하면 g페널티가 p+" "+i+" "+g없는 13 문자 보다 쓰기가 짧기 때문 입니다.

루비 90 86 84 83 자

r,i,g=2,2,0;while i+=1 do(2...i).all?{|j|i%j>0}&&((i-r<=g||p([r,i,g=i-r]))&&r=i)end

부울 단락, 표현 평가 남용 등

C 248

코드는 연속 소수 a, b를 비교 한 다음 간격이 g보다 큰지 확인한 후 다음 소수 쌍을 찾습니다.

#include <cstdio>
void f(int* a, int* b){*a =*b;int t=1;while (*b += 2){t=1;for(int i=3;i<*b;i+=2){if(*b%i==0){t=0; break;}}if(t)break;}}
int main(){int a=2,b=3,g=0;do{(b-a>g)?printf("%d %d %d\n",a,b,(g=b-a)): f(&a,&b);} while(b>=0);return 0;}

하스켈 154 144 137 123

프라임 p은 에라 스토 텐의 체를 사용하여 생성 된 #후를 사용하여 여과하고 인쇄 %합니다.

p=2:3#1
n#m|all((>0).mod n)$take m p=n:(n+1)#(m+1)|1<2=(n+1)#m
(l:u@(o:_))%k|o-l>k=print(l,o,o-l)>>u%(o-l)|1<2=u%k
main=p%0

출력은 다음과 같습니다

(2,3,1)
(3,5,2)
(7,11,4)
(23,29,6)
(89,97,8)

내가 바라는 것은 괜찮습니다.

게임 메이커 언어, 85

초기화되지 않은 모든 변수를 다음과 같이 가정합니다 0(일부 버전의 Game Maker에서는 기본값 임).

a=2b=2for(d=2;b++;1)for(c<b-a;b mod --d;1)d<3&&(c=b-a&&show_message_ext("",a,b,c)a=b)

게임 메이커 언어, 74 + 55 = 129

초기화되지 않은 모든 변수를 다음과 같이 가정합니다 0(일부 버전의 Game Maker에서는 기본값 임).

n=2while(n++){if p(n){if l{if n-l>g{g=n-l;show_message_ext("",l,n,g)}}l=n}

스크립트 p는 다음과 같습니다.

r=1a=argument0for(i=2i<a;i++){if a mod i=0r=0}return r}

Perl, 87 바이트 ( 모듈 사용 )

use Math::Prime::Util":all";$l=2;forprimes{if($_-$l>$m){say"$l $_ ",$m=$_-$l}$l=$_}1e14

모듈을 작성했지만 탈리에 565,000자를 추가해야합니다. 대부분 재미를 위해 게시하지만 내장 기능을 사용하여 지금까지 볼 수 없으므로 성능 대안을 제공합니다. 1e9까지 갭은 4.6 초, 1e10까지 갭은 36 초, 1e11은 6.5 분.

Pari / GP 2.8은 기본적으로 동일한 방식으로 수행 할 수 있지만 2 배 이상 느립니다.

l=2;m=0;forprime(p=2,1e14,if(p-l>m,print(l," ",p," ",m=p-l));l=p)

펄 153

짧은 코드:

$i=$a=2;while($a=$i++){if(p($i)){if($m<$m2=$i-$a){$m=$m2;print"$a $i $m$/"}}}sub p{$d=2;$s=sqrt$_[0];while(){return 0if!($_[0]%$d);return 1if$d>$s;$d++}}

읽기 쉬운:

$i=$a=2;
while($a=$i++){
  if(p($i)){
    if($m<$m2=$i-$a){
      $m=$m2;
      print"$a $i $m$/"
    }
  }
}
sub p {
  $d=2;
  $s=sqrt$_[0];
  while(){
    return 0if!($_[0]%$d);
    return 1if$d>$s;
    $d++;
  }
}