Rosetta Code

Largest difference between adjacent primes: Difference between revisions

Page Discussion

Largest difference between adjacent primes (view source)

Revision as of 20:48, 20 April 2024

21,818 bytes added ,  27 days ago
Added Easylang
(→‎{{header|Factor}}: add link to detailed explanation)
(Added Easylang)
 
(30 intermediate revisions by 20 users not shown)
Line 5:
Find and show on this page the largest difference between adjacent primes under 1,000,000.
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">F primes_upto(limit)
V is_prime = [0B] * 2 [+] [1B] * (limit - 1)
L(n) 0 .< Int(limit ^ 0.5 + 1.5)
I is_prime[n]
L(i) (n * n .. limit).step(n)
is_prime[i] = 0B
R enumerate(is_prime).filter((i, prime) -> prime).map((i, prime) -> i)
 
V primes = primes_upto(1'000'000)
 
V maxdiff = 0
L(n) 1 .< primes.len
maxdiff = max(maxdiff, primes[n] - primes[n - 1])
 
print(‘Largest difference is ’maxdiff)</syntaxhighlight>
 
{{out}}
<pre>
Largest difference is 114
</pre>
 
=={{header|ALGOL 68}}==
Line 10 ⟶ 32:
As with the Wren, Phix, etc. samples, shows the gaps at a few other places.
{{libheader|ALGOL 68-primes}}
<langsyntaxhighlight lang="algol68">BEGIN # find the largest gap between adjacent primes up to 10 000 000 #
PR read "primes.incl.a68" PR
[]BOOL prime = PRIMESIEVE 10 000 000; # sieve the primes to 10 000 000 #
Line 42 ⟶ 64:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 52 ⟶ 74:
Largest gap between primes up to 1000000: 114 between 492113 and 492227
Largest gap between primes up to 10000000: 154 between 4652353 and 4652507
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">primes: select range.step:2 3 1e6 => prime?
 
pair: couple primes drop primes
| maximum'p -> p\1 - p\0
| <=
 
print "Largest prime gap under a million is:"
print ~"|pair\1 - pair\0| between |pair\0| and |pair\1|"</syntaxhighlight>
 
{{out}}
 
<pre>Largest prime gap under a million is:
114 between 492113 and 492227</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f LARGEST_DIFFERENCE_BETWEEN_ADJACENT_PRIMES.AWK
# converted from FreeBASIC
BEGIN {
stop = 1000000
champi = 3
champj = 5
i = 5
record = 2
while (i < stop) {
j = next_prime(i)
if (j-i > record) {
champi = i
champj = j
record = j - i
}
i = j
}
printf("The largest difference between adjacent primes < %d is %d between %d and %d\n",stop,record,champi,champj)
exit(0)
}
function next_prime(n, q) { # finds the next prime after n
if (n == 0) { return(2) }
if (n < 3) { return(++n) }
q = n + 2
while (!is_prime(q)) {
q += 2
}
return(q)
}
function is_prime(n, d) {
d = 5
if (n < 2) { return(0) }
if (n % 2 == 0) { return(n == 2) }
if (n % 3 == 0) { return(n == 3) }
while (d*d <= n) {
if (n % d == 0) { return(0) }
d += 2
if (n % d == 0) { return(0) }
d += 4
}
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
The largest difference between adjacent primes < 1000000 is 114 between 492113 and 492227
</pre>
 
=={{header|C}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
 
Line 89 ⟶ 177:
printf( "The largest difference was %d, between %d and %d.\n", record, champ, champj );
return 0;
}</langsyntaxhighlight>
{{out}}<pre>The largest difference was 114, between 492113 and 492227.</pre>
 
=={{header|C++}}==
{{libheader|Primesieve}}
<syntaxhighlight lang="cpp">#include <iostream>
#include <locale>
 
#include <primesieve.hpp>
 
int main() {
std::cout.imbue(std::locale(""));
const uint64_t limit = 10000000000;
uint64_t max_diff = 0;
primesieve::iterator pi;
uint64_t p1 = pi.next_prime();
for (uint64_t p = 10;;) {
uint64_t p2 = pi.next_prime();
if (p2 >= p) {
std::cout << "Largest gap between primes under " << p << " is "
<< max_diff << ".\n";
if (p == limit)
break;
p *= 10;
}
if (p2 - p1 > max_diff)
max_diff = p2 - p1;
p1 = p2;
}
}</syntaxhighlight>
 
{{out}}
<pre>
Largest gap between primes under 10 is 2.
Largest gap between primes under 100 is 8.
Largest gap between primes under 1,000 is 20.
Largest gap between primes under 10,000 is 36.
Largest gap between primes under 100,000 is 72.
Largest gap between primes under 1,000,000 is 114.
Largest gap between primes under 10,000,000 is 154.
Largest gap between primes under 100,000,000 is 220.
Largest gap between primes under 1,000,000,000 is 282.
Largest gap between primes under 10,000,000,000 is 354.
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
function IsPrime(N: integer): boolean;
{Optimised prime test - about 40% faster than the naive approach}
var I,Stop: integer;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (i + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
 
 
 
procedure LargestPrimeDifference(Memo: TMemo);
{Find the largest difference between primes under 1 million}
var I: integer;
var P1,P2: integer;
var Delta,Largest,Prime1,Prime2: integer;
begin
Largest:=0;
P1:=1;
for I:=1 to 1000000-1 do
if IsPrime(I) then
begin
Delta:=I - P1;
if Delta>Largest then
begin
Largest:=Delta;
Prime1:=P1;
Prime2:=I;
end;
P1:=I;
end;
Memo.Lines.Add(Format('Prime1: %d Prime2: %d Diff: %d',[Prime1,Prime2,Largest]));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Prime1: 492113 Prime2: 492227 Diff: 114
 
</pre>
 
 
=={{header|EasyLang}}==
<syntaxhighlight>
fastfunc isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
fastfunc nextprim prim .
repeat
prim += 1
until isprim prim = 1
.
return prim
.
prim = 2
repeat
prev = prim
prim = nextprim prim
until prim > 1e6
max = higher max (prim - prev)
.
print max
</syntaxhighlight>
{{out}}
<pre>
114
</pre>
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<syntaxhighlight lang="fsharp">
// Largest difference between adjacent primes. Nigel Galloway: November 22nd., 2021
let n,g=primes32()|>Seq.takeWhile((>)1000000)|>Seq.pairwise|>Seq.maxBy(fun(n,g)->g-n) in printfn $"%d{g}-%d{n}=%d{g-n}"
</syntaxhighlight>
{{out}}
<pre>
492227-492113=114
</pre>
 
=={{header|Factor}}==
See [[Largest difference between adjacent primes/Factor]] for a detailed explanation because why not?
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: arrays formatting kernel lists lists.lazy math math.order
math.primes.lists sequences ;
 
Line 101 ⟶ 337:
[ second 1e6 < ] lwhile { 0 } [ max ] foldl
 
"Largest difference in adjacent primes under a million: %d between %d and %d.\n" vprintf</langsyntaxhighlight>
{{out}}
<pre>
Line 108 ⟶ 344:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
 
function nextprime( n as uinteger ) as uinteger
Line 132 ⟶ 368:
wend
 
print using "The largest difference was ####, between ####### and #######";record;champ;champj</langsyntaxhighlight>
{{out}}<pre>The largest difference was 114 between 492113 and 492227</pre>
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|go-rcu}}
<syntaxhighlight lang="go">package main
 
import (
"fmt"
"rcu"
)
 
func main() {
limit := int(1e10 - 1)
primes := rcu.Primes(limit)
maxI := 0
maxDiff := 0
nextStop := 10
fmt.Println("The largest differences between adjacent primes under the following limits is:")
for i := 1; i < len(primes); i++ {
diff := primes[i] - primes[i-1]
if diff > maxDiff {
maxDiff = diff
maxI = i
}
if i == len(primes)-1 || primes[i+1] > nextStop {
c1 := rcu.Commatize(nextStop)
c2 := rcu.Commatize(primes[maxI])
c3 := rcu.Commatize(primes[maxI-1])
c4 := rcu.Commatize(maxDiff)
fmt.Printf("Under %s: %s - %s = %s\n", c1, c2, c3, c4)
nextStop *= 10
}
}
}</syntaxhighlight>
 
{{out}}
<pre>
The largest differences between adjacent primes under the following limits is:
Under 10: 5 - 3 = 2
Under 100: 97 - 89 = 8
Under 1,000: 907 - 887 = 20
Under 10,000: 9,587 - 9,551 = 36
Under 100,000: 31,469 - 31,397 = 72
Under 1,000,000: 492,227 - 492,113 = 114
Under 10,000,000: 4,652,507 - 4,652,353 = 154
Under 100,000,000: 47,326,913 - 47,326,693 = 220
Under 1,000,000,000: 436,273,291 - 436,273,009 = 282
Under 10,000,000,000: 4,302,407,713 - 4,302,407,359 = 354
</pre>
 
=={{header|GW-BASIC}}==
<langsyntaxhighlight lang="gwbasic">10 R=2 : P=3 : P2=0
20 GOSUB 190
30 IF P2>1000000! THEN GOTO 70
Line 165 ⟶ 450:
280 C2 = P2
290 R = P2 - P
300 RETURN</langsyntaxhighlight>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.List.Split ( divvy )
 
isPrime :: Int -> Bool
isPrime n
|n == 2 = True
|n == 1 = False
|otherwise = null $ filter (\i -> mod n i == 0 ) [2 .. root]
where
root :: Int
root = floor $ sqrt $ fromIntegral n
solution :: Int
solution = maximum $ map (\li -> last li - head li ) $ divvy 2 1 $ filter
isPrime [1..999999]
 
main :: IO ( )
main = do
print solution</syntaxhighlight>
{{out}}
<pre>
114
</pre>
 
 
=={{header|J}}==
<syntaxhighlight lang="j"> >./ 2 -~/\ p: i. _1 p: 1e6
114</syntaxhighlight>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
See [[Erdős-primes#jq]] for a suitable definition of `is_prime` as used here.
 
<syntaxhighlight lang="jq"># Primes less than . // infinite
def primes:
(. // infinite) as $n
| if $n < 3 then empty
else 2, (range(3; $n) | select(is_prime))
end;
 
def largest_difference_between_adjacent_primes:
reduce primes as $p ( null; # [prev, diff]
if . == null then [$p, 0]
else ($p - .[0]) as $diff
| if $diff > .[1] then [$p, $diff]
else .[0] = $p
end
end)
| .[1];
 
pow(10; 1, 2, 6) | largest_difference_between_adjacent_primes
</syntaxhighlight>
{{out}}
<pre>
2
8
14
</pre>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes
 
function maxprimeinterval(nmax)
pri = primes(nmax)
diffs = [pri[i] - pri[i - 1] for i in 2:length(pri)]
diff, idx = findmax(diffs)
println("The maximum prime interval in primes up to $nmax is $diff: for example at [$(pri[idx]), $(pri[idx + 1])].")
end
 
foreach(n -> maxprimeinterval(10^n), 1:10)
</syntaxhighlight>{{out}}
<pre>
The maximum prime interval in primes up to 10 is 2: for example at [3, 5].
The maximum prime interval in primes up to 100 is 8: for example at [89, 97].
The maximum prime interval in primes up to 1000 is 20: for example at [887, 907].
The maximum prime interval in primes up to 10000 is 36: for example at [9551, 9587].
The maximum prime interval in primes up to 100000 is 72: for example at [31397, 31469].
The maximum prime interval in primes up to 1000000 is 114: for example at [492113, 492227].
The maximum prime interval in primes up to 10000000 is 154: for example at [4652353, 4652507].
The maximum prime interval in primes up to 100000000 is 220: for example at [47326693, 47326913].
The maximum prime interval in primes up to 1000000000 is 282: for example at [436273009, 436273291].
The maximum prime interval in primes up to 10000000000 is 354: for example at [4302407359, 4302407713].
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Max[-Subtract @@@
Partition[Most@NestWhileList[NextPrime, 2, # < 1000000 &], 2, 1]]</syntaxhighlight>
 
{{out}}<pre>
114
</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="Nim">import std/[bitops, math]
 
type Sieve = object
data: seq[byte]
 
func `[]`(sieve: Sieve; idx: Positive): bool =
## Return value of element at index "idx".
let idx = idx shr 1
let iByte = idx shr 3
let iBit = idx and 7
result = sieve.data[iByte].testBit(iBit)
 
func `[]=`(sieve: var Sieve; idx: Positive; val: bool) =
## Set value of element at index "idx".
let idx = idx shr 1
let iByte = idx shr 3
let iBit = idx and 7
if val: sieve.data[iByte].setBit(iBit)
else: sieve.data[iByte].clearBit(iBit)
 
func newSieve(lim: Positive): Sieve =
## Create a sieve with given maximal index.
result.data = newSeq[byte]((lim + 16) shr 4)
 
func initPrimes(lim: Positive): seq[Natural] =
## Initialize the list of primes from 2 to "lim".
var composite = newSieve(lim)
composite[1] = true
for n in countup(3, sqrt(lim.toFloat).int, 2):
if not composite[n]:
for k in countup(n * n, lim, 2 * n):
composite[k] = true
result.add 2
for n in countup(3, lim, 2):
if not composite[n]:
result.add n
 
let primes = initPrimes(1_000_000)
 
var prev = 0
var largestDiff = 0
for n in primes:
largestDiff = max(largestDiff, n - prev)
prev = n
echo "Largest difference: ", largestDiff
</syntaxhighlight>
 
{{out}}
<pre>Largest difference: 114
</pre>
 
=={{header|Pascal}}==
==={{header|Free Pascal}}===
<syntaxhighlight lang="pascal">program primesieve;
// sieving small ranges of 65536 only odd numbers
//{$O+,R+}
{$IFDEF FPC}
{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=16}
uses
sysutils;
{$ENDIF}
{$IFDEF WINDOWS}
{$APPTYPE CONSOLE}
{$ENDIF}
 
const
smlPrimes :array [0..10] of Byte = (2,3,5,7,11,13,17,19,23,29,31);
maxPreSievePrime = 17;
sieveSize = 1 shl 15;//32768*2 ->max count of FoundPrimes = 6542
type
tSievePrim = record
svdeltaPrime:word;//diff between actual and new prime
svSivOfs:word;
svSivNum:LongWord;// 1 shl (16+32) = 2.8e14
end;
var
{$Align 16}
//primes up to 1E6-> sieving to 1E12
sievePrimes : array[0..78497] of tSievePrim;
{$Align 16}
preSieve :array[0..3*5*7*11*13*17-1] of Byte;
{$Align 16}
Sieve :array[0..sieveSize-1] of Byte;
{$Align 16}
FoundPrimes : array[0..6542] of Word;
{$Align 16}
Limit,OffSet,Dekalimit,MaxGap : Uint64;
 
SieveMaxIdx,
preSieveOffset,
SieveNum,
FoundPrimesCnt,
PrimPos,
LastInsertedSievePrime :NativeUInt;
 
procedure CopyPreSieveInSieve;forward;
procedure CollectPrimes;forward;
procedure sieveOneSieve;forward;
 
procedure preSieveInit;
var
i,pr,j,umf : NativeInt;
Begin
i := 1;// starts with pr = 3
umf := 1;
repeat
IF preSieve[i] =0 then
Begin
pr := 2*i+1;
j := i;
repeat
preSieve[j] := 1;
inc(j,pr);
until j> High(preSieve);
umf := umf*pr;
end;
inc(i);
until umf>High(preSieve);
preSieveOffset := 0;
end;
 
procedure CalcSievePrimOfs(lmt:NativeUint);
//lmt High(sievePrimes)
var
i,pr : NativeUInt;
sq : Uint64;
begin
pr := 0;
i := 0;
repeat
with sievePrimes[i] do
Begin
pr := pr+svdeltaPrime;
IF sqr(pr) < (SieveSize*2) then
Begin
svSivNum := 0;
svSivOfs := (pr*pr-1) DIV 2;
end
else
Begin
SieveMaxIdx := i;
pr := pr-svdeltaPrime;
BREAK;
end;
end;
inc(i);
until i > lmt;
 
for i := i to lmt do
begin
with sievePrimes[i] do
Begin
pr := pr+svdeltaPrime;
sq := sqr(pr);
svSivNum := sq DIV (2*SieveSize);
svSivOfs := ( (sq - Uint64(svSivNum)*(2*SieveSize))-1)DIV 2;
end;
end;
end;
 
procedure InitSieve;
begin
preSieveOffset := 0;
SieveNum :=0;
CalcSievePrimOfs(PrimPos-1);
end;
 
procedure InsertSievePrimes;
var
j :NativeUINt;
i,pr : NativeUInt;
begin
i := 0;
//ignore first primes already sieved with
if SieveNum = 0 then
repeat
inc(i);
until FoundPrimes[i] > maxPreSievePrime;
 
pr :=0;
j := Uint64(SieveNum)*SieveSize*2-LastInsertedSievePrime;
with sievePrimes[PrimPos] do
Begin
pr := FoundPrimes[i];
svdeltaPrime := pr+j;
j := pr;
end;
inc(PrimPos);
for i := i+1 to FoundPrimesCnt-1 do
Begin
IF PrimPos > High(sievePrimes) then
BREAK;
with sievePrimes[PrimPos] do
Begin
pr := FoundPrimes[i];
svdeltaPrime := (pr-j);
j := pr;
end;
inc(PrimPos);
end;
LastInsertedSievePrime :=Uint64(SieveNum)*SieveSize*2+pr;
end;
 
procedure sievePrimesInit;
var
i,j,pr:NativeInt;
Begin
LastInsertedSievePrime := 0;
 
PrimPos := 0;
preSieveOffset := 0;
SieveNum :=0;
CopyPreSieveInSieve;
i := 1; // start with 3
repeat
while Sieve[i] = 1 do
inc(i);
pr := 2*i+1;
inc(i);
j := ((pr*pr)-1) DIV 2;
if j > High(Sieve) then
BREAK;
repeat
Sieve[j] := 1;
inc(j,pr);
until j > High(Sieve);
until false;
 
CollectPrimes;
InsertSievePrimes;
IF PrimPos < High(sievePrimes) then
Begin
InitSieve;
//Erste Sieb nochmals, aber ohne Eintrag
CopyPreSieveInSieve;
sieveOneSieve;
repeat
inc(SieveNum);
CopyPreSieveInSieve;
sieveOneSieve;
CollectPrimes;
InsertSievePrimes;
until PrimPos > High(sievePrimes);
end;
end;
 
procedure CopyPreSieveInSieve;
var
lmt : NativeInt;
Begin
lmt := preSieveOffset+sieveSize;
lmt := lmt-(High(preSieve)+1);
IF lmt<= 0 then
begin
Move(preSieve[preSieveOffset],Sieve[0],sieveSize);
if lmt <> 0 then
inc(preSieveOffset,sieveSize)
else
preSieveOffset := 0;
end
else
begin
Move(preSieve[preSieveOffset],Sieve[0],sieveSize-lmt);
Move(preSieve[0],Sieve[sieveSize-lmt],lmt);
preSieveOffset := lmt
end;
end;
 
procedure CollectPrimes;
var
pSieve : pbyte;
pFound : pWord;
i,idx : NativeInt;
Begin
pFound := @FoundPrimes[0];
idx := 0;
i := 0;
IF SieveNum = 0 then
Begin
repeat
pFound[idx] := smlPrimes[idx];
inc(idx);
until smlPrimes[idx]>maxPreSievePrime;
i := (smlPrimes[idx] -1) DIV 2;
end;
 
pSieve := @Sieve[0];
repeat
pFound[idx]:= 2*i+1;
inc(idx,1-pSieve[i]);
inc(i);
until i>High(Sieve);
FoundPrimesCnt:= idx;
end;
 
procedure sieveOneSieve;
var
i,j,pr,dSievNum :NativeUint;
Begin
pr := 0;
For i := 0 to SieveMaxIdx do
with sievePrimes[i] do
begin
pr := pr+svdeltaPrime;
IF svSivNum = sieveNum then
Begin
j := svSivOfs;
repeat
Sieve[j] := 1;
inc(j,pr);
until j > High(Sieve);
dSievNum := j DIV SieveSize;
svSivOfs := j-dSievNum*SieveSize;
inc(svSivNum,dSievNum);
end;
end;
 
i := SieveMaxIdx+1;
repeat
if i > High(SievePrimes) then
BREAK;
with sievePrimes[i] do
begin
if svSivNum > sieveNum then
Begin
SieveMaxIdx := I-1;
Break;
end;
pr := pr+svdeltaPrime;
j := svSivOfs;
repeat
Sieve[j] := 1;
inc(j,pr);
until j > High(Sieve);
dSievNum := j DIV SieveSize;
svSivOfs := j-dSievNum*SieveSize;
inc(svSivNum,dSievNum);
inc(i);
end;
until false;
end;
 
var
T1,T0,CNT,ActPrime,LastPrime,GapPrime : Int64;
i: Int32;
 
begin
T0 := GetTickCount64;
Limit := 10*1000*1000*1000;//99999999999;//
preSieveInit;
sievePrimesInit;
 
InitSieve;
offset := 0;
Cnt := 1;//==2
LastPrime := 2;
Dekalimit := 10;
MaxGap := 0;
writeln('Limit Gap First prime');
repeat
CopyPreSieveInSieve;sieveOneSieve;CollectPrimes;
inc(Cnt,FoundPrimesCnt);
inc(SieveNum);
//check for max gap
i := 0;
repeat
ActPrime := Offset+FoundPrimes[i];
If ActPrime > Dekalimit then
Begin
writeln(Dekalimit :12,MaxGap:4,GapPrime:12);
DekaLimit := 10 *DekaLimit;
end;
if ActPrime - LastPrime > MaxGap then
begin
MaxGap := ActPrime - LastPrime;
GapPrime:= LastPrime;
end;
LastPrime := ActPrime;
inc(i);
until (i >= FoundPrimesCnt);
 
inc(offset,2*SieveSize);
until SieveNum > (Limit DIV (2*SieveSize));
 
T1 := GetTickCount64;
OffSet := Uint64(SieveNum-1)*(2*SieveSize);
// correct count to Limit
i := FoundPrimesCnt;
repeat
dec(i);
dec(cnt);
until (i = 0) OR (OffSet+FoundPrimes[i]<Limit);
writeln;
writeln(cnt,' in ',Limit,' takes ',T1-T0,' ms');
{$IFDEF WINDOWS}
writeln('Press <Enter>');readln;
{$ENDIF}
end.
</syntaxhighlight>
{{out|@TIO.RUN}}
<pre>
Limit Gap First prime
10 2 3
100 8 89
1000 20 887
10000 36 9551
100000 72 31397
1000000 114 492113
10000000 154 4652353
100000000 220 47326693
1000000000 282 436273009
10000000000 354 4302407359
 
455052511 in 10000000000 takes 14319 ms
</pre>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use Primesieve qw(generate_primes);
Line 177 ⟶ 972:
map { ($diff = $primes[$_] - $primes[$_-1]) > $max and ($max,$p) = ($diff,$_-1) } 1..$#primes;
printf "Largest prime gap up to %d: %d - between %d and %d.\n", 10**$n, $max, @primes[$p,$p+1];
}</langsyntaxhighlight>
{{out}}
<pre>Largest prime gap up to 100: 8 - between 89 and 97.
Line 189 ⟶ 984:
=={{header|Phix}}==
{{trans|Wren}}
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
Line 210 ⟶ 1,005:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<!--</langsyntaxhighlight>-->
<!--</lang>-->
{{out}}
<pre>
Line 228 ⟶ 1,022:
<small>Almost all the time is spent constructing the list of primes. It is about 4 times slower under pwa/p2js so
limited to 1e8 when running in a browser to keep the time below 5s instead of over 50s.</small>
 
=={{header|Python}}==
<syntaxhighlight lang="python">
print("working...")
limit = 1000000
res1 = 0
res2 = 0
maxOld = 0
newDiff = 0
oldDiff = 0
 
def isPrime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
 
for n in range(limit):
newDiff = n - maxOld
if isprime(n):
if (newDiff > oldDiff):
res1 = n
res2 = maxOld
oldDiff = newDiff
maxOld = n
 
diff = res1 - res2
print(res1)
print(res2)
print("Largest difference is = ",end="")
print(diff)
print("done...")
</syntaxhighlight>
{{out}}
<pre>
492227
492113
Largest difference is = 114
</pre>
 
=={{header|Raku}}==
===Built-ins===
<syntaxhighlight lang="raku" perl6line>for 2..8 -> $n {
printf "Largest prime gap up to {10 ** $n}: %d - between %d and %d.\n", .[0], |.[1]
given max (^10**$n).grep(&is-prime).rotor(2=>-1).map({.[1]-.[0],$_})
}</langsyntaxhighlight>
{{out}}
<pre>Largest prime gap up to 100: 8 - between 89 and 97.
Line 247 ⟶ 1,080:
===Module===
 
<syntaxhighlight lang="raku" perl6line>use Math::Primesieve;
my $sieve = Math::Primesieve.new;
 
Line 253 ⟶ 1,086:
printf "Largest prime gap up to {10 ** $n}: %d - between %d and %d.\n", .[0], |.[1]
given max $sieve.primes(10 ** $n).rotor(2=>-1).map({.[1]-.[0],$_})
}</langsyntaxhighlight>
Same output
 
=={{header|Ring}}==
 
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 283 ⟶ 1,116:
see nl + "Largest difference is = " + diff + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 291 ⟶ 1,124:
Largest difference is = 114
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
≪ 1000000 PREVPRIME
DUP PREVPRIME DUP2 - UNROT
'''DO''' NIP DUP PREVPRIME
DUP2 - 4 PICK
'''IF''' OVER < '''THEN''' 3 UNPICK '''ELSE''' DROP '''END'''
'''UNTIL''' DUP 2 == '''END'''
DROP2
≫ '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: 114
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
n = 1000000
pr1, pr2 = Prime.each(n).each_cons(2).max_by{|p1,p2| p2-p1}
puts "Largest difference between adjacent primes under #{n} is #{pr2-pr1} (#{pr2}-#{pr1})."
</syntaxhighlight>
{{out}}
<pre>Largest difference between adjacent primes under 1000000 is 114 (492227-492113).
</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn is_prime( num : u32 ) -> bool {
if num == 1 {
return false ;
}
else {
let root : f32 = (num as f32).sqrt( ) ;
let limit : u32 = root.floor( ) as u32 ;
(2..=limit).filter( | &d | num % d == 0 ).collect::<Vec<u32>>( ).len( ) == 0
}
}
 
fn main() {
let target_primes : Vec<u32> = (2..1000000).filter( | &d | is_prime( d ) ).
collect( ) ;
let mut diff : u32 = target_primes[ 1 ] - target_primes[ 0 ] ;
let len = target_primes.len( ) ;
for i in 1..len - 1 {
let current_diff = target_primes[i + 1] - target_primes[ i ] ;
if current_diff > diff {
diff = current_diff ;
}
}
println!("{}" , diff ) ;
}</syntaxhighlight>
{{out}}
<pre>
114
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func prime_gap_records(upto) {
 
var gaps = []
var p = 2
 
each_prime(p.next_prime, upto, {|q|
gaps[q-p] := p
p = q
})
 
gaps.grep { defined(_) }
}
 
var upto = 1e8
var primes = prime_gap_records(upto)
 
for n in (2 .. upto.ilog10) {
 
var b = primes.last_by {|p| p < 10**n } \\ break
 
printf("Largest prime gap up to 10^%s is %3s between %s and %s\n",
n, b.next_prime - b, b, b.next_prime)
}</syntaxhighlight>
{{out}}
<pre>
Largest prime gap up to 10^2 is 8 between 89 and 97
Largest prime gap up to 10^3 is 20 between 887 and 907
Largest prime gap up to 10^4 is 36 between 9551 and 9587
Largest prime gap up to 10^5 is 72 between 31397 and 31469
Largest prime gap up to 10^6 is 114 between 492113 and 492227
Largest prime gap up to 10^7 is 154 between 4652353 and 4652507
Largest prime gap up to 10^8 is 220 between 47326693 and 47326913
</pre>
 
Line 296 ⟶ 1,220:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./fmt" for Fmt
 
var limit = 1e9 - 1
Line 315 ⟶ 1,239:
nextStop = nextStop * 10
}
}</langsyntaxhighlight>
 
{{out}}
Line 332 ⟶ 1,256:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">def Size = 1_000_000_000/2; \sieve for odd numbers
int Prime, I, K;
char Flags;
Line 370 ⟶ 1,294:
Limit:= Limit*10;
];
]</langsyntaxhighlight>
 
{{out}}
Chkas
1,978

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/317708...363840"