Successive prime differences: Difference between revisions

The series of increasing prime numbers begins: <code>2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...</code>

 

:#https://www.primepuzzles.net/puzzles/puzz_011.htm

:#https://matheplanet.de/matheplanet/nuke/html/viewtopic.php?topic=232720&start=0

=={{header|C sharp}}==

using System.Collections.Generic;

using static System.Linq.Enumerable;

 

public static void Main() {

var primes = GeneratePrimes(1_000_000).ToList();

 

IEnumerable<IEnumerable<int>> FindDifferenceGroups(int[] diffs) {

yield return Range(pi - diffs.Length, diffs.Length + 1).Select(i => primes[i]);

}

}

}

{{out}}

<pre>

(7, 11, 13), (997807, 997811, 997813), 1444

(31, 37, 41, 43), (997141, 997147, 997151, 997153), 306

</pre>

 

=={{header|Factor}}==

{{works with|Factor|0.99}}

math.statistics sequences ;

IN: rosetta-code.successive-prime-differences

} [ show ] with each ;

{{out}}

<pre>

Last group: { 997141 997147 997151 997153 }

Count: 306

</pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Println()

}

 

{{out}}

</pre>

 

 

function filterdifferences(deltas, N)

allprimes = primes(N)

differences = map(i -> allprimes[i + 1] - allprimes[i], 1:length(allprimes) - 1)

for delt in deltas

end

end

 

filterdifferences([[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]], 1000000)

<pre>

[2] 8169 [3, 5]...[999959, 999961]

[1] 1 [2, 3]...[2, 3]

</pre>

 

 

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use List::EachCons;

use ntheory 'primes';

 

my @intervals = map { $primes[$_] - $primes[$_-1] } 1..$#primes;

 

 

for my $diffs ([2], [1], [2,2], [2,4], [4,2], [6,4,2]) {

my $n = -1;

printf "%10s has %5d sets: %15s … %s\n",

'(' . join(' ',@$diffs) . ')',

join(' ', @primes[$offsets[ 0]..($offsets[ 0]+@$diffs)]),

join(' ', @primes[$offsets[-1]..($offsets[-1]+@$diffs)]);

{{out}}

<pre> (2) has 8169 sets: 3 5 … 999959 999961

(6 4 2) has 306 sets: 31 37 41 43 … 997141 997147 997151 997153</pre>

 

===Categorized by Successive===

{{works with|Rakudo|2019.03}}

 

my $sieve = Math::Primesieve.new;

 

}

say ' Count: ', +$primes{$i}, "\n";

{{out}}

<pre>## Sets of 2 successive primes <= 1,000,000 with successive differences of 2

===Precomputed Differences===

{{works with|Rakudo|2019.03}}

 

constant $max = 1_000_000;

say sprintf '%10s has %5d sets: %15s … %s',

@succ.gist, @group_start_offsets.elems, $first, $last;

{{Out}}

<pre>Given all ordered primes <= 1000000, sets with successive differences of:

(4 2) has 1444 sets: 7 11 13 … 997807 997811 997813

(6 4 2) has 306 sets: 31 37 41 43 … 997141 997147 997151 997153</pre>

 

=={{header|REXX}}==

parse arg H . 1 . difs /*allow the highest number be specified*/

if H=='' | H=="," then H= 1000000 /*Not specified? Then use the default.*/

do e=4 by 2 for (N-1)%2; @.e=; end /*treat the even integers > 2 special.*/

/*all primes are indicated with a "." */

if @.j==. then do; if ! then iterate /*Prime? Should skip the top part ? */

jj= j * j /*compute the square of J. ___ */

if jj>N then != 1 /*indicate skip top part if j > √ N */

do m=jj to N by j+j; @.m=; end /*odd multiples.*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

count: 306

</pre>

=={{header|Ruby}}==

PRIMES = Prime.each(1_000_000).to_a

difs = [[2], [1], [2,2], [2,4], [4,2], [6,4,2]]

puts "#{ar} has #{res.size} sets. #{res.first}...#{res.last}"

end

{{output}}

<pre>[2] has 8169 sets. [3, 5]...[999959, 999961]

[6, 4, 2] has 306 sets. [31, 37, 41, 43]...[997141, 997147, 997151, 997153]

</pre>

 

=={{header|Sidef}}==

var primes = limit.primes

 

say ("...for differences #{diffs}, there are #{groups.len} groups, where ",

"the first group = #{groups.first} and the last group = #{groups.last}")

{{out}}

<pre>

...for differences [4, 2], there are 1444 groups, where the first group = [7, 11, 13] and the last group = [997807, 997811, 997813]

...for differences [6, 4, 2], there are 306 groups, where the first group = [31, 37, 41, 43] and the last group = [997141, 997147, 997151, 997153]

</pre>

 

 

Treat this as a string search problem.

var [const] BI=Import("zklBigNum"); // libGMP

var [const] primeBitMap=Data(PRIME_LIMIT).fill(0x30); // one big string

while(n=primeBitMap.find(sp,n+1)){ r.append(n) } // (31, 61, 271,...)

r.apply('wrap(n){ T(n).extend(ds.apply('+(n))) }) //( (31,37,41,43), (61,67,71,73), (271,277,281,283) ...)

r:=primeWindows(PRIME_LIMIT,w);

println("Successive primes (<=%,d) with deltas of %s (%,d groups):"

println(" First group: %s; Last group: %s\n"

.fmt(r[0].concat(", "),r[-1].concat(", ")));

{{out}}

<pre>