Earliest difference between prime gaps: Difference between revisions

=={{header|C++}}==

{{libheader|Primesieve}}

#include <locale>

#include <unordered_map>

}

}

{{out}}

=={{header|F_Sharp|F#}}==

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]

// Earliest difference between prime gaps. Nigel Galloway: December 1st., 2021

let fN y=let i=System.Collections.Generic.SortedDictionary<int64,int64>()

[1..9]|>List.iter(fun g->let fN=fN(pown 10 g) in let n,i=(primes64()|>Seq.skip 1|>Seq.pairwise|>Seq.map fN|>Seq.find Option.isSome).Value

printfn $"%10d{pown 10 g} -> distance between start of gap %d{n.Key}=%d{n.Value} and start of gap %d{i.Key}=%d{i.Value} is %d{abs((n.Value)-(i.Value))}")

{{out}}

<pre>

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

}

}

{{out}}

Implementation:

magnitude=. ref=. 10^y

whilst. -.1 e. ok do.

end.

(0 1+ok i.1){mag

Task examples:

7 23

lowpgap 2

396733 1444309

lowpgap 7

=={{header|Java}}==

Uses the PrimeGenerator class from [[Extensible prime generator#Java]].

import java.util.Map;

}

}

{{out}}

{{trans|Wren}}

To get to 10^9 correctly we need a limit multiplier of 5 in Julia, not 4. Going up to 10^10 runs out of memory on my machine.

using Primes

primegaps()

<pre>

Earliest difference > 10 between adjacent prime gap starting primes:

</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

gaps = {Differences[primes], Most[primes]} // Transpose;

tmp = GatherBy[gaps, First][[All, 1]];

{10^i, n, starts[n], n + 2, starts[n + 2], k}, {i, 1, 7}];

StringTemplate["Earliest difference > `` between adjacent prime gap starting primes:

{{out}}

<pre>Earliest difference > 10 between adjacent prime gap starting primes:

=={{header|Pascal}}==

==={{header|Free Pascal}}===

// sieving small ranges of 65536

//{$O+,R+}

writeln('Press <Enter>');readln;

{$ENDIF}

{{out|@TIO.RUN}}

<pre>

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Earliest_difference_between_prime_gaps

print "above $m gap @{[$i * 2 - 2 ]} abs( $gaps[$i-1] - $gaps[$i] )\n";

}

{{out}}

<pre>

=={{header|Phix}}==

{{trans|Wren}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">?</span><span style="color: #000000;">1e7</span><span style="color: #0000FF;">:</span><span style="color: #000000;">1e8</span><span style="color: #0000FF;">),</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

Output same as Wren. Takes 5s on desktop/Phix but would take 17s under p2js so limited that to keep it under 2s.

A limit of 1e9 needs 64 bit (hence not p2js compatible), and a multiplier of 5, and a gslim of 354, and takes 2 mins 43s, and nearly killed my poor little box, but matched the output of Julia, which managed it in 40s (and with no signs of any stress). Python needed more memory than I've got for 1e9, but took 15s for a limit of 1e8, while Wren (bless, also 1e8) took just over 3 minutes (an old i5/8GB/w10).

=={{header|Python}}==

{{trans|Julia, Wren}}

from primesieve import primes

else:

GAP1 = GAP2

=={{header|Raku}}==

1e1 through 1e7 are pretty speedy (less than 5 seconds total). 1e8 and 1e9 take several minutes.

use Lingua::EN::Numbers;

|(2 * $key + 2, @upto[$key], 2 * $key + 4, @upto[$key+1], abs(@upto[$key] - @upto[$key+1]))».&comma;

True

{{out}}

<pre>Earliest difference > 10 between adjacent prime gap starting primes:

=={{header|Rust}}==

// primal = "0.3"

}

}

{{out}}

=={{header|Sidef}}==

var gaps = []

}

})

{{out}}

<pre>

{{libheader|Wren-fmt}}

This uses a segmented sieve to avoid running out of memory when looking for the earliest difference above 1 billion. Takes a little over 5½ minutes to run (25 seconds to reach first 100 million) on my machine (core i7, 32GB RAM, Ubuntu 20.04).

import "/fmt" for Fmt

gap1 = gap2

}

{{out}}