素数を見つけることは、プログラミングの通過儀礼であり、非常に頻繁に誰かが作成する最初の深刻なプログラムです（通常は試用部門で）。

しかし、素数だけはすでに使い古されています。次に興味深いのは、素数のギャップを取得することです。連続する素数間のこれまでで最も長いギャップです。これらは非常にまれで「貴重な」ものです。最初のいくつかのペアとその違いは次のとおりです。

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

ここで最初に答えようとしたとき、私は正しかったことを望みます...私は文字を正しく数えたかどうかさえわかりません。

うーん、Python 2.xにダウングレードすることで、印刷物に別の文字を保存できます...

JavaScript、90 85 78 74文字

短いコード （Google Closure Compiler-Advanced Optimizations;一部の手動編集; @ 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
...

素数のテストはかなり非効率ですが、その方法では文字数が少なくなります。

^{ここに最初に投稿するので、間違いを許してください。}

Mathematica、114 108

無限の出力を許可しますが、シーケンスの特定のポイントの後、ファンが回転し、CPUがFreecellを再生していると疑い始め、ビジーに見えるように最善を尽くします。

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}

未ゴルフコード：

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文字、ドゲラン

私のPythonバージョンから変換：

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

Golfscript、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                             | 

2つのパス：yesおよびno。はいの場合（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]
...

Perl、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ます。$i2からのすべての除数をチェックすることにより、おおまかな方法​​でテストされ$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
...

Python、93 91文字

素朴な素数チェック（2〜n（charsがtoまで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番目のレベルは1つのタブ文字です。

出力：

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

Bashと素数正規表現用のPerl（167 157 143 112バイト）

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

Perl 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

Oracle 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、最も内側の副選択がエラトステネスのふるいを使用して素数を作成し、外側が前の素数を計算し、最後の選択が最後から1つを減算します。

1 x 10 ^124の再帰クエリを実行しているため、これは何も返しません。したがって、この数値を適切に動作させるには、この数値を低くします。

D-153 + 10 = 163

ここでも、素数を印刷した場合よりも文字数が少ないため、ここで+10のペナルティを受け入れています。

Golfed：

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

JAVASCRIPT 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;}}

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

実際にはg、p+" "+i+" "+g（ペナルティなしで13文字）よりも短い書き込み（ペナルティ付きで11文字）であるため、10文字のペナルティを取得する方が適切でした。

Ruby 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（これは、ゲームメーカーの一部のバージョンのデフォルトです）。

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（これは、ゲームメーカーの一部のバージョンのデフォルトです）。

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)

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