Das Finden von Primzahlen ist ein Programmierritus und sehr häufig ein erstes ernstes Programm, das jemand erstellt (normalerweise mit Testteilung).

Aber Primzahlen alleine sind schon abgenutzt. Weiter interessanter ist es, die ersten Lücken zu erhalten: die bislang längsten Lücken zwischen aufeinanderfolgenden Primzahlen. Diese sind ziemlich selten und "kostbar". Die ersten paar Paare und ihre Unterschiede sind:

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

Mein Vater hat diese Werte aus Spaß mit der Hand bis zu 10 km berechnet. Mal sehen, wie kurz ein Code sein kann.

Regeln:

• Keine eingebauten Funktionen für Prime Testing, Prime Generation oder Prime Gaps
• Kein Abrufen von http://oeis.org/A002386 oder ähnlichem (Ich kann Sie von weitem Betrüger riechen :))
• Keine vorberechneten Arrays
• Drucken Sie so lange, bis Ihr interner Integer-Typ nicht mehr funktioniert

Die niedrigste Anzahl an Charakteren gewinnt. +10 Zeichen, wenn Sie nur die Lücken ohne die Primzahlen drucken.

Sie können auch Versionen mit integrierten Funktionen anzeigen, wenn sie interessant sind. Seien Sie kreativ.

Klarstellung: Sie durchlaufen Primzahlen und melden jedes Mal, wenn Sie eine Lücke sehen, die größer ist als jede Lücke, die Sie zuvor gesehen haben. Beispielsweise ist zwischen 3 und 5 eine Lücke von 2 Einheiten vorhanden. Die Lücke zwischen 5 und 7 ist ebenfalls 2, aber das sind alte Nachrichten, die uns nicht mehr interessieren. Nur wenn Sie eine neue, größte Lücke sehen, melden Sie diese. Dies zeigt, wie die Primzahlen immer seltener werden, je größer die Lücken werden.

EDIT : Die meisten Antworten sind brillant und verdienen mehr Anerkennung. Bisher ist ein GolfScript-Eintrag mit 48 Zeichen jedoch der kürzeste.

GolfScript 66 59 57 49 48

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

Obwohl ich Probleme habe, es hier laufen zu lassen http://golfscript.apphb.com/ (vielleicht mag diese Site die Endlosschleife nicht?), Aber es funktioniert einwandfrei, wenn ich es auf meinem Computer mit golfscript.rb ausführe. Ich bin ziemlich neu in GolfScript, so dass dies wahrscheinlich noch weiter abgespielt werden kann. UPDATE: Ich denke nicht, dass man damit viel mehr Golf spielen kann, ohne den Algorithmus irgendwie zu ändern.

Die ersten paar Zeilen werden gedruckt (Wenn Sie das "", das gedruckt wird, nicht mögen, können Sie Folgendes hinzufügen:

[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]
...

Allgemeine, für Menschen lesbare Vorstellung davon, wie dies funktioniert (ein paar Dinge, die sich geringfügig unterscheiden, da ich in dieser Version keinen Stack verwende):

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)

Python, 121 110 109 108 104 103 Zeichen

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

Als ich hier zum ersten Mal versuchte zu antworten, hoffe ich, dass ich es richtig gemacht habe. Ich bin nicht sicher, ob ich die Zeichen richtig gezählt habe.

Hmmm, ich konnte ein anderes Zeichen auf dem Ausdruck speichern, indem ich auf Python 2.x heruntergestuft habe ...

JavaScript, 90 85 78 74 Zeichen

Funktionscode (Google Closure Compiler - Erweiterte Optimierungen; einige manuelle Bearbeitungen; weitere Bearbeitungen von @ 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)

Langer Code

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

Ausgabe

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

Ziemlich ineffizienter Test für Primzahlen, aber auf diese Weise werden weniger Zeichen verwendet.

^{Erster Beitrag hier, bitte entschuldigen Sie eventuelle Fehler.}

Mathematica, 114, 108

Ermöglicht die unendliche Ausgabe, obwohl sich der Lüfter nach einem bestimmten Zeitpunkt in der Sequenz dreht und Sie den Verdacht haben, dass Ihre CPU Freecell spielt, während Sie ihr Bestes tun, um ausgelastet auszusehen.

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]

Ausgabebeispiel (Dies sind diejenigen, die es in den ersten ~ 30er Jahren aufgreift):

{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-Code:

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]

Haskell - 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

(Ineffizienter) Ausdruck einer Primliste, der Will Ness gestohlen wurde .

-edit- Ich wusste nie, x|y=z|w=qdass es gültig sein würde.

MATLAB 104 89

Implementieren Sie einfach die grundlegende Methode, indem Sie jede mögliche Unterteilung überprüfen.

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

Ausgabe:

  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 Zeichen, Dogelang

Konvertiert von meiner Python-Version :

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)

Ausgabe:

(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 Zeichen

Mann, jeder Charakter ist extrem schwer zu verlieren:

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

Ausgabe :

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

Erklärung :

Der Stapel wird so eingerichtet, dass jede Iteration mit dem Stapel wie diesem beginnt, wobei sich der obere Teil rechts befindet. Das [zeigt die aktuelle Array-Markierung an, dh, wenn der Interpreter auf ein trifft ], wird alles auf dem Stapel von der Markierung bis zur Spitze in ein Array eingefügt.

g [ last | cur

gist die maximale Lücke bisher. Von oben nach unten:

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

In der Schleife:

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

Wie werden alle Teiler in eine Liste aufgenommen? Lass es uns Schritt für Schritt machen

 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]

Was macht es, wenn die Teiler leer sind?

 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                             | 

Zwei Wege: ja und nein. Wenn ja (beachten Sie, dass ifder oberste Wert auf dem Stapel verbraucht wird):

 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

Wenn nein:

 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

Beachten Sie in beiden Fällen, dass sich unser Stapel jetzt in der Form befindet ... | g [ c | c | c.

Jetzt wird der doSpitzenwert immer vom Stapel genommen cund es wird eine Schleife ausgeführt, wenn er positiv ist. Da dies cimmer weiter zunimmt, ist es immer wahr, so dass wir für immer eine Schleife bilden.

Nach dem Auftauchen befindet sich der obere Bereich des Stapels g [ c | c, was bedeutet, dass der letzte aktualisiert wurdec und die Array-Markierung befindet sich an derselben Stelleg befindet sich immer noch dort, wo wir dies erwarten.

Dies sind die verschlungenen Operationen von GolfScript. Ich hoffe, Sie haben es genossen, mitzufolgen!

Rubin, 110

Nur für Ruby 2.0 aufgrund der lazyMethode:

(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]}

Ausgabe:

[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 Bytes

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

Ungolfed:

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

Der Algorithmus ist einfach, $pmerkt sich die vorherige Primzahl. Dann $igeht es von 3oben nach unten, wenn der Typ $ i bei mir "versagt" oder wegen Überlauf negativ wird. $iwird auf grobe Weise getestet, indem alle Teiler von 2 bis 5 überprüft werden $i-1. Eine Zeile wird gedruckt, wenn die aktuelle Differenz größer ist als die zuvor gedruckte Differenz $d.

Mit etwas mehr Bytes kann die Laufzeit verbessert werden:

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

Das Ergebnis beginnt mit:

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 Zeichen

Naive Prime-Prüfung (überprüfen Sie, ob durch irgendetwas von 2 bis n(weniger Zeichen als bis n/2) teilbar ):

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

Die zweite Ebene des Einzugs ist ein Tabulatorzeichen.

Ausgabe:

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

Bash und etwas Perl für Prime Regex ( 167 157 143 112 Bytes)

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

etwas Output:

$./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 Bytes

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

alte Non Golf Version:

$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"}
}

Dies ähnelt meiner anderen Einreichung, sans bash.

C (100)

Mein eigener Beitrag, kein spezieller Algorithmus, nur Golf:

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

Haskell, 134C

Golf gespielt:

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

Ungolfed:

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

Ich habe die Rekursion nicht die übliche Schleife von foroder verwendet 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);
}

Ausgabe:

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

Habe das gerade in der Frage gemerkt:

Die niedrigste Anzahl an Charakteren gewinnt. +10 Zeichen, wenn Sie nur die Lücken ohne die Primzahlen drucken.

Da dies SQL ist und die Schlüsselwörter so lang sind, ist es eigentlich besser, die Strafe in Kauf zu nehmen. Es ist die gleiche Idee wie beim Original.

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

das ist schön zu:

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

Alte Antwort (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)))

und in einem lesbaren Format:

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

Dies erzeugt einen Zahlengenerator in c , die innerste Unterauswahl erzeugt die Primzahlen unter Verwendung eines Siebs von Eratosthenes, die äußere berechnet die vorherige Primzahl und schließlich subtrahiert die letzte Auswahl eine von der anderen.

Dies gibt nichts zurück, da 1 x 10 ¹²⁴ rekursive Abfragen ausgeführt werden. Wenn Sie also möchten, dass es funktioniert, verringern Sie diese Zahl auf etwas Sinnvolles.

D - 153 + 10 = 163

Ich nehme hier gerne die 10-Punkte-Strafe in Kauf, weil die Zeichenanzahl immer noch niedriger ist als wenn ich auch die Primzahlen gedruckt hätte.

Golf gespielt :

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

Lesbare Version :

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 CHAR

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

kurze Version:

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

Kopieren Sie diesen Code in Ihre Browserkonsole. Es wird für immer bleiben, da die maximale Anzahl etwas ist 1.79*10^308.

Ungolfed:

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 Zeichen

151 Zeichen + 10 Strafzeichen = 161 Zeichen

Kurzfassung:

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

Lange Version:

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

Es war eigentlich besser, 10 Zeichen Strafe zu nehmen, da es kürzer ist g(11 Zeichen mit Strafe) als p+" "+i+" "+g(13 Zeichen ohne Strafe).

Ruby 90 86 84 83 Zeichen

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

Einige boolesche Kurzschlüsse, Missbrauch der Ausdrucksbewertung usw.

C 248

Der Code vergleicht aufeinanderfolgende Primzahlen a, b und prüft dann, ob die Lücken größer als g sind. Dann findet er das nächste Primzahlenpaar.

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

Haskell, 154 144 137 123

Die Primzahlen pwerden mit dem Erasthotensieb erzeugt #und anschließend mit filtriert und gedruckt %.

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

Die Ausgabe sieht aus wie

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

was ich hoffe ist okay

Game Maker Language, 85

Angenommen, alle nicht initialisierten Variablen sind wie 0folgt (dies ist bei einigen Versionen von Game Maker die Standardeinstellung).

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)

Game Maker Language, 74 + 55 = 129

Angenommen, alle nicht initialisierten Variablen sind wie 0folgt (dies ist bei einigen Versionen von Game Maker die Standardeinstellung).

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

Skript pist unten:

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

Perl, 87 Bytes ( mit einem Modul )

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

Ich habe das Modul geschrieben, aber wir müssten der Liste zusätzliche 565.000 Zeichen hinzufügen. Meistens aus Spaß, aber auch um eine Leistungsalternative anzubieten, da ich bisher keine Verwendung von Builtins sehe. 4,6s für Lücken bis 1e9, 36s für Lücken bis 1e10, 6,5min für 1e11.

Pari / GP 2.8 kann im Prinzip auf die gleiche Weise ausgeführt werden, allerdings über 2x langsamer:

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

Perl 153

Kurzcode:

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

leicht zu lesen:

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