Successive prime differences: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
(39 intermediate revisions by 25 users not shown) | |||
Line 30:
:#https://www.primepuzzles.net/puzzles/puzz_011.htm
:#https://matheplanet.de/matheplanet/nuke/html/viewtopic.php?topic=232720&start=0
=={{header|11l}}==
{{trans|D}}
<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 + 1).step(n)
is_prime[i] = 0B
R enumerate(is_prime).filter((i, prime) -> prime).map((i, prime) -> i)
F successive_primes(primes, diffs)
[[Int]] results
V dl = diffs.len
L(i) 0 .< primes.len - dl
V group = [0] * (dl + 1)
group[0] = primes[i]
L(j) i .+ dl
I primes[j + 1] - primes[j] != diffs[j - i]
L.break
group[j - i + 1] = primes[j + 1]
L.was_no_break
results [+]= group
R results
V prime_list = primes_upto(1'000'000)
print(‘For primes less than 1,000,000:-’)
L(diffs) [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]]
print(‘ For differences of #. ->’.format(diffs))
V sp = successive_primes(prime_list, diffs)
print(‘ First group = ’sp[0])
print(‘ Last group = ’sp.last)
print(‘ Number found = ’sp.len)
print()</syntaxhighlight>
{{out}}
<pre>
For primes less than 1,000,000:-
For differences of [2] ->
First group = [3, 5]
Last group = [999959, 999961]
Number found = 8169
For differences of [1] ->
First group = [2, 3]
Last group = [2, 3]
Number found = 1
For differences of [2, 2] ->
First group = [3, 5, 7]
Last group = [3, 5, 7]
Number found = 1
For differences of [2, 4] ->
First group = [5, 7, 11]
Last group = [999431, 999433, 999437]
Number found = 1393
For differences of [4, 2] ->
First group = [7, 11, 13]
Last group = [997807, 997811, 997813]
Number found = 1444
For differences of [6, 4, 2] ->
First group = [31, 37, 41, 43]
Last group = [997141, 997147, 997151, 997153]
Number found = 306
</pre>
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN # find some sequences of primes where the gaps between the elements #
# follow specific patterns #
# reurns a list of primes up to n #
PROC prime list = ( INT n )[]INT:
BEGIN
# sieve the primes to n #
INT no = 0, yes = 1;
[ 1 : n ]INT p;
p[ 1 ] := no; p[ 2 ] := yes;
FOR i FROM 3 BY 2 TO n DO p[ i ] := yes OD;
FOR i FROM 4 BY 2 TO n DO p[ i ] := no OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( n ) DO
IF p[ i ] = yes THEN FOR s FROM i * i BY i + i TO n DO p[ s ] := no OD FI
OD;
# replace the sieve with a list #
INT p pos := 0;
FOR i TO n DO IF p[ i ] = yes THEN p[ p pos +:= 1 ] := i FI OD;
p[ 1 : p pos ]
END # prime list # ;
# prints the elements of list #
PROC print list = ( STRING name, []INT list )VOID:
BEGIN
print( ( name, "[" ) );
FOR i FROM LWB list TO UPB list DO print( ( " ", whole( list[ i ], 0 ) ) ) OD;
print( ( " ]" ) )
END # print list # ;
# attempts to find patterns in the differences of primes and prints the results #
PROC try differences = ( []INT primes, []INT pattern )VOID:
BEGIN
INT pattern length = ( UPB pattern - LWB pattern ) + 1;
[ 1 : pattern length + 1 ]INT first; FOR i TO UPB first DO first[ i ] := 0 OD;
[ 1 : pattern length + 1 ]INT last; FOR i TO UPB last DO last[ i ] := 0 OD;
INT count := 0;
FOR p FROM LWB primes + pattern length TO UPB primes DO
BOOL matched := TRUE;
INT e pos := LWB pattern;
FOR e FROM p - pattern length TO p - 1
WHILE matched := primes[ e + 1 ] - primes[ e ] = pattern[ e pos ]
DO
e pos +:= 1
OD;
IF matched THEN
# found a matching sequence #
count +:= 1;
last := primes[ p - pattern length : p @ 1 ];
IF count = 1 THEN first := last FI
FI
OD;
print( ( " Found ", whole( count, 0 ), " prime sequence(s) that differ by: " ) );
print list( "", pattern );
print( ( newline ) );
IF count > 0 THEN
# found at least one sequence #
print list( " first: ", first );
print list( " last: ", last );
print( ( newline ) )
FI;
print( ( newline ) )
END # try differences # ;
INT max number = 1 000 000;
[]INT p list = prime list( max number );
print( ( "For primes up to ", whole( max number, 0 ), "...", newline ) );
try differences( p list, ( 2 ) );try differences( p list, ( 1 ) );
try differences( p list, ( 2, 2 ) );try differences( p list, ( 2, 4 ) );
try differences( p list, ( 4, 2 ) );try differences( p list, ( 6, 4, 2 ) );
try differences( p list, ( 2, 4, 6, 8 ) );try differences( p list, ( 2, 4, 6, 8, 10 ) );
try differences( p list, ( 32, 16, 8, 4, 2 ) )
END</syntaxhighlight>
{{out}}
<pre>
For primes up to 1000000...
Found 8169 prime sequence(s) that differ by: [ 2 ]
first: [ 3 5 ] last: [ 999959 999961 ]
Found 1 prime sequence(s) that differ by: [ 1 ]
first: [ 2 3 ] last: [ 2 3 ]
Found 1 prime sequence(s) that differ by: [ 2 2 ]
first: [ 3 5 7 ] last: [ 3 5 7 ]
Found 1393 prime sequence(s) that differ by: [ 2 4 ]
first: [ 5 7 11 ] last: [ 999431 999433 999437 ]
Found 1444 prime sequence(s) that differ by: [ 4 2 ]
first: [ 7 11 13 ] last: [ 997807 997811 997813 ]
Found 306 prime sequence(s) that differ by: [ 6 4 2 ]
first: [ 31 37 41 43 ] last: [ 997141 997147 997151 997153 ]
Found 68 prime sequence(s) that differ by: [ 2 4 6 8 ]
first: [ 347 349 353 359 367 ] last: [ 984911 984913 984917 984923 984931 ]
Found 11 prime sequence(s) that differ by: [ 2 4 6 8 10 ]
first: [ 13901 13903 13907 13913 13921 13931 ] last: [ 954257 954259 954263 954269 954277 954287 ]
Found 1 prime sequence(s) that differ by: [ 32 16 8 4 2 ]
first: [ 148091 148123 148139 148147 148151 148153 ] last: [ 148091 148123 148139 148147 148151 148153 ]
</pre>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="c">
#proto buscarprimos(_X_,_Y_)
#include <basico.h>
algoritmo
pila de trabajo 50
decimales '0'
números( dif 1, dif 2, dif 22, dif 24, dif 42, dif 642)
cadenas( inicio1, inicio2, inicio22, inicio24, inicio42, inicio642,\
final1, final2, final22, final24, final42, final642 )
sw1=1, sw2=1, sw22=1, sw24=1, sw42=1, sw642=1
i=2
iterar
i, es primo?, entonces {
i2 = i, i4=i, i6=i
++i2; i2, es primo?, entonces{
++dif 1
sw1, entonces{
#( string(i)),#(string(i2)), unir en 'inicio1'
sw1=0
}
#( string(i)),#(string(i2)), unir en 'final1'
}
++i2; i2, es primo?, entonces{
++dif 2
sw2, entonces{
#( string(i)),#(string(i2)), unir en 'inicio2'
sw2=0
}
#( string(i)),#(string(i2)), unir en 'final2'
i2+=2; i2, es primo?, entonces{
++dif 22
sw22, entonces{
#( string(i)),#(string(i2-2)),#(string(i2))
unir en 'inicio22'
sw22=0
}
#( string(i)),#(string(i2-2)),#(string(i2))
unir en 'final22'
}
i2+=2; i2, es primo?, entonces{
++dif 24
sw24, entonces{
#( string(i)),#(string(i2-4)),#(string(i2))
unir en 'inicio24'
sw24=0
}
#( string(i)),#(string(i2-4)),#(string(i2))
unir en 'final24'
}
}
i4+=4, i4, es primo?, entonces{
i4+=2, i4, es primo?, entonces{
++dif 42
sw42, entonces{
#( string(i)),#(string(i4-2)),#(string(i4))
unir en 'inicio42'
sw42=0
}
#( string(i)),#(string(i4-2)),#(string(i4))
unir en 'final42'
}
}
/* aquí, debido al espaciamiento, pueden haber primos entre 'i'
e 'i+12', y debo chequear eso */
i6+=6, i6, es primo?, entonces{
i6+=4, i6, es primo?, entonces{
i6+=2, i6, es primo?, entonces{
si '#(buscar primos( (i+1),(i6-6) ) && buscar primos( (i6-5),i6-2))'
sw642, entonces{
#( string(i)),#(string(i6-6)),#(string(i6-2)),#(string(i6))
unir en 'inicio642'
sw642=0
}
++dif 642
fin si
#( string(i)),#(string(i6-6)),#(string(i6-2)),#(string(i6))
unir en 'final642'
}
}
}
}
++i
hasta que '#(i == 1000000)'
imprimir( "Diff Sequence\tCount\t\tFirst\tLast\n")
imprimir( "[ 1 ] \t", dif 1, "\t", #(lpad(" ",13,inicio1))," ",final1,\
"\n[ 2 ] \t", dif 2, "\t", #(lpad(" ",13,inicio2))," ",final2,\
"\n[ 2-2 ] \t", dif22, "\t", #(lpad(" ",13,inicio22))," ",final22,\
"\n[ 2-4 ] \t", dif 24,"\t", #(lpad(" ",13,inicio24))," ",final24,\
"\n[ 4-2 ] \t", dif 42,"\t", #(lpad(" ",13,inicio42))," ",final42,\
"\n[ 6-4-2 ]\t", dif 642,"\t", #(lpad(" ",13,inicio642))," ",final642,"\n")
terminar
subrutinas
buscar primos(x,y)
sw=1
iterar para( i=x, #(sw && i<y), ++i )
i, es primo?, entonces{
sw=0
}
siguiente
retornar 'sw'
</syntaxhighlight>
{{out}}
<pre>
Diff Sequence Count First Last
[ 1 ] 1 2,3 2,3
[ 2 ] 8169 3,5 999959,999961
[ 2-2 ] 1 3,5,7 3,5,7
[ 2-4 ] 1393 5,7,11 999431,999433,999437
[ 4-2 ] 1444 7,11,13 997807,997811,997813
[ 6-4-2 ] 306 31,37,41,43 997141,997147,997151,997153
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">LIM: 1000000
findDiffs: function [r][
if r=[1] -> return [[2 3]]
i: 3
tupled: map 0..dec size r 'x -> fold slice r 0 x [a b][a+b]
diffs: new []
while [i < LIM][
if prime? i [
prset: map tupled 't -> i + t
if every? prset 'elem -> prime? elem [
'diffs ++ @[@[i] ++ prset]
]
]
i: i + 2
]
diffs: filter diffs 'dd [
some? range (first dd)+1 (last dd)-1 'x -> and? [prime? x][not? contains? dd x]
]
return diffs
]
loop [[2] [1] [2 2] [2 4] [4 2] [6 4 2]] 'rng [
print ["Differences of" join.with:", " to [:string] rng]
diffs: findDiffs rng
print ["\tFirst: " join.with:" " to [:string] first diffs]
print ["\tLast: " join.with:" " to [:string] last diffs]
print ["\tCount: " size diffs]
]</syntaxhighlight>
{{out}}
<pre>Differences of 2
First: 3 5
Last: 999959 999961
Count: 8169
Differences of 1
First: 2 3
Last: 2 3
Count: 1
Differences of 2, 2
First: 3 5 7
Last: 3 5 7
Count: 1
Differences of 2, 4
First: 5 7 11
Last: 999431 999433 999437
Count: 1393
Differences of 4, 2
First: 7 11 13
Last: 997807 997811 997813
Count: 1444
Differences of 6, 4, 2
First: 31 37 41 43
Last: 997141 997147 997151 997153
Count: 306</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SUCCESSIVE_PRIME_DIFFERENCES.AWK
BEGIN {
Line 77 ⟶ 439:
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
Line 92 ⟶ 454:
112 1 370261,370373 370261,370373
</pre>
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#define PRIME_COUNT 100000
int64_t PRIMES[PRIME_COUNT];
size_t primeSize = 0;
bool isPrime(int n) {
size_t i = 0;
for (i = 0; i < primeSize; i++) {
int64_t p = PRIMES[i];
if (n == p) {
return true;
}
if (n % p == 0) {
return false;
}
if (p * p > n) {
break;
}
}
return true;
}
void initialize() {
int i;
PRIMES[primeSize++] = 2;
PRIMES[primeSize++] = 3;
PRIMES[primeSize++] = 5;
PRIMES[primeSize++] = 7;
PRIMES[primeSize++] = 11;
PRIMES[primeSize++] = 13;
PRIMES[primeSize++] = 17;
PRIMES[primeSize++] = 19;
for (i = 21; primeSize < PRIME_COUNT;) {
if (isPrime(i)) {
PRIMES[primeSize++] = i;
}
i += 2;
if (primeSize < PRIME_COUNT && isPrime(i)) {
PRIMES[primeSize++] = i;
}
i += 2;
}
}
void diff1(size_t diff) {
int64_t pm0, pm1;
int64_t fg1 = 0, fg2 = 0, lg1 = 0, lg2 = 0;
size_t pos, count = 0;
if (diff == 0) {
return;
}
pm0 = PRIMES[0];
for (pos = 1; pos < PRIME_COUNT; pos++) {
pm1 = pm0;
pm0 = PRIMES[pos];
if (pm0 > 1000000) {
break;
}
if (pm0 - pm1 == diff) {
count++;
if (fg1 == 0) {
fg1 = pm1;
fg2 = pm0;
}
lg1 = pm1;
lg2 = pm0;
}
}
printf("%ld|%d|%lld %lld|%lld %lld|\n", diff, count, fg1, fg2, lg1, lg2);
}
void diff2(size_t d0, size_t d1) {
int64_t pm0, pm1, pm2;
int64_t fg1 = 0, fg2, fg3, lg1, lg2, lg3;
size_t pos, count = 0;
if (d0 == 0 || d1 == 0) {
return;
}
pm1 = PRIMES[0];
pm0 = PRIMES[1];
for (pos = 2; pos < PRIME_COUNT; pos++) {
pm2 = pm1;
pm1 = pm0;
pm0 = PRIMES[pos];
if (pm0 > 1000000) {
break;
}
if (pm1 - pm2 == d0 && pm0 - pm1 == d1) {
count++;
if (fg1 == 0) {
fg1 = pm2;
fg2 = pm1;
fg3 = pm0;
}
lg1 = pm2;
lg2 = pm1;
lg3 = pm0;
}
}
printf("%d %d|%d|%lld %lld %lld|%lld %lld %lld|\n", d0, d1, count, fg1, fg2, fg3, lg1, lg2, lg3);
}
void diff3(size_t d0, size_t d1, size_t d2) {
int64_t pm0, pm1, pm2, pm3;
int64_t fg1 = 0, fg2, fg3, fg4, lg1, lg2, lg3, lg4;
size_t pos, count = 0;
if (d0 == 0 || d1 == 0 || d2 == 0) {
return;
}
pm2 = PRIMES[0];
pm1 = PRIMES[1];
pm0 = PRIMES[2];
for (pos = 3; pos < PRIME_COUNT; pos++) {
pm3 = pm2;
pm2 = pm1;
pm1 = pm0;
pm0 = PRIMES[pos];
if (pm0 > 1000000) {
break;
}
if (pm2 - pm3 == d0 && pm1 - pm2 == d1 && pm0 - pm1 == d2) {
count++;
if (fg1 == 0) {
fg1 = pm3;
fg2 = pm2;
fg3 = pm1;
fg4 = pm0;
}
lg1 = pm3;
lg2 = pm2;
lg3 = pm1;
lg4 = pm0;
}
}
printf("%d %d %d|%d|%lld %lld %lld %lld|%lld %lld %lld %lld|\n", d0, d1, d2, count, fg1, fg2, fg3, fg4, lg1, lg2, lg3, lg4);
}
int main() {
initialize();
printf("differences|count|first group|last group\n");
diff1(2);
diff1(1);
diff2(2, 2);
diff2(2, 4);
diff2(4, 2);
diff3(6, 4, 2);
return 0;
}</syntaxhighlight>
{{out}}
<pre>differences|count|first group|last group
2|8169|3 5|999959 999961|
1|1|2 3|2 3|
2 2|1|3 5 7|3 5 7|
2 4|1393|5 7 11|999431 999433 999437|
4 2|1444|7 11 13|997807 997811 997813|
6 4 2|306|31 37 41 43|997141 997147 997151 997153|</pre>
=={{header|C sharp}}==
<
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class SuccessivePrimeDifferences {
public static void Main() {
var primes = GeneratePrimes(1_000_000).ToList();
Line 121 ⟶ 663:
IEnumerable<IEnumerable<int>> FindDifferenceGroups(int[] diffs) {
for (int pi = diffs.Length; pi < primes.Count; pi++)
if (Range(0, diffs.Length).All(di => primes[pi-diffs.Length+di+1] - primes[pi-diffs.Length+di] == diffs[di]))
yield return Range(pi - diffs.Length, diffs.Length + 1).Select(i => primes[i]);
}
IEnumerable<int> GeneratePrimes(int lmt) {
bool[] comps = new bool[lmt + 1];
comps[0] = comps[1] = true;
yield return 2; yield return 3;
for (int j = 4; j <= lmt; j += 2) comps[j] = true;
for (int j = 9; j <= lmt; j += 6) comps[j] = true;
int i = 5, d = 4, rt = (int)Math.Sqrt(lmt);
for ( ; i <= rt; i += (d = 6 - d))
if (!comps[i]) {
yield return i;
for (int j = i * i, k = i << 1; j <= lmt; j += k)
comps[j] = true;
}
for ( ; i <= lmt; i += (d = 6 - d)) if (!comps[i]) yield return i;
}
}
}</syntaxhighlight>
{{out}}
<pre>
Line 141 ⟶ 696:
=={{header|C++}}==
<
#include <cstdint>
#include <vector>
#include "
using integer = uint32_t;
Line 202 ⟶ 757:
const integer limit = 1000000;
const size_t max_group_size = 4;
diffs d[] = { {2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2} };
vector group;
Line 219 ⟶ 774:
}
return 0;
}</
Contents of
<
#define
#include <algorithm>
#include <vector>
/**
* A simple implementation of the Sieve of Eratosthenes.
* See https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes.
*/
class prime_sieve {
public:
explicit
bool is_prime(size_t) const;
private:
Line 236 ⟶ 795:
};
/**
* Constructs a sieve with the given limit.
*
* @param limit the maximum integer that can be tested for primality
*/
inline
is_prime_.resize(limit/2, true);
for (size_t p = 3; p * p <= limit; p += 2) {
size_t inc = 2 * p;
is_prime_[q/2 - 1] = false;
}
}
}
/**
* Returns true if the given integer is a prime number. The integer
* must be less than or equal to the limit passed to the constructor.
*
* @param n an integer less than or equal to the limit passed to the
* constructor
* @return true if the integer is prime
*/
inline bool prime_sieve::is_prime(size_t n) const {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
return is_prime_.at(n/2 - 1);
}
#endif</syntaxhighlight>
{{out}}
Line 269 ⟶ 842:
=={{header|D}}==
{{trans|Go}}
<
import std.array;
import std.range;
Line 377 ⟶ 950:
writeln();
}
}</
{{out}}
<pre>For primes less than 1,000,000:-
Line 409 ⟶ 982:
Last group = [997141, 997147, 997151, 997153]
Number found = 306</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Generics.Collections}}
<syntaxhighlight lang="delphi">
program Successive_prime_differences;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
System.Generics.Collections;
function IsPrime(a: UInt64): Boolean;
var
d: UInt64;
begin
if (a < 2) then
exit(False);
if (a mod 2) = 0 then
exit(a = 2);
if (a mod 3) = 0 then
exit(a = 3);
d := 5;
while (d * d <= a) do
begin
if (a mod d = 0) then
Exit(false);
inc(d, 2);
if (a mod d = 0) then
Exit(false);
inc(d, 4);
end;
Result := True;
end;
function Primes(const limit: UInt64): TArray<UInt64>;
var
i: UInt64;
procedure Add(const value: UInt64);
begin
SetLength(result, Length(result) + 1);
Result[Length(result) - 1] := value;
end;
begin
if limit < 2 then
exit;
// 2 is the only even prime
Add(2);
i := 3;
while i <= limit do
begin
if IsPrime(i) then
Add(i);
inc(i, 2);
end;
end;
function Commatize(const n: UInt64): string;
var
str: string;
digits: Integer;
i: Integer;
begin
Result := '';
str := n.ToString;
digits := str.Length;
for i := 1 to digits do
begin
if ((i > 1) and (((i - 1) mod 3) = (digits mod 3))) then
Result := Result + ',';
Result := Result + str[i];
end;
end;
function CheckScan(index: Integer; p: TArray<UInt64>; pattern: array of Integer): Boolean;
var
i, last: Integer;
begin
last := Length(pattern) - 1;
for i := 0 to last do
if p[index - last + i - 1] + pattern[i] <> p[index - last + i] then
exit(False);
Result := True;
end;
const
GroupLabel: array[1..6] of string = ('(2)', '(1)', '(2, 2)', '(2, 4)',
'(4, 2)', '(6, 4, 2)');
var
limit, start: UInt64;
c: TArray<UInt64>;
i, j: UInt64;
Group: array[1..6] of Tlist<string>;
begin
for i := 1 to 6 do
Group[i] := Tlist<string>.Create;
limit := Trunc(1e6 - 1);
c := Primes(limit);
for j := 1 to High(c) do
begin
if CheckScan(j, c, [2]) then
Group[1].Add(format('(%d,%d)', [c[j - 1], c[j]]));
if CheckScan(j, c, [1]) then
Group[2].Add(format('(%d,%d)', [c[j - 1], c[j]]));
if j > 1 then
begin
if CheckScan(j, c, [2, 2]) then
Group[3].Add(format('(%d,%d,%d)', [c[j - 2], c[j - 1], c[j]]));
if CheckScan(j, c, [2, 4]) then
Group[4].Add(format('(%d,%d,%d)', [c[j - 2], c[j - 1], c[j]]));
if CheckScan(j, c, [4, 2]) then
Group[5].Add(format('(%d,%d,%d)', [c[j - 2], c[j - 1], c[j]]));
end;
if j > 2 then
if CheckScan(j, c, [6, 4, 2]) then
Group[6].Add(format('(%d,%d,%d,%d)', [c[j - 3], c[j - 2], c[j - 1], c[j]]));
end;
for i := 1 to 6 do
begin
Write(GroupLabel[i], ': first group = ', Group[i].First);
Writeln(', last group = ', Group[i].last, ', count = ', Group[i].Count);
Group[i].free;
end;
readln;
end.
</syntaxhighlight>
{{out}}
<pre>
(2): first group = (3,5), last group = (999959,999961), count = 8169
(1): first group = (2,3), last group = (2,3), count = 1
(2, 2): first group = (3,5,7), last group = (3,5,7), count = 1
(2, 4): first group = (5,7,11), last group = (999431,999433,999437), count = 1393
(4, 2): first group = (7,11,13), last group = (997807,997811,997813), count = 1444
(6, 4, 2): first group = (31,37,41,43), last group = (997141,997147,997151,997153), count = 306
</pre>
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight>
fastfunc isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func nextprime n .
n += 1
while isprim n = 0
n += 1
.
return n
.
func spd n d[] .
if isprim n = 0
return 0
.
for i = 1 to len d[]
if nextprime n <> n + d[i]
return 0
.
n += d[i]
.
return 1
.
proc print_set n d[] . .
write "( " & n & " "
for i = 1 to len d[]
write n + d[i] & " "
n += d[i]
.
print ")"
.
proc show max d[] . .
write "Differences of "
for d in d[]
write d & " "
.
print ""
for n = 2 to max - d[len d[]]
if spd n d[] = 1
c += 1
if c = 1
print_set n d[]
.
last = n
.
.
print_set last d[]
print "Number of occurrences: " & c
print ""
.
show 1000000 [ 2 ]
show 1000000 [ 1 ]
show 1000000 [ 2 2 ]
show 1000000 [ 2 4 ]
show 1000000 [ 4 2 ]
show 1000000 [ 6 4 2 ]
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]
<
// Successive primes. Nigel Galloway: May 6th., 2019
let sP n=let sP=pCache|>Seq.takeWhile(fun n->n<1000000)|>Seq.windowed(Array.length n+1)|>Seq.filter(fun g->g=(Array.scan(fun n g->n+g) g.[0] n))
printfn "sP %A\t-> Min element = %A Max element = %A of %d elements" n (Seq.head sP) (Seq.last sP) (Seq.length sP)
List.iter sP [[|2|];[|1|];[|2;2|];[|2;4|];[|4;2|];[|6;4;2|]]
</syntaxhighlight>
{{out}}
<pre>
Line 430 ⟶ 1,234:
=={{header|Factor}}==
{{works with|Factor|0.99}}
<
math.statistics sequences ;
IN: rosetta-code.successive-prime-differences
Line 456 ⟶ 1,260:
} [ show ] with each ;
MAIN: successive-prime-differences</
{{out}}
<pre>
Line 489 ⟶ 1,293:
Last group: { 997141 997147 997151 997153 }
Count: 306
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#include "isprime.bas"
function nextprime( n as uinteger ) as uinteger
'finds the next prime after n
if n = 0 then return 2
if n < 3 then return n + 1
dim as integer q = n + 2
while not isprime(q)
q+=2
wend
return q
end function
function spd( byval n as integer, d() as integer ) as boolean
if not isprime(n) then return false
for i as integer = lbound(d) to ubound(d)
if not nextprime(n) = n + d(i) then return false
n+=d(i)
next i
return true
end function
sub print_set( byval n as uinteger, d() as uinteger )
print "( ";n;" ";
for i as integer = lbound(d) to ubound(d)
print n+d(i);" ";
n+=d(i)
next i
print ")"
end sub
function count_below( max as uinteger, d() as uinteger ) as uinteger
dim as uinteger c = 0, last = 0
for n as uinteger = 2 to max-d(ubound(d))
if spd(n, d()) then
c+=1
if c=1 then print_set( n, d() )
last = n
end if
next n
print_set(last, d())
return c
end function
dim as integer n, c
'example 1, differences of 2
redim as uinteger d(0)
d(0) = 2
print "Differences of 2 (the twin primes)"
c = count_below(1000000, d())
print "Number of occurrences: ", c
'example 2, difference of 1
d(0) = 1
print
print "Differences of 1"
c = count_below(1000000, d())
print "Number of occurrences: ", c
'example 3, differences of 2,2
redim as uinteger d(1)
d(0) = 2 : d(1) = 2
print
print "Differences of 2, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c
'example 4, differences of 2,4
d(1) = 4
print
print "Differences of 2, 4"
c = count_below(1000000, d())
print "Number of occurrences: ", c
'example 5, differences of 2,2
d(0) = 4 : d(1) = 2
print
print "Differences of 4, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c
'example 6, differences of 6,4,2
redim as uinteger d(2)
d(0) = 6 : d(1) = 4 : d(2) = 2
print
print "Differences of 6, 4, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c</syntaxhighlight>
{{out}}<pre>
Differences of 2 (the twin primes)
( 3 5 )
( 999959 999961 )
Number of occurrences: 8169
Differences of 1
( 2 3 )
( 2 3 )
Number of occurrences: 1
Differences of 2, 2
( 3 5 7 )
( 3 5 7 )
Number of occurrences: 1
Differences of 2, 4
( 5 7 11 )
( 999431 999433 999437 )
Number of occurrences: 1393
Differences of 4, 2
( 7 11 13 )
( 997807 997811 997813 )
Number of occurrences: 1444
Differences of 6, 4, 2
( 31 37 41 43 )
( 997141 997147 997151 997153 )
Number of occurrences: 306
</pre>
=={{header|Go}}==
<
import "fmt"
Line 560 ⟶ 1,486:
fmt.Println()
}
}</
{{out}}
Line 596 ⟶ 1,522:
Number found = 306
</pre>
=={{header|Haskell}}==
Uses primes library: http://hackage.haskell.org/package/primes-0.2.1.0/docs/Data-Numbers-Primes.html
===Fixed computed values===
<
import Data.Numbers.Primes (primes)
Line 630 ⟶ 1,557:
main :: IO ()
main = showGroup "2" >> showGroup "1" >> showGroup "(2 2)" >> showGroup "(2 4)" >> showGroup "(4 2)"
>> showGroup "(6 4 2)"</
===Dynamic computed input===
<
import Data.Numbers.Primes (primes)
Line 643 ⟶ 1,570:
findPrimes primes diffs = loopDiffs diffs <> findPrimes (tail primes) diffs
where
loopDiffs
let successive = take (length d + 1) primes,
subs = map (uncurry (-)) . init . tail . (\xs -> zip (xs <> [0]) (0 : xs))
showGroup :: Result -> String -> IO ()
Line 661 ⟶ 1,586:
++ "\n"
where
groups =
firstGroup = show . head
lastGroup = show . last
Line 669 ⟶ 1,594:
where
(diffs, result) = groups [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]]
groups diffs = (diffs, findPrimes (takeWhile (< 1_000_000) primes) diffs)</
{{out}}
<pre>
Line 698 ⟶ 1,623:
=={{header|J}}==
<syntaxhighlight lang="j">
primes_less_than=: i.&.:(p:inv)
assert 2 3 5 -: primes_less_than 7
NB. Insert minus `-/' into the length two infixes `\'.
NB. Passive `~' swaps the arguments producing the positive differences.
assert 8169 -: +/ 2 =
end_groups=:
┌─────┬─────┬───────────────────────────┐
├─────┼─────┼───────────────────────────┤
│2 │8169 │ 3 5 │
Line 736 ⟶ 1,661:
│6 4 2│306 │ 31 37 41 43│
│ │ │997141 997147 997151 997153│
└─────┴─────┴───────────────────────────┘</
=={{header|Java}}==
{{trans|Go}}
<
import java.util.Arrays;
import java.util.List;
Line 807 ⟶ 1,732:
}
}
}</
{{out}}
<pre>For primes less than 1,000,000:-
Line 841 ⟶ 1,766:
Number found = 306</pre>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
For a suitable implementation of `is_prime` as used here, see e.g. # [[Erd%C5%91s-primes#jq]].
<syntaxhighlight lang="jq"># Emit a stream of consecutive primes.
# The stream is unbounded if . is null or infinite,
# otherwise it continues up to but excluding `.`.
def primes:
(if . == null then infinite else . end) as $n
| 2, (range(3; $n; 2) | select(is_prime));
# s is a stream
# $deltas is an array
# Output: a stream of arrays, each corresponding to a selection of consecutive
# items from s satisfying the differences requirement.
def filter_differences(s; $deltas):
def diffs_equal: # i.e. equal to $deltas
. as $in
| all( range(1;length);
($in[.] - $in[.-1]) == $deltas[. - 1]);
($deltas|length + 1) as $n
| foreach s as $x ( {};
.emit = null
| .tuple += [$x]
| .tuple |= .[-$n:]
| if (.tuple|length) == $n
then if (.tuple|diffs_equal) then .emit = .tuple
else .
end
else .
end;
select(.emit).emit );
def report_first_last_count(s):
null | {first,last,count}
| reduce s as $x (.;
if .first == null then .first = $x else . end
| .count = .count + 1
| .last = $x ) ;
</syntaxhighlight>
'''The Tasks'''
<syntaxhighlight lang="jq">[pow(10;6) | primes] as $p1e6
| ([2], [1], [2,2], [2,4], [4,2], [6,4,2]) as $d
| ("\nFor deltas = \($d):", report_first_last_count(filter_differences($p1e6[]; $d ) ) )</syntaxhighlight>
{{out}}
<pre>
For deltas = [2]:
{"first":[3,5],"last":[999959,999961],"count":8169}
For deltas = [1]:
{"first":[2,3],"last":[2,3],"count":1}
For deltas = [2,2]:
{"first":[3,5,7],"last":[3,5,7],"count":1}
For deltas = [2,4]:
{"first":[5,7,11],"last":[999431,999433,999437],"count":1393}
For deltas = [4,2]:
{"first":[7,11,13],"last":[997807,997811,997813],"count":1444}
For deltas = [6,4,2]:
{"first":[31,37,41,43],"last":[997141,997147,997151,997153],"count":306}
</pre>
=={{header|Julia}}==
<
function filterdifferences(deltas, N)
Line 865 ⟶ 1,857:
filterdifferences([[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]], 1000000)
</
<pre>
Diff Sequence Count First Last
Line 875 ⟶ 1,867:
[6, 4, 2] 306 [31, 37, 41, 43]...[997141, 997147, 997151, 997153]
</pre>
=={{header|Lua}}==
This task uses <code>primegen</code> from: [[Extensible_prime_generator#Lua]]
<syntaxhighlight lang="lua">function findspds(primelist, diffs)
local results = {}
for i = 1, #primelist-#diffs do
result = {primelist[i]}
for j = 1, #diffs do
if primelist[i+j] - primelist[i+j-1] == diffs[j] then
result[j+1] = primelist[i+j]
else
result = nil
break
end
end
results[#results+1] = result
end
return results
end
primegen:generate(nil, 1000000)
for _,diffs in ipairs{{2}, {1}, {2,2}, {2,4}, {4,2}, {6,4,2}} do
spdlist = findspds(primegen.primelist, diffs)
print("DIFFS: ["..table.concat(diffs," ").."]")
print("COUNT: "..#spdlist)
print("FIRST: ["..table.concat(spdlist[1]," ").."]")
print("LAST : ["..table.concat(spdlist[#spdlist]," ").."]")
print()
end</syntaxhighlight>
{{out}}
<pre>DIFFS: [2]
COUNT: 8169
FIRST: [3 5]
LAST : [999959 999961]
DIFFS: [1]
COUNT: 1
FIRST: [2 3]
LAST : [2 3]
DIFFS: [2 2]
COUNT: 1
FIRST: [3 5 7]
LAST : [3 5 7]
DIFFS: [2 4]
COUNT: 1393
FIRST: [5 7 11]
LAST : [999431 999433 999437]
DIFFS: [4 2]
COUNT: 1444
FIRST: [7 11 13]
LAST : [997807 997811 997813]
DIFFS: [6 4 2]
COUNT: 306
FIRST: [31 37 41 43]
LAST : [997141 997147 997151 997153]</pre>
=={{header|Kotlin}}==
{{trans|Java}}
<
val primes = mutableListOf<Int>()
primes.add(2)
Line 948 ⟶ 1,999:
println()
}
}</
{{out}}
<pre>For primes less than 1,000,000:-
Line 981 ⟶ 2,032:
Last group = [997141, 997147, 997151, 997153]
Number found = 306</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[Primediffs]
p = Prime[Range[PrimePi[10^6]]];
Primediffs[seq_] := {First[#], Last[#], Length[#]} &[p[[#1 ;; #2 + 1]] & @@@ SequencePosition[Differences[p], seq]]
Primediffs[{2}]
Primediffs[{1}]
Primediffs[{2, 2}]
Primediffs[{2, 4}]
Primediffs[{4, 2}]
Primediffs[{6, 4, 2}]</syntaxhighlight>
{{out}}
<pre>{{3,5},{999959,999961},8169}
{{2,3},{2,3},1}
{{3,5,7},{3,5,7},1}
{{5,7,11},{999431,999433,999437},1393}
{{7,11,13},{997807,997811,997813},1444}
{{31,37,41,43},{997141,997147,997151,997153},306}</pre>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import math, strutils
const N = 1_000_000
var comp: array[2..(N - 1), bool] # True is composite, so default is prime.
for n in 2..<N:
if not comp[n]:
for k in countup(n * n, N - 1, n):
comp[k] = true
var primes = @[2]
for n in countup(3, N - 1, 2):
if not comp[n]:
primes.add n
iterator groups(primes: seq[int]; diffs: varargs[int]): seq[int] =
## Yield groups of successive primes with given differences.
var cumdiffs = cumsummed(diffs) # Compute differences from first prime of group.
let groupSize = diffs.len + 1
for i in 0..(primes.len - groupSize):
let p = primes[i]
var group = @[p]
for k, diff in cumdiffs:
if primes[i + k + 1] != p + diff: break
group.add p + diff
if group.len == groupSize:
yield group
proc findGroups(primes: seq[int]; diffs: varargs[int]) =
## In the given list of primes and for the given differences,
## find the first group, the last group and the count of groups.
var
first, last: seq[int]
count = 0
for group in primes.groups(diffs):
if first.len == 0: first = group
last = group
inc count
echo "Differences: ", diffs.join(", ")
echo "– first: ($#)" % first.join(", ")
echo "– last: ($#)" % last.join(", ")
echo "– count: ", count
echo()
primes.findGroups(2)
primes.findGroups(1)
primes.findGroups(2, 2)
primes.findGroups(2, 4)
primes.findGroups(4, 2)
primes.findGroups(6, 4, 2)</syntaxhighlight>
{{out}}
<pre>Differences: 2
– first: (3, 5)
– last: (999959, 999961)
– count: 8169
Differences: 1
– first: (2, 3)
– last: (2, 3)
– count: 1
Differences: 2, 2
– first: (3, 5, 7)
– last: (3, 5, 7)
– count: 1
Differences: 2, 4
– first: (5, 7, 11)
– last: (999431, 999433, 999437)
– count: 1393
Differences: 4, 2
– first: (7, 11, 13)
– last: (997807, 997811, 997813)
– count: 1444
Differences: 6, 4, 2
– first: (31, 37, 41, 43)
– last: (997141, 997147, 997151, 997153)
– count: 306</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use List::EachCons;
use Array::Compare;
use ntheory 'primes';
Line 996 ⟶ 2,146:
my @intervals = map { $primes[$_] - $primes[$_-1] } 1..$#primes;
my $c = Array::Compare->new;
for my $diffs ([2], [1], [2,2], [2,4], [4,2], [6,4,2]) {
my $n = -1;
my @offsets = grep {$_} each_cons @$diffs, @intervals, sub { $n++; $n if $c->compare(\@_,
printf "%10s has %5d sets: %15s … %s\n",
'(' . join(' ',@$diffs) . ')',
Line 1,006 ⟶ 2,157:
join(' ', @primes[$offsets[ 0]..($offsets[ 0]+@$diffs)]),
join(' ', @primes[$offsets[-1]..($offsets[-1]+@$diffs)]);
}</
{{out}}
<pre> (2) has 8169 sets: 3 5 … 999959 999961
Line 1,016 ⟶ 2,167:
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1_000_000</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">differences</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">ld</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">differences</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">ld</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">pi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">ld</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">pi</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">differences</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">pi</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">pi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">pi</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">ld</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;">for</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">differences</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[$]}</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%8V : %8d %14V...%V\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Differences Count First Last\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}},</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,051 ⟶ 2,202:
{4,2} : 1444 {7,11,13}...{997807,997811,997813}
{6,4,2} : 306 {31,37,41,43}...{997141,997147,997151,997153}
</pre>
=={{header|Picat}}==
{{trans|Prolog}}
<syntaxhighlight lang="picat">main =>
Num is 1_000_000,
statistics(runtime,[Start|_]),
PrimeList = primes(Num),
NumPrimes = PrimeList.len,
statistics(runtime,[Stop|_]),
RunTime = Stop - Start,
printf("There are %w primes until %w [time(ms) %w]%n",NumPrimes, Num, RunTime),
DiffList = [[1], [2], [2,2], [2,4], [4,2], [2,4,6],
[2,6,4], [4,2,6], [4,6,2], [6,2,4], [6,4,2],[6,4,2,4]],
run(DiffList, PrimeList).
primesByDiffs([],_,[]).
primesByDiffs([Prime|Primes], Diff, [Slide|Slides]):-
Slide = new_list(Diff.len+1),
append(Slide, _, [Prime|Primes]),
select(Diff, Slide),!,
primesByDiffs(Primes, Diff, Slides).
primesByDiffs([_|Primes], Diff, Slides):-
primesByDiffs(Primes, Diff, Slides).
select([],_).
select([Diff|Diffs],[S1, S2|Stail]):-
S2 = S1 + Diff,
select(Diffs, [S2|Stail]).
run([],_).
run([Diff|Dtail], PrimeList):-
statistics(runtime,[Start|_]),
primesByDiffs(PrimeList, Diff, SlideList),
Num = SlideList.len,
statistics(runtime,[Stop|_]),
Runtime = Stop - Start,
printf("%-10w number: %5w (%2wms) first: %-22w last: %-22w\n", Diff, Num, Runtime, SlideList.first, SlideList.last),
!,
run(Dtail, PrimeList).</syntaxhighlight>
{{out}}
<pre>There are 78498 primes until 1000000 [time(ms) 130]
[1] number: 1 ( 9ms) first: [2,3] last: [2,3]
[2] number: 8169 (10ms) first: [3,5] last: [999959,999961]
[2,2] number: 1 (10ms) first: [3,5,7] last: [3,5,7]
[2,4] number: 1393 (11ms) first: [5,7,11] last: [999431,999433,999437]
[4,2] number: 1444 (10ms) first: [7,11,13] last: [997807,997811,997813]
[2,4,6] number: 279 (12ms) first: [17,19,23,29] last: [997097,997099,997103,997109]
[2,6,4] number: 297 (12ms) first: [29,31,37,41] last: [979541,979543,979549,979553]
[4,2,6] number: 162 (12ms) first: [67,71,73,79] last: [980587,980591,980593,980599]
[4,6,2] number: 300 (12ms) first: [19,23,29,31] last: [997099,997103,997109,997111]
[6,2,4] number: 159 (12ms) first: [1601,1607,1609,1613] last: [997091,997097,997099,997103]
[6,4,2] number: 306 (13ms) first: [31,37,41,43] last: [997141,997147,997151,997153]
[6,4,2,4] number: 62 (13ms) first: [31,37,41,43,47] last: [959461,959467,959471,959473,959477]
</pre>
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">prime(2). % use swi prolog
prime(N):-
N /\ 1 > 0, % odd
M is floor(sqrt(N)) - 1, % reverse 2*I+1
Max is M // 2, % integer division
forall(between(1, Max, I), N mod (2*I+1) > 0).
primesByDiffs([],_,[]).
primesByDiffs([Prime|Primes], Diff, [Slide|Slides]):-
length(Diff, Len0),
Len is Len0 + 1,
length(Slide, Len),
append(Slide, _, [Prime|Primes]),
select(Diff, Slide),!,
primesByDiffs(Primes, Diff, Slides).
primesByDiffs([_|Primes], Diff, Slides):-
primesByDiffs(Primes, Diff, Slides).
select([],_).
select([Diff|Diffs],[S1, S2|Stail]):-
S2 is S1 + Diff,
select(Diffs, [S2|Stail]).
run([],_).
run([Diff|Dtail], PrimeList):-
statistics(runtime,[Start|_]),
primesByDiffs(PrimeList, Diff, SlideList),
length(SlideList, Num),
statistics(runtime,[Stop|_]),
Runtime is Stop - Start,
SlideList = [First|SlideTail],
format('~|~w~t~7+ number: ~|~t~d~4+ [time(ms) ~|~t~d~3+] first: ~|~w~t~22+',[Diff, Num, Runtime, First]),
writeLast(SlideTail),!, nl,
run(Dtail, PrimeList).
writeLast([]).
writeLast(SlideTail):-
last(SlideTail, Last),
format('last: ~w',[Last]).
do:- Num is 1000000,
statistics(runtime,[Start|_]),
numlist(2, Num, List),
include(prime, List, PrimeList),
length(PrimeList, NumPrimes),
statistics(runtime,[Stop|_]),
RunTime is Stop - Start,
format('there are ~w primes until ~w [time(ms) ~w]~n',[NumPrimes, Num, RunTime]),
DiffList = [[1], [2], [2,2], [2,4], [4,2], [2,4,6],
[2,6,4], [4,2,6], [4,6,2], [6,2,4], [6,4,2]],
run(DiffList, PrimeList).</syntaxhighlight>
{{out}}
<pre>?- do.
there are 78498 primes until 1000000 [time(ms) 14614]
[1] number: 1 [time(ms) 123] first: [2,3]
[2] number: 8169 [time(ms) 124] first: [3,5] last: [999959,999961]
[2,2] number: 1 [time(ms) 131] first: [3,5,7]
[2,4] number: 1393 [time(ms) 133] first: [5,7,11] last: [999431,999433,999437]
[4,2] number: 1444 [time(ms) 133] first: [7,11,13] last: [997807,997811,997813]
[2,4,6] number: 279 [time(ms) 141] first: [17,19,23,29] last: [997097,997099,997103,997109]
[2,6,4] number: 297 [time(ms) 141] first: [29,31,37,41] last: [979541,979543,979549,979553]
[4,2,6] number: 162 [time(ms) 142] first: [67,71,73,79] last: [980587,980591,980593,980599]
[4,6,2] number: 300 [time(ms) 141] first: [19,23,29,31] last: [997099,997103,997109,997111]
[6,2,4] number: 159 [time(ms) 142] first: [1601,1607,1609,1613] last: [997091,997097,997099,997103]
[6,4,2] number: 306 [time(ms) 142] first: [31,37,41,43] last: [997141,997147,997151,997153]
true.
</pre>
Line 1,056 ⟶ 2,331:
Uses the [https://www.sympy.org/en/index.html Sympy] library.
<
from sympy import Sieve
Line 1,090 ⟶ 2,365:
print(" First group:", str(first)[1:-1])
print(" Last group:", str(last)[1:-1])
print(" Count:", count)</
{{out}}
Line 1,124 ⟶ 2,399:
Essentially the code from the [[Sexy_primes#Raku|Sexy primes]] task with minor tweaks.
<syntaxhighlight lang="raku"
my $sieve = Math::Primesieve.new;
Line 1,154 ⟶ 2,429:
}
say ' Count: ', +$primes{$i}, "\n";
}</
{{out}}
<pre>## Sets of 2 successive primes <= 1,000,000 with successive differences of 2
Line 1,188 ⟶ 2,463:
===Precomputed Differences===
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku"
constant $max = 1_000_000;
Line 1,206 ⟶ 2,481:
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:
Line 1,217 ⟶ 2,492:
=={{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.*/
Line 1,261 ⟶ 2,536:
do m=jj to N by j+j; @.m=; end /*odd multiples.*/
end /* [↑] strike odd multiples ¬ prime. */
end /*j*/; return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,294 ⟶ 2,569:
count: 306
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl + nl
see "For primes less than 1,000,000:" + nl + nl
num = 0
limit = 1000000
Primes = []
SuccPrimes = []
Sp = [[2],[1],[2,2],[2,4],[4,2],[6,4,2]]
for n = 1 to limit
if isprime(n)
add(Primes,n)
ok
next
for n = 1 to len(Sp)
num = 0
for m = 1 to len(Primes)-len(Sp[n])
flag = 0
SuccPrimes = []
for p = 1 to len(Sp[n])
if (Primes[m+p]-Primes[m+p-1] = Sp[n][p])
flag++
add(SuccPrimes,Primes[m+p])
add(SuccPrimes,Primes[m+p-1])
else
exit
ok
next
SuccPrimes = sort(SuccPrimes)
for x = len(SuccPrimes) to 2 step -1
if SuccPrimes[x] = SuccPrimes[x-1]
del(SuccPrimes,x)
ok
next
if len(SuccPrimes) = len(Sp[n])+1
num++
LastSuccPrimes = SuccPrimes
if num = 1
see "For differences of "
showArray(Sp[n])
see " ->" + nl
see " First group = "
showArray(SuccPrimes)
see nl
ok
ok
next
see " Last group = "
showArray(LastSuccPrimes)
see nl
see " Number found = " + num + nl + nl
next
see "done..." + nl
func showArray(array)
txt = ""
see "["
for n = 1 to len(array)
txt = txt + array[n] + ","
next
txt = left(txt,len(txt)-1)
txt = txt + "]"
see txt
</syntaxhighlight>
{{out}}
<pre>
working...
For primes less than 1,000,000:
For differences of [2] ->
First group = [3,5]
Last group = [999959,999961]
Number found = 8169
For differences of [1] ->
First group = [2,3]
Last group = [2,3]
Number found = 1
For differences of [2,2] ->
First group = [3,5,7]
Last group = [3,5,7]
Number found = 1
For differences of [2,4] ->
First group = [5,7,11]
Last group = [999431,999433,999437]
Number found = 1393
For differences of [4,2] ->
First group = [7,11,13]
Last group = [997807,997811,997813]
Number found = 1444
For differences of [6,4,2] ->
First group = [31,37,41,43]
Last group = [997141,997147,997151,997153]
Number found = 306
done...
</pre>
=={{header|RPL}}==
{{works with|HP|49}}
« DUP SIZE 1 + { } DUP 0 → diff n first last count
« 1
2 n '''START''' DUP NEXTPRIME '''NEXT'''
'''WHILE''' DUP 1000000 < '''REPEAT'''
n ROLL DROP DUP NEXTPRIME
n DUPN n →LIST
'''IF''' DUP ΔLIST diff == '''THEN'''
1 →LIST
'''IF''' first SIZE THEN 'last' '''ELSE''' 'first' '''END''' STO
1 'count' STO+
'''ELSE''' DROP '''END'''
'''END'''
n DROPN first last + count
» » '<span style="color:blue">SUCCP</span>' STO
{ 2 4 } <span style="color:blue">SUCCP</span>
{{out}}
<pre>
2: { { 5 7 11 } { 999431 999433 999437 } }
1: 1393
</pre>
=={{header|Ruby}}==
<
PRIMES = Prime.each(1_000_000).to_a
difs = [[2], [1], [2,2], [2,4], [4,2], [6,4,2]]
Line 1,306 ⟶ 2,714:
puts "#{ar} has #{res.size} sets. #{res.first}...#{res.last}"
end
</syntaxhighlight>
{{output}}
<pre>[2] has 8169 sets. [3, 5]...[999959, 999961]
Line 1,314 ⟶ 2,722:
[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|Rust}}==
<syntaxhighlight lang="rust">
fn is_prime(num: u32) -> bool {
match num {
x if x < 4 => x > 1,
x if x % 2 == 0 => false,
x => { let limit = (x as f32).sqrt().ceil() as u32;
(3..=limit).step_by(2).all(|a| x % a != 0)
}
}
}
fn primes_by_diffs(primes: &[u32], diffs: &[u32]) -> Vec<Vec<u32>> {
fn select(diffs: &[u32], prime_win: &[u32], acc: bool) -> bool {
if diffs.is_empty() || !acc {
acc
}
else {
let acc1 = prime_win[0] + diffs[0] == prime_win[1];
select(&diffs[1..], &prime_win[1..], acc1)
}
}
primes.windows(diffs.len() + 1)
.filter(|&win| select(diffs, win, true))
.map(|win| win.to_vec())
.collect()
}
fn main() {
let limit = 1_000_000u32;
let start = std::time::Instant::now();
let primes = (2..).filter(|&i| is_prime(i));
let prime_list: Vec<u32> = primes.take_while(|&p| p <= limit).collect();
let duration = start.elapsed();
println!("primes time: {:?}", duration);
for diffs in vec!(vec!(1), vec!(2), vec!(2,2), vec!(2,4), vec!(4,2), vec!(6,4,2), vec!(2,4,6)) {
let result_list = primes_by_diffs(&prime_list, &diffs);
let len = result_list.len();
println!("{:?} number: {}\n\tfirst: {:?}", diffs, len, result_list[0]);
if len == 1 {
println!()
}
if len > 1 {
println!("\tlast: {:?}\n", result_list.last().unwrap())
}
}
}
</syntaxhighlight>
{{out}}
<pre>
primes time: 422.406627ms
[1] number: 1
first: [2, 3]
[2] number: 8169
first: [3, 5]
last: [999959, 999961]
[2, 2] number: 1
first: [3, 5, 7]
[2, 4] number: 1393
first: [5, 7, 11]
last: [999431, 999433, 999437]
[4, 2] number: 1444
first: [7, 11, 13]
last: [997807, 997811, 997813]
[6, 4, 2] number: 306
first: [31, 37, 41, 43]
last: [997141, 997147, 997151, 997153]
[2, 4, 6] number: 279
first: [17, 19, 23, 29]
last: [997097, 997099, 997103, 997109]
</pre>
=={{header|Scala}}==
<
def main(args: Array[String]): Unit = {
val d2 = primesByDiffs(2)(1000000)
Line 1,346 ⟶ 2,834:
def primesSliding(len: Int): Iterator[Vector[Int]] = primes.sliding(len).map(_.toVector)
def primes: LazyList[Int] = 2 #:: LazyList.from(3, 2).filter(n => !Iterator.range(3, math.sqrt(n).toInt + 1, 2).exists(n%_ == 0))
}</
{{out}}
Line 1,358 ⟶ 2,846:
=={{header|Sidef}}==
<
var primes = limit.primes
Line 1,374 ⟶ 2,862:
say ("...for differences #{diffs}, there are #{groups.len} groups, where ",
"the first group = #{groups.first} and the last group = #{groups.last}")
}</
{{out}}
<pre>
Line 1,384 ⟶ 2,872:
...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>
=={{header|Visual Basic .NET}}==
{{trans|Java}}
<syntaxhighlight lang="vbnet">Imports System.Text
Module Module1
Function Sieve(limit As Integer) As Integer()
Dim primes As New List(Of Integer) From {2}
Dim c(limit + 1) As Boolean REM composite = true
REM no need to process even numbers > 2
Dim p = 3
While True
Dim p2 = p * p
If p2 > limit Then
Exit While
End If
For i = p2 To limit Step 2 * p
c(i) = True
Next
Do
p += 2
Loop While c(p)
End While
For i = 3 To limit Step 2
If Not c(i) Then
primes.Add(i)
End If
Next
Return primes.ToArray
End Function
Function SuccessivePrimes(primes() As Integer, diffs() As Integer) As List(Of List(Of Integer))
Dim results As New List(Of List(Of Integer))
Dim dl = diffs.Length
Dim i = 0
While i < primes.Length - dl
Dim group(dl) As Integer
group(0) = primes(i)
Dim j = i
While j < i + dl
If primes(j + 1) - primes(j) <> diffs(j - i) Then
GoTo outer REM continue the outermost loop
End If
group(j - i + 1) = primes(j + 1)
j += 1
End While
results.Add(group.ToList)
outer:
i += 1
End While
Return results
End Function
Function CollectionToString(Of T)(c As IEnumerable(Of T)) As String
Dim builder As New StringBuilder
builder.Append("[")
Dim it = c.GetEnumerator()
If it.MoveNext() Then
builder.Append(it.Current)
End If
While it.MoveNext()
builder.Append(", ")
builder.Append(it.Current)
End While
builder.Append("]")
Return builder.ToString
End Function
Sub Main()
Dim primes = Sieve(999999)
Dim diffsList = {({2}), ({1}), ({2, 2}), ({2, 4}), ({4, 2}), ({6, 4, 2})}
Console.WriteLine("For primes less than 1,000,000:-")
Console.WriteLine()
For Each diffs In diffsList
Console.WriteLine(" For differences of {0} ->", CollectionToString(diffs))
Dim sp = SuccessivePrimes(primes, diffs)
If sp.Count = 0 Then
Console.WriteLine(" No groups found")
Continue For
End If
Console.WriteLine(" First group = {0}", CollectionToString(sp(0)))
Console.WriteLine(" Last group = {0}", CollectionToString(sp(sp.Count - 1)))
Console.WriteLine(" Number found = {0}", sp.Count)
Console.WriteLine()
Next
End Sub
End Module</syntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-
For differences of [2] ->
First group = [3, 5]
Last group = [999959, 999961]
Number found = 8169
For differences of [1] ->
First group = [2, 3]
Last group = [2, 3]
Number found = 1
For differences of [2, 2] ->
First group = [3, 5, 7]
Last group = [3, 5, 7]
Number found = 1
For differences of [2, 4] ->
First group = [5, 7, 11]
Last group = [999431, 999433, 999437]
Number found = 1393
For differences of [4, 2] ->
First group = [7, 11, 13]
Last group = [997807, 997811, 997813]
Number found = 1444
For differences of [6, 4, 2] ->
First group = [31, 37, 41, 43]
Last group = [997141, 997147, 997151, 997153]
Number found = 306</pre>
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-math}}
<syntaxhighlight lang="wren">import "./math" for Int
var successivePrimes = Fn.new { |primes, diffs|
var results = []
var dl = diffs.count
for (i in 0...primes.count-dl) {
var group = List.filled(dl+1, 0)
group[0] = primes[i]
var outer = false
for (j in i...i+dl) {
var cont = false
if (primes[j+1] - primes[j] != diffs[j-i]) {
outer = true
break
}
group[j-i+1] = primes[j+1]
}
if (!outer) results.add(group)
}
return results
}
var primes = Int.primeSieve(999999)
var diffsList = [ [2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2] ]
System.print("For primes less than 1,000,000:-\n")
for (diffs in diffsList) {
System.print(" For differences of %(diffs) ->")
var sp = successivePrimes.call(primes, diffs)
var cont = false
if (sp.count == 0) {
System.print(" No groups found")
cont = true
}
if (!cont) {
System.print(" First group = %(sp[0])")
System.print(" Last group = %(sp[-1])")
System.print(" Number found = %(sp.count)\n")
}
}</syntaxhighlight>
{{out}}
<pre>
For primes less than 1,000,000:-
For differences of [2] ->
First group = [3, 5]
Last group = [999959, 999961]
Number found = 8169
For differences of [1] ->
First group = [2, 3]
Last group = [2, 3]
Number found = 1
For differences of [2, 2] ->
First group = [3, 5, 7]
Last group = [3, 5, 7]
Number found = 1
For differences of [2, 4] ->
First group = [5, 7, 11]
Last group = [999431, 999433, 999437]
Number found = 1393
For differences of [4, 2] ->
First group = [7, 11, 13]
Last group = [997807, 997811, 997813]
Number found = 1444
For differences of [6, 4, 2] ->
First group = [31, 37, 41, 43]
Last group = [997141, 997147, 997151, 997153]
Number found = 306
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N); \Return 'true' if N is prime
int N, D;
[if N < 2 then return false;
if (N&1) = 0 then return N = 2;
if rem(N/3) = 0 then return N = 3;
D:= 5;
while D*D <= N do
[if rem(N/D) = 0 then return false;
D:= D+2;
if rem(N/D) = 0 then return false;
D:= D+4;
];
return true;
];
char Prime(1_000_000), S;
int Diff, Diffs, Count, N, I, First, Last;
int Str, Len;
[for N:= 0 to 1_000_000-1 do
Prime(N):= if IsPrime(N) then ^1 else ^0;
Diffs:= [[2, 0, 0], [1, 0, 0], [2, 2+2, 0], [2, 4+2, 0], [4, 2+4, 0], [6, 4+6, 2+4+6]];
Str:= [ "101 ", "11 ", "10101 ", "1010001 ", "1000101 ", "1000001000101 "];
Len:= [ 3, 2, 5, 7, 7, 13];
for Diff:= 0 to 6-1 do
[Count:= 0;
for N:= 0 to 1_000_000-1 -13 do
[S:= Str(Diff);
for I:= 0 to Len(Diff)-1 do
if S(I) # Prime(N+I) then I:= 100;
if I < 100 then \have match
[Count:= Count+1;
if Count = 1 then First:= N;
Last:= N;
];
];
Text(0, "First: "); IntOut(0, First);
for I:= 0 to 2 do
if Diffs(Diff,I) # 0 then
[ChOut(0, ^ ); IntOut(0, First+Diffs(Diff,I))];
Text(0, " Last: "); IntOut(0, Last);
for I:= 0 to 2 do
if Diffs(Diff,I) # 0 then
[ChOut(0, ^ ); IntOut(0, Last+Diffs(Diff,I))];
Text(0, " Groups: "); IntOut(0, Count); CrLf(0);
];
]</syntaxhighlight>
{{out}}
<pre>
First: 3 5 Last: 999959 999961 Groups: 8169
First: 2 3 Last: 2 3 Groups: 1
First: 3 5 7 Last: 3 5 7 Groups: 1
First: 5 7 11 Last: 999431 999433 999437 Groups: 1393
First: 7 11 13 Last: 997807 997811 997813 Groups: 1444
First: 31 37 41 43 Last: 997141 997147 997151 997153 Groups: 306
</pre>
Line 1,394 ⟶ 3,142:
Treat this as a string search problem.
<
var [const] BI=Import("zklBigNum"); // libGMP
var [const] primeBitMap=Data(PRIME_LIMIT).fill(0x30); // one big string
Line 1,407 ⟶ 3,155:
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):"
Line 1,414 ⟶ 3,162:
println(" First group: %s; Last group: %s\n"
.fmt(r[0].concat(", "),r[-1].concat(", ")));
}</
{{out}}
<pre>
|