aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Initial data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 72d218235f
commit f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Task/Successive-prime-differences/00-META.yaml Normal file
View file

@ -0,0 +1,3 @@
---
from: http://rosettacode.org/wiki/Successive_prime_differences
note: Prime Numbers

31
Task/Successive-prime-differences/00-TASK.txt Normal file
View file

@ -0,0 +1,31 @@
The series of increasing prime numbers begins: <code>2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...</code>
The task applies a filter to the series returning groups of ''successive'' primes, (s'primes), that differ from the next by a given value or values.
'''Example 1:''' Specifying that the difference between s'primes be <code>2</code> leads to the groups:
:<code>(3, 5), (5, 7), (11, 13), (17, 19), (29, 31), ...</code> <br>
(Known as [[wp:Twin prime|Twin primes]] or [https://oeis.org/A077800 Prime pairs])
'''Example 2:''' Specifying more than one difference ''between'' s'primes leads to groups of size one greater than the number of differences. Differences of <code>2, 4</code> leads to the groups:
:<code>(5, 7, 11), (11, 13, 17), (17, 19, 23), (41, 43, 47), ...</code>. <br>
In the first group 7 is two more than 5 and 11 is four more than 7; as well as 5, 7, and 11 being ''successive'' primes.
Differences are checked in the order of the values given, (differences of <code>4, 2</code> would give different groups entirely).
;Task:
* In each case use a list of primes less than 1_000_000
* For the following Differences show the first and last group, as well as the number of groups found:
:# Differences of <code>2</code>.
:# Differences of <code>1</code>.
:# Differences of <code>2, 2</code>.
:# Differences of <code>2, 4</code>.
:# Differences of <code>4, 2</code>.
:# Differences of <code>6, 4, 2</code>.
* Show output here.
<br>Note: Generation of a list of primes is a secondary aspect of the task. Use of a built in function, well known library, or importing/use of prime generators from other [[Sieve of Eratosthenes|Rosetta Code tasks]] is encouraged.
;references
:#https://pdfs.semanticscholar.org/78a1/7349819304863ae061df88dbcb26b4908f03.pdf
:#https://www.primepuzzles.net/puzzles/puzz_011.htm
:#https://matheplanet.de/matheplanet/nuke/html/viewtopic.php?topic=232720&start=0

34
Task/Successive-prime-differences/11l/successive-prime-differences.11l Normal file
View file

@ -0,0 +1,34 @@
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()

68
Task/Successive-prime-differences/ALGOL-68/successive-prime-differences.alg Normal file
View file

@ -0,0 +1,68 @@
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

44
Task/Successive-prime-differences/AWK/successive-prime-differences.awk Normal file
View file

@ -0,0 +1,44 @@
# syntax: GAWK -f SUCCESSIVE_PRIME_DIFFERENCES.AWK
BEGIN {
for (i=lo=0; i<=hi=1000000; i++) {
if (is_prime(i)) {
p_arr[++p] = i
}
}
printf("there are %d primes between %d - %d\n",p,lo,hi)
fmt = "%-11s %5s %-15s %s\n"
printf(fmt,"differences","count","first group","last group")
for (a=1; a<=split("2;1;2,2;2,4;4,2;6,4,2;2,4,6;100;112",diff_arr,";"); a++) {
diff_leng = split(diff_arr[a],tmp_arr,",")
first_set = last_set = ""
count = 0
for (b=1; b<=p; b++) {
str = ""
for (c=1; c<=diff_leng; c++) {
if (p_arr[b+c-1] + tmp_arr[c] == p_arr[b+c]) {
str = (str == "") ? (p_arr[b+c-1] "," p_arr[b+c]) : (str "," p_arr[b+c])
}
}
if (gsub(/,/,"&",str) == diff_leng) {
count++
if (first_set == "") {
first_set = str
}
last_set = str
}
}
printf(fmt,diff_arr[a],count,first_set,last_set)
}
exit(0)
}
function is_prime(x, i) {
if (x <= 1) {
return(0)
}
for (i=2; i<=int(sqrt(x)); i++) {
if (x % i == 0) {
return(0)
}
}
return(1)
}

30
Task/Successive-prime-differences/Arturo/successive-prime-differences.arturo Normal file
View file

@ -0,0 +1,30 @@
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]
]

79
Task/Successive-prime-differences/C++/successive-prime-differences-1.cpp Normal file
View file

@ -0,0 +1,79 @@
#include <iostream>
#include <cstdint>
#include <vector>
#include "prime_sieve.hpp"
using integer = uint32_t;
using vector = std::vector<integer>;
void print_vector(const vector& vec) {
if (!vec.empty()) {
auto i = vec.begin();
std::cout << '(' << *i;
for (++i; i != vec.end(); ++i)
std::cout << ", " << *i;
std::cout << ')';
}
}
class diffs {
public:
diffs(std::initializer_list<integer> list) : diffs_(list) {}
diffs(const vector& vec) : diffs_(vec) {}
void test_group(const vector&);
size_t size() const {
return diffs_.size();
}
void print(std::ostream&);
private:
vector diffs_;
vector first_;
vector last_;
integer count_ = 0;
};
void diffs::test_group(const vector& vec) {
if (vec.size() < size() + 1)
return;
size_t start = vec.size() - size() - 1;
for (size_t i = 0, j = start + 1; i < size(); ++i, ++j) {
if (vec[j] - vec[j - 1] != diffs_[i])
return;
}
vector group(vec.begin() + start, vec.end());
if (count_ == 0)
first_ = group;
last_ = group;
++count_;
}
void diffs::print(std::ostream& out) {
print_vector(diffs_);
out << ": first group = ";
print_vector(first_);
out << ", last group = ";
print_vector(last_);
out << ", count = " << count_ << '\n';
}
int main() {
const integer limit = 1000000;
const size_t max_group_size = 4;
prime_sieve sieve(limit);
diffs d[] = { {2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2} };
vector group;
for (integer p = 0; p < limit; ++p) {
if (!sieve.is_prime(p))
continue;
if (group.size() >= max_group_size)
group.erase(group.begin());
group.push_back(p);
for (auto&& diff : d) {
diff.test_group(group);
}
}
for (auto&& diff : d) {
diff.print(std::cout);
}
return 0;
}

52
Task/Successive-prime-differences/C++/successive-prime-differences-2.cpp Normal file
View file

@ -0,0 +1,52 @@
#ifndef PRIME_SIEVE_HPP
#define PRIME_SIEVE_HPP
#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 prime_sieve(size_t);
bool is_prime(size_t) const;
private:
std::vector<bool> is_prime_;
};
/**
* Constructs a sieve with the given limit.
*
* @param limit the maximum integer that can be tested for primality
*/
inline prime_sieve::prime_sieve(size_t limit) {
limit = std::max(size_t(3), limit);
is_prime_.resize(limit/2, true);
for (size_t p = 3; p * p <= limit; p += 2) {
if (is_prime_[p/2 - 1]) {
size_t inc = 2 * p;
for (size_t q = p * p; q <= limit; q += inc)
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

49
Task/Successive-prime-differences/C-sharp/successive-prime-differences.cs Normal file
View file

@ -0,0 +1,49 @@
using System;
using System.Collections.Generic;
using static System.Linq.Enumerable;
public static class SuccessivePrimeDifferences {
public static void Main() {
var primes = GeneratePrimes(1_000_000).ToList();
foreach (var d in new[] {
new [] { 2 },
new [] { 1 },
new [] { 2, 2 },
new [] { 2, 4 },
new [] { 4, 2 },
new [] { 6, 4, 2 },
}) {
IEnumerable<int> first = null, last = null;
int count = 0;
foreach (var grp in FindDifferenceGroups(d)) {
if (first == null) first = grp;
last = grp;
count++;
}
Console.WriteLine($"{$"({string.Join(", ", first)})"}, {$"({string.Join(", ", last)})"}, {count}");
}
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;
}
}
}

170
Task/Successive-prime-differences/C/successive-prime-differences.c Normal file
View file

@ -0,0 +1,170 @@
#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;
}

109
Task/Successive-prime-differences/D/successive-prime-differences.d Normal file
View file

@ -0,0 +1,109 @@
import std.algorithm;
import std.array;
import std.range;
import std.stdio;
immutable PRIMES = [
2, 3, 5, 7,
11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523,
541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769,
773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997,
1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217,
1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663,
1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907,
1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141,
2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383,
2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659,
2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861,
2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163,
3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391,
3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637,
3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907,
3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153,
4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423,
4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679,
4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967,
4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231,
5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501,
5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749,
5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043,
6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299,
6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571,
6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841,
6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121,
7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451,
7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681,
7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951,
7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263,
8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563,
8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819,
8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103,
9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377,
9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643,
9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907,
9923, 9929, 9931, 9941, 9949, 9967, 9973,
];
bool isPrime(int n) {
if (n < 2) {
return false;
}
foreach (prime; PRIMES) {
if (n == prime) {
return true;
}
if (n % prime == 0) {
return false;
}
if (n < prime * prime) {
if (n > PRIMES[$-1] * PRIMES[$-1]) {
assert(false, "Out of pre-computed primes.");
}
break;
}
}
return true;
}
int[][] successivePrimes(int[] primes, int[] diffs) {
int[][] results;
auto dl = diffs.length;
outer:
for (int i = 0; i < primes.length - dl; i++) {
auto group = uninitializedArray!(int[])(dl + 1);
group[0] = primes[i];
for (int j = i; j < i + dl; j++) {
if (primes[j + 1] - primes[j] != diffs[j - i]) {
continue outer;
}
group[j - i + 1] = primes[j + 1];
}
results ~= group;
}
return results;
}
void main() {
auto primeList = iota(2, 1_000_000).filter!isPrime.array;
auto diffsList = [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]];
writeln("For primes less than 1,000,000:-");
foreach (diffs; diffsList) {
writefln(" For differences of %s ->", diffs);
auto sp = successivePrimes(primeList, diffs);
if (sp.length == 0) {
writeln(" No groups found");
continue;
}
writeln(" First group = ", sp[0]);
writeln(" Last group = ", sp[$ - 1]);
writeln(" Number found = ", sp.length);
writeln();
}
}

147
Task/Successive-prime-differences/Delphi/successive-prime-differences.delphi Normal file
View file

@ -0,0 +1,147 @@
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.

4
Task/Successive-prime-differences/F-Sharp/successive-prime-differences.fs Normal file
View file

@ -0,0 +1,4 @@
// 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|]]

27
Task/Successive-prime-differences/Factor/successive-prime-differences.factor Normal file
View file

@ -0,0 +1,27 @@
USING: formatting fry grouping kernel math math.primes
math.statistics sequences ;
IN: rosetta-code.successive-prime-differences
: seq-diff ( seq diffs -- seq' quot )
dup [ length 1 + <clumps> ] dip '[ differences _ sequence= ]
; inline
: show ( seq diffs -- )
[ "...for differences %u:\n" printf ] keep seq-diff
[ find nip { } like ]
[ find-last nip { } like ]
[ count ] 2tri
"First group: %u\nLast group: %u\nCount: %d\n\n" printf ;
: successive-prime-differences ( -- )
"Groups of successive primes up to one million...\n" printf
1,000,000 primes-upto {
{ 2 }
{ 1 }
{ 2 2 }
{ 2 4 }
{ 4 2 }
{ 6 4 2 }
} [ show ] with each ;
MAIN: successive-prime-differences

89
Task/Successive-prime-differences/FreeBASIC/successive-prime-differences.basic Normal file
View file

@ -0,0 +1,89 @@
#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

69
Task/Successive-prime-differences/Go/successive-prime-differences.go Normal file
View file

@ -0,0 +1,69 @@
package main
import "fmt"
func sieve(limit int) []int {
primes := []int{2}
c := make([]bool, limit+1) // composite = true
// no need to process even numbers > 2
p := 3
for {
p2 := p * p
if p2 > limit {
break
}
for i := p2; i <= limit; i += 2 * p {
c[i] = true
}
for {
p += 2
if !c[p] {
break
}
}
}
for i := 3; i <= limit; i += 2 {
if !c[i] {
primes = append(primes, i)
}
}
return primes
}
func successivePrimes(primes, diffs []int) [][]int {
var results [][]int
dl := len(diffs)
outer:
for i := 0; i < len(primes)-dl; i++ {
group := make([]int, dl+1)
group[0] = primes[i]
for j := i; j < i+dl; j++ {
if primes[j+1]-primes[j] != diffs[j-i] {
group = nil
continue outer
}
group[j-i+1] = primes[j+1]
}
results = append(results, group)
group = nil
}
return results
}
func main() {
primes := sieve(999999)
diffsList := [][]int{{2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2}}
fmt.Println("For primes less than 1,000,000:-\n")
for _, diffs := range diffsList {
fmt.Println(" For differences of", diffs, "->")
sp := successivePrimes(primes, diffs)
if len(sp) == 0 {
fmt.Println(" No groups found")
continue
}
fmt.Println(" First group = ", sp[0])
fmt.Println(" Last group = ", sp[len(sp)-1])
fmt.Println(" Number found = ", len(sp))
fmt.Println()
}
}

32
Task/Successive-prime-differences/Haskell/successive-prime-differences-1.hs Normal file
View file

@ -0,0 +1,32 @@
{-# LANGUAGE NumericUnderscores #-}
import Data.Numbers.Primes (primes)
type Result = [(String, [Int])]
oneMillionPrimes :: Integral p => [p]
oneMillionPrimes = takeWhile (<1_000_000) primes
getGroups :: [Int] -> Result
getGroups [] = []
getGroups ps@(n:x:y:z:xs)
| x-n == 6 && y-x == 4 && z-y == 2 = ("(6 4 2)", [n, x, y, z]) : getGroups (tail ps)
| x-n == 4 && y-x == 2 = ("(4 2)", [n, x, y]) : getGroups (tail ps)
| x-n == 2 && y-x == 4 = ("(2 4)", [n, x, y]) : ("2", [n, x]) : getGroups (tail ps)
| x-n == 2 && y-x == 2 = ("(2 2)", [n, x, y]) : ("2", [n, x]) : getGroups (tail ps)
| x-n == 2 = ("2", [n, x]) : getGroups (tail ps)
| x-n == 1 = ("1", [n, x]) : getGroups (tail ps)
| otherwise = getGroups (tail ps)
getGroups (x:xs) = getGroups xs
groups :: Result
groups = getGroups oneMillionPrimes
showGroup :: String -> IO ()
showGroup group = do
putStrLn $ "Differences of " ++ group ++ ": " ++ show (length r)
putStrLn $ "First: " ++ show (head r) ++ "\nLast: " ++ show (last r) ++ "\n"
where r = foldr (\(a, b) c -> if a == group then b : c else c) [] groups
main :: IO ()
main = showGroup "2" >> showGroup "1" >> showGroup "(2 2)" >> showGroup "(2 4)" >> showGroup "(4 2)"
>> showGroup "(6 4 2)"

35
Task/Successive-prime-differences/Haskell/successive-prime-differences-2.hs Normal file
View file

@ -0,0 +1,35 @@
{-# LANGUAGE NumericUnderscores #-}
import Data.Numbers.Primes (primes)
-- Type alias dictionary. Key is the difference group and value is a successive prime group.
type Result = [(String, [Int])]
findPrimes :: [Int] -> [[Int]] -> Result
findPrimes [] _ = []
findPrimes primes diffs = loopDiffs diffs <> findPrimes (tail primes) diffs
where
loopDiffs ds = [(show d, successive)
| d <- ds,
let successive = take (length d + 1) primes,
subs successive == d]
subs = map (uncurry (-)) . init . tail . (\xs -> zip (xs <> [0]) (0 : xs))
showGroup :: Result -> String -> IO ()
showGroup result diffs = do
putStrLn $ "Differences of " ++ diffs ++ ": " ++ show (length groups)
putStrLn
$ "First: "
++ firstGroup groups
++ "\nLast: "
++ lastGroup groups
++ "\n"
where
groups = [b | (a, b) <- result, a == diffs]
firstGroup = show . head
lastGroup = show . last
main :: IO ()
main = mapM_ (showGroup result . show) diffs
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)

38
Task/Successive-prime-differences/J/successive-prime-differences.j Normal file
View file

@ -0,0 +1,38 @@
primes_less_than=: i.&.:(p:inv)
assert 2 3 5 -: primes_less_than 7
Primes=: primes_less_than 1e6
NB. Insert minus `-/' into the length two infixes `\'.
NB. Passive `~' swaps the arguments producing the positive differences.
Successive_Differences=: 2 -~/\ Primes
assert 8169 -: +/ 2 = Successive_Differences NB. twin prime tally
Groups=: 2 ; 1 ; 2 2 ; 2 4 ; 4 2 ; 6 4 2
group_index=: [: I. E.
end_groups=: Primes {~ ({. , {:)@] +/ 0,#\@[
Header=: <;._2 'Group;Count;First/Last groups;'
Header ,> Groups ([ ([ ; #@] ; end_groups) group_index)&.> <Successive_Differences
┌─────┬─────┬───────────────────────────┐
│Group│Count│First/Last groups │
├─────┼─────┼───────────────────────────┤
│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│
└─────┴─────┴───────────────────────────┘

68
Task/Successive-prime-differences/Java/successive-prime-differences.java Normal file
View file

@ -0,0 +1,68 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class SuccessivePrimeDifferences {
private static Integer[] sieve(int limit) {
List<Integer> primes = new ArrayList<>();
primes.add(2);
boolean[] c = new boolean[limit + 1];// composite = true
// no need to process even numbers > 2
int p = 3;
while (true) {
int p2 = p * p;
if (p2 > limit) {
break;
}
for (int i = p2; i <= limit; i += 2 * p) {
c[i] = true;
}
do {
p += 2;
} while (c[p]);
}
for (int i = 3; i <= limit; i += 2) {
if (!c[i]) {
primes.add(i);
}
}
return primes.toArray(new Integer[0]);
}
private static List<List<Integer>> successivePrimes(Integer[] primes, Integer[] diffs) {
List<List<Integer>> results = new ArrayList<>();
int dl = diffs.length;
outer:
for (int i = 0; i < primes.length - dl; i++) {
Integer[] group = new Integer[dl + 1];
group[0] = primes[i];
for (int j = i; j < i + dl; ++j) {
if (primes[j + 1] - primes[j] != diffs[j - i]) {
continue outer;
}
group[j - i + 1] = primes[j + 1];
}
results.add(Arrays.asList(group));
}
return results;
}
public static void main(String[] args) {
Integer[] primes = sieve(999999);
Integer[][] diffsList = {{2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2}};
System.out.println("For primes less than 1,000,000:-\n");
for (Integer[] diffs : diffsList) {
System.out.printf(" For differences of %s ->\n", Arrays.toString(diffs));
List<List<Integer>> sp = successivePrimes(primes, diffs);
if (sp.isEmpty()) {
System.out.println(" No groups found");
continue;
}
System.out.printf(" First group = %s\n", Arrays.toString(sp.get(0).toArray(new Integer[0])));
System.out.printf(" Last group = %s\n", Arrays.toString(sp.get(sp.size() - 1).toArray(new Integer[0])));
System.out.printf(" Number found = %d\n", sp.size());
System.out.println();
}
}
}

37
Task/Successive-prime-differences/Jq/successive-prime-differences-1.jq Normal file
View file

@ -0,0 +1,37 @@
# 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 ) ;

3
Task/Successive-prime-differences/Jq/successive-prime-differences-2.jq Normal file
View file

@ -0,0 +1,3 @@
[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 ) ) )

23
Task/Successive-prime-differences/Julia/successive-prime-differences.julia Normal file
View file

@ -0,0 +1,23 @@
using Primes
function filterdifferences(deltas, N)
allprimes = primes(N)
differences = map(i -> allprimes[i + 1] - allprimes[i], 1:length(allprimes) - 1)
println("Diff Sequence Count First Last")
for delt in deltas
ret = trues(length(allprimes) - length(delt))
for j in 1:length(ret)
for (i, d) in enumerate(delt)
if differences[j - 1 + i] != d
ret[j] = false
break
end
end
end
count, p1, pn, n = sum(ret), findfirst(ret), findlast(ret), length(delt)
println(rpad(string(delt), 16), lpad(count, 4),
lpad(string(allprimes[p1:p1 + n]), 18), "...", rpad(allprimes[pn:pn+n], 15))
end
end
filterdifferences([[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]], 1000000)

71
Task/Successive-prime-differences/Kotlin/successive-prime-differences.kotlin Normal file
View file

@ -0,0 +1,71 @@
private fun sieve(limit: Int): Array<Int> {
val primes = mutableListOf<Int>()
primes.add(2)
val c = BooleanArray(limit + 1) // composite = true
// no need to process even numbers > 2
var p = 3
while (true) {
val p2 = p * p
if (p2 > limit) {
break
}
var i = p2
while (i <= limit) {
c[i] = true
i += 2 * p
}
do {
p += 2
} while (c[p])
}
var i = 3
while (i <= limit) {
if (!c[i]) {
primes.add(i)
}
i += 2
}
return primes.toTypedArray()
}
private fun successivePrimes(primes: Array<Int>, diffs: Array<Int>): List<List<Int>> {
val results = mutableListOf<List<Int>>()
val dl = diffs.size
outer@ for (i in 0 until primes.size - dl) {
val group = IntArray(dl + 1)
group[0] = primes[i]
for (j in i until i + dl) {
if (primes[j + 1] - primes[j] != diffs[j - i]) {
continue@outer
}
group[j - i + 1] = primes[j + 1]
}
results.add(group.toList())
}
return results
}
fun main() {
val primes = sieve(999999)
val diffsList = arrayOf(
arrayOf(2),
arrayOf(1),
arrayOf(2, 2),
arrayOf(2, 4),
arrayOf(4, 2),
arrayOf(6, 4, 2)
)
println("For primes less than 1,000,000:-\n")
for (diffs in diffsList) {
println(" For differences of ${diffs.contentToString()} ->")
val sp = successivePrimes(primes, diffs)
if (sp.isEmpty()) {
println(" No groups found")
continue
}
println(" First group = ${sp[0].toTypedArray().contentToString()}")
println(" Last group = ${sp[sp.size - 1].toTypedArray().contentToString()}")
println(" Number found = ${sp.size}")
println()
}
}

26
Task/Successive-prime-differences/Lua/successive-prime-differences.lua Normal file
View file

@ -0,0 +1,26 @@
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

9
Task/Successive-prime-differences/Mathematica/successive-prime-differences.math Normal file
View file

@ -0,0 +1,9 @@
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}]

50
Task/Successive-prime-differences/Nim/successive-prime-differences.nim Normal file
View file

@ -0,0 +1,50 @@
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)

22
Task/Successive-prime-differences/Perl/successive-prime-differences.pl Normal file
View file

@ -0,0 +1,22 @@
use strict;
use warnings;
use List::EachCons;
use Array::Compare;
use ntheory 'primes';
my $limit = 1E6;
my @primes = (2, @{ primes($limit) });
my @intervals = map { $primes[$_] - $primes[$_-1] } 1..$#primes;
print "Groups of successive primes <= $limit\n";
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(\@_, \@$diffs) };
printf "%10s has %5d sets: %15s … %s\n",
'(' . join(' ',@$diffs) . ')',
scalar @offsets,
join(' ', @primes[$offsets[ 0]..($offsets[ 0]+@$diffs)]),
join(' ', @primes[$offsets[-1]..($offsets[-1]+@$diffs)]);
}

26
Task/Successive-prime-differences/Phix/successive-prime-differences.phix Normal file
View file

@ -0,0 +1,26 @@
(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>
<!--

36
Task/Successive-prime-differences/Picat/successive-prime-differences.picat Normal file
View file

@ -0,0 +1,36 @@
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).

51
Task/Successive-prime-differences/Prolog/successive-prime-differences.pro Normal file
View file

@ -0,0 +1,51 @@
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).

35
Task/Successive-prime-differences/Python/successive-prime-differences.py Normal file
View file

@ -0,0 +1,35 @@
# https://docs.sympy.org/latest/index.html
from sympy import Sieve
def nsuccprimes(count, mx):
"return tuple of <count> successive primes <= mx (generator)"
sieve = Sieve()
sieve.extend(mx)
primes = sieve._list
return zip(*(primes[n:] for n in range(count)))
def check_value_diffs(diffs, values):
"Differences between successive values given by successive items in diffs?"
return all(v[1] - v[0] == d
for d, v in zip(diffs, zip(values, values[1:])))
def successive_primes(offsets=(2, ), primes_max=1_000_000):
return (sp for sp in nsuccprimes(len(offsets) + 1, primes_max)
if check_value_diffs(offsets, sp))
if __name__ == '__main__':
for offsets, mx in [((2,), 1_000_000),
((1,), 1_000_000),
((2, 2), 1_000_000),
((2, 4), 1_000_000),
((4, 2), 1_000_000),
((6, 4, 2), 1_000_000),
]:
print(f"## SETS OF {len(offsets)+1} SUCCESSIVE PRIMES <={mx:_} WITH "
f"SUCCESSIVE DIFFERENCES OF {str(list(offsets))[1:-1]}")
for count, last in enumerate(successive_primes(offsets, mx), 1):
if count == 1:
first = last
print(" First group:", str(first)[1:-1])
print(" Last group:", str(last)[1:-1])
print(" Count:", count)

45
Task/Successive-prime-differences/REXX/successive-prime-differences.rexx Normal file
View file

@ -0,0 +1,45 @@
/*REXX program finds and displays primes with successive differences (up to a limit).*/
parse arg H . 1 . difs /*allow the highest number be specified*/
if H=='' | H=="," then H= 1000000 /*Not specified? Then use the default.*/
if difs='' then difs= 2 1 2.2 2.4 4.2 6.4.2 /* " " " " " " */
call genP H
do j=1 for words(difs) /*traipse through the lists.*/
dif= translate( word(difs, j),,.); dw= words(dif) /*obtain true differences. */
do i=1 for dw; dif.i= word(dif, i) /*build an array of diffs. */
end /*i*/ /* [↑] for optimization. */
say center('primes with differences of:' dif, 50, '─') /*display title.*/
p= 1; c= 0; grp= /*init. prime#, count, grp.*/
do a=1; p= nextP(p+1); if p==0 then leave /*find the next DIF primes*/
aa= p; !.= /*AA: nextP; the group #'s.*/
!.1= p /*assign 1st prime in group.*/
do g=2 for dw /*get the rest of the group.*/
aa= nextP(aa+1); if aa==0 then leave a /*obtain the next prime. */
!.g= aa; _= g-1 /*prepare to add difference.*/
if !._ + dif._\==!.g then iterate a /*determine if fits criteria*/
end /*g*/
c= c+1 /*bump count of # of groups.*/
grp= !.1; do b=2 for dw; grp= grp !.b /*build a list of primes. */
end /*b*/
if c==1 then say ' first group: ' grp /*display the first group. */
end /*a*/
/* [↓] test if group found.*/
if grp=='' then say " (none)" /*display the last group. */
else say ' last group: ' grp /* " " " " */
say ' count: ' c /* " " group count. */
say
end /*j*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
nextP: do nxt=arg(1) to H; if @.nxt==. then return nxt; end /*nxt*/; return 0
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: procedure expose @.; parse arg N; != 0; @.=.; @.1= /*initialize the array.*/
do e=4 by 2 for (N-1)%2; @.e=; end /*treat the even integers > 2 special.*/
/*all primes are indicated with a "." */
do j=1 by 2 for (N-1)%2 /*use odd integers up to N inclusive.*/
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.*/
end /* [↑] strike odd multiples ¬ prime. */
end /*j*/; return

31
Task/Successive-prime-differences/Raku/successive-prime-differences-1.raku Normal file
View file

@ -0,0 +1,31 @@
use Math::Primesieve;
my $sieve = Math::Primesieve.new;
my $max = 1_000_000;
my @primes = $sieve.primes($max);
my $filter = @primes.Set;
my $primes = @primes.categorize: &successive;
sub successive ($i) {
gather {
take '2' if $filter{$i + 2};
take '1' if $filter{$i + 1};
take '2_2' if all($filter{$i «+« (2,4)});
take '2_4' if all($filter{$i «+« (2,6)});
take '4_2' if all($filter{$i «+« (4,6)});
take '6_4_2' if all($filter{$i «+« (6,10,12)}) and
none($filter{$i «+« (2,4,8)});
}
}
sub comma { $^i.flip.comb(3).join(',').flip }
for (2,), (1,), (2,2), (2,4), (4,2), (6,4,2) -> $succ {
say "## Sets of {1+$succ} successive primes <= { comma $max } with " ~
"successive differences of { $succ.join: ', ' }";
my $i = $succ.join: '_';
for 'First', 0, ' Last', * - 1 -> $where, $ind {
say "$where group: ", join ', ', [\+] flat $primes{$i}[$ind], |$succ
}
say ' Count: ', +$primes{$i}, "\n";
}

19
Task/Successive-prime-differences/Raku/successive-prime-differences-2.raku Normal file
View file

@ -0,0 +1,19 @@
use Math::Primesieve;
constant $max = 1_000_000;
constant @primes = Math::Primesieve.primes($max);
constant @diffs = @primes.skip Z- @primes;
say "Given all ordered primes <= $max, sets with successive differences of:";
for (2,), (1,), (2,2), (2,4), (4,2), (6,4,2) -> @succ {
my $size = @succ.elems;
my @group_start_offsets = @diffs.rotor( $size => 1-$size )
.grep(:k, { $_ eqv @succ });
my ($first, $last) = @group_start_offsets[0, *-1]
.map: { @primes.skip($_).head($size + 1) };
say sprintf '%10s has %5d sets: %15s … %s',
@succ.gist, @group_start_offsets.elems, $first, $last;
}

67
Task/Successive-prime-differences/Ring/successive-prime-differences.ring Normal file
View file

@ -0,0 +1,67 @@
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

10
Task/Successive-prime-differences/Ruby/successive-prime-differences.rb Normal file
View file

@ -0,0 +1,10 @@
require 'prime'
PRIMES = Prime.each(1_000_000).to_a
difs = [[2], [1], [2,2], [2,4], [4,2], [6,4,2]]
difs.each do |ar|
res = PRIMES.each_cons(ar.size+1).select do |slice|
slice.each_cons(2).zip(ar).all? {|(a,b), c| a+c == b}
end
puts "#{ar} has #{res.size} sets. #{res.first}...#{res.last}"
end

47
Task/Successive-prime-differences/Rust/successive-prime-differences.rust Normal file
View file

@ -0,0 +1,47 @@
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())
}
}
}

30
Task/Successive-prime-differences/Scala/successive-prime-differences.scala Normal file
View file

@ -0,0 +1,30 @@
object SuccessivePrimeDiffs {
def main(args: Array[String]): Unit = {
val d2 = primesByDiffs(2)(1000000)
val d1 = primesByDiffs(1)(1000000)
val d22 = primesByDiffs(2, 2)(1000000)
val d24 = primesByDiffs(2, 4)(1000000)
val d42 = primesByDiffs(4, 2)(1000000)
val d642 = primesByDiffs(6, 4, 2)(1000000)
if(true) println(
s"""|Diffs: (First), (Last), Count
|2: (${d2.head.mkString(", ")}), (${d2.last.mkString(", ")}), ${d2.size}
|1: (${d1.head.mkString(", ")}), (${d1.last.mkString(", ")}), ${d1.size}
|2-2: (${d22.head.mkString(", ")}), (${d22.last.mkString(", ")}), ${d22.size}
|2-4: (${d24.head.mkString(", ")}), (${d24.last.mkString(", ")}), ${d24.size}
|4-2: (${d42.head.mkString(", ")}), (${d42.last.mkString(", ")}), ${d42.size}
|6-4-2: (${d642.head.mkString(", ")}), (${d642.last.mkString(", ")}), ${d642.size}
|""".stripMargin)
}
def primesByDiffs(diffs: Int*)(max: Int): LazyList[Vector[Int]] = {
primesSliding(diffs.size + 1)
.takeWhile(_.last <= max)
.filter{vec => diffs.zip(vec.init).map{case (a, b) => a + b} == vec.tail}
.to(LazyList)
}
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))
}

17
Task/Successive-prime-differences/Sidef/successive-prime-differences.sidef Normal file
View file

@ -0,0 +1,17 @@
var limit = 1e6
var primes = limit.primes
say "Groups of successive primes <= #{limit.commify}:"
for diffs in [[2], [1], [2,2], [2,4], [4,2], [6,4,2]] {
var groups = []
primes.each_cons(diffs.len+1, {|*group|
if (group.map_cons(2, {|a,b| b-a}) == diffs) {
groups << group
}
})
say ("...for differences #{diffs}, there are #{groups.len} groups, where ",
"the first group = #{groups.first} and the last group = #{groups.last}")
}

90
Task/Successive-prime-differences/Visual-Basic-.NET/successive-prime-differences.vb Normal file
View file

@ -0,0 +1,90 @@
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

39
Task/Successive-prime-differences/Wren/successive-prime-differences.wren Normal file
View file

@ -0,0 +1,39 @@
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")
}
}

46
Task/Successive-prime-differences/XPL0/successive-prime-differences.xpl0 Normal file
View file

@ -0,0 +1,46 @@
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);
];
]

14
Task/Successive-prime-differences/Zkl/successive-prime-differences-1.zkl Normal file
View file

@ -0,0 +1,14 @@
const PRIME_LIMIT=1_000_000;
var [const] BI=Import("zklBigNum"); // libGMP
var [const] primeBitMap=Data(PRIME_LIMIT).fill(0x30); // one big string
p:= BI(1);
while(p.nextPrime()<=PRIME_LIMIT){ primeBitMap[p]="1" } // bitmap of primes
fcn primeWindows(m,deltas){ // eg (6,4,2)
n,r := 0,List();
ds:=deltas.len().pump(List,'wrap(n){ deltas[0,n+1].sum(0) }); // (6,10,12)
sp:=Data(Void,"1" + "0"*deltas.sum(0));
foreach n in (ds){ sp[n]="1" } // "1000001000101"
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) ...)
}

7
Task/Successive-prime-differences/Zkl/successive-prime-differences-2.zkl Normal file
View file

@ -0,0 +1,7 @@
foreach w in (T( T(2), T(1), T(2,2), T(2,4), T(4,2), T(6,4,2) )){
r:=primeWindows(PRIME_LIMIT,w);
println("Successive primes (<=%,d) with deltas of %s (%,d groups):"
.fmt(PRIME_LIMIT,w.concat(","),r.len()));
println(" First group: %s; Last group: %s\n"
.fmt(r[0].concat(", "),r[-1].concat(", ")));
}