Largest difference between adjacent primes: Difference between revisions
Largest difference between adjacent primes (view source)
Revision as of 20:48, 20 April 2024
, 1 month agoAdded Easylang
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
(Added Easylang) |
||
| (12 intermediate revisions by 8 users not shown) | |||
Line 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}}==
Line 204 ⟶ 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>
Line 340 ⟶ 451:
290 R = P2 - P
300 RETURN</syntaxhighlight>
=={{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}}==
Line 403 ⟶ 543:
{{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>
Line 932 ⟶ 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>
Line 972 ⟶ 1,220:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="
import "./fmt" for Fmt
var limit = 1e9 - 1
| |||