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

9,646 bytes added ,  27 days ago
Added Easylang
(added AWK)
(Added Easylang)
 
(20 intermediate revisions by 14 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 53 ⟶ 75:
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">
<lang AWK>
# syntax: GAWK -f LARGEST_DIFFERENCE_BETWEEN_ADJACENT_PRIMES.AWK
# converted from FreeBASIC
Line 97 ⟶ 136:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 105 ⟶ 144:
=={{header|C}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
 
Line 138 ⟶ 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}}
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <locale>
 
Line 167 ⟶ 206:
p1 = p2;
}
}</langsyntaxhighlight>
 
{{out}}
Line 181 ⟶ 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#)]
<langsyntaxhighlight 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>
</lang>
{{out}}
<pre>
Line 197 ⟶ 331:
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 203 ⟶ 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 210 ⟶ 344:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
 
function nextprime( n as uinteger ) as uinteger
Line 234 ⟶ 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 267 ⟶ 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}}==
<langsyntaxhighlight lang="julia">using Primes
 
function maxprimeinterval(nmax)
Line 280 ⟶ 524:
 
foreach(n -> maxprimeinterval(10^n), 1:10)
</langsyntaxhighlight>{{out}}
<pre>
The maximum prime interval in primes up to 10 is 2: for example at [3, 5].
Line 293 ⟶ 537:
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}}===
<langsyntaxhighlight lang="pascal">program primesieve;
// sieving small ranges of 65536 only odd numbers
//{$O+,R+}
Line 640 ⟶ 944:
{$ENDIF}
end.
</syntaxhighlight>
</lang>
{{out|@TIO.RUN}}
<pre>
Line 659 ⟶ 963:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use Primesieve qw(generate_primes);
Line 668 ⟶ 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 680 ⟶ 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 701 ⟶ 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 721 ⟶ 1,024:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">
print("working...")
limit = 1000000
Line 751 ⟶ 1,054:
print(diff)
print("done...")
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 761 ⟶ 1,064:
=={{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 777 ⟶ 1,080:
===Module===
 
<syntaxhighlight lang="raku" perl6line>use Math::Primesieve;
my $sieve = Math::Primesieve.new;
 
Line 783 ⟶ 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 813 ⟶ 1,116:
see nl + "Largest difference is = " + diff + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 821 ⟶ 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 826 ⟶ 1,220:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./fmt" for Fmt
 
var limit = 1e9 - 1
Line 845 ⟶ 1,239:
nextStop = nextStop * 10
}
}</langsyntaxhighlight>
 
{{out}}
Line 862 ⟶ 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 900 ⟶ 1,294:
Limit:= Limit*10;
];
]</langsyntaxhighlight>
 
{{out}}
Chkas
1,978

edits

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