Rosetta Code

CalmoSoft primes: Difference between revisions

Page Discussion

CalmoSoft primes (view source)

Revision as of 11:34, 12 November 2023

18,586 bytes added ,  6 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(Algol 68 stretch - notes)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(18 intermediate revisions by 11 users not shown)
Line 26:
ELSE
BOOL is a prime := TRUE;
FOR f FROM 5 BY 2 WHILE f * f <= n AND ( is a prime := n MOD f /= 0 )DO
DO SKIP OD; is a prime := n MOD f /= 0
OD;
is a prime
FI # is prime # ;
Line 37 ⟶ 38:
INT max len := -1;
INT max sum := -1;
FOR this start FROM LWB prime TO UPB prime - 1 DO
WHILE
INT this end := UPB prime;
INT this len := ( this end + 1 ) - this start;
Line 58 ⟶ 60:
FI
FI;
( UPB prime - this start ) > max len
DO
# the start prime won't be in the next sequence #
seq sum -:= prime[ this start ]
Line 81 ⟶ 85:
Uses Algol 68G's LONG LONG INT for the Millar Rabin test.
To run this with Algol 68G, you need <code>-heap 512M</code> on the command line.
<br>Note the souircesource of the <code>is probably prime</code> routine used here is available from a page in Rosetta Code - see the following link.
{{libheader|ALGOL 68-primes}}
<syntaxhighlight lang="algol68">
Line 88 ⟶ 92:
PR read "primes.incl.a68" PR
INT max prime = 50 000 000;
# sieve, count and sum the primes to max prime and replace the sieve #
# with a list of primes #
[ 0 : max prime ]BOOL prime;
prime[ 0 ]1 := max prime[ 1 ]INT := FALSEprime;
prime[INT 2 ] :yes = 1, no = TRUE0;
prime[ 1 ] := 2; # the first prime in the list #
INT p count := 1;
prime[ 2 ] := yes; # first TRUE sieve value #
INT p count := 1;
LONG INT p sum := 2;
FOR i FROM 3 BY 2 TO UPB prime DO prime[ i ] := TRUE yes OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := FALSEno OD;
INT root max prime = ENTIER sqrt( UPB prime );
FOR i FROM 3 BY 2 TO root max prime DO
IF prime[ i ] = yes THEN
prime[ p count +:= 1 ] := i;
p sum +:= i;
FOR s FROM i * i BY i + i TO UPB prime DO prime[ s ] := FALSEno OD
FI
OD;
FOR i FROM root max prime + IF ODD root max prime THEN 2 ELSE 1 FI BY 2 TO max prime DO
IF prime[ i ] = yes THEN
prime[ p count +:= 1 ] := i;
p sum +:= i
FI
OD;
# construct a list of the primes up to max prime #
[ 1 : p count ]INT prime list;
INT p pos := 0;
FOR i WHILE p pos < UPB prime list DO
IF prime[ i ] THEN prime list[ p pos +:= 1 ] := i FI
OD;
LONG INT seq sum := p sum;
Line 122:
INT max len := -1;
LONG INT max sum := -1;
FOR this start FROM LWB prime list TO UPB primep listcount - 1
WHILE
INT this end := UPBp prime listcount;
INT this len := ( this end + 1 ) - this start;
LONG INT this sum := seq sum;
Line 130:
IF this start = 1 THEN
# the first prime is 2, the sequence must have even length #
this sum -:= prime list[ this end ];
this end -:= 1;
this len -:= 1
Line 137:
IF this start > 1 THEN
# the first prime isn't 2, the sequence must have odd length #
this sum -:= prime list[ this end ];
this end -:= 1;
this len -:= 1
Line 149:
FI
DO
this sum -:= prime list[ this end ];
this sum -:= prime list[ this end -:= 1 ];
this end -:= 1;
this len -:= 2
Line 164:
DO
# the start prime won't be in the next sequence #
seq sum -:= prime list[ this start ]
OD;
print( ( "Longest sequence of Calmosoft primes up to ", whole( prime list[ UPB primep listcount ], 0 )
, " has sum ", whole( max sum, 0 ), " and length ", whole( max len, 0 )
, newline
Line 172:
);
IF max len < 12 THEN
FOR i FROM max start TO max end DO print( ( " ", whole( prime list[ i ], 0 ) ) ) OD
ELSE
FOR i FROM max start TO max start + 6 DO print( ( " ", whole( prime list[ i ], 0 ) ) ) OD;
print( ( " ... " ) );
FOR i FROM max end - 6 TO max end DO print( ( " ", whole( prime list[ i ], 0 ) ) ) OD
FI
END
Line 185:
7 11 13 17 19 23 29 ... 49999693 49999699 49999711 49999739 49999751 49999753 49999757
</pre>
 
=={{header|AppleScript}}==
''"Tip: if it takes longer than twenty seconds, you're doing it wrong."'' It largely depends of course on the speed and busy-ness of the computer, the characteristics of the language, and which part of the process you're timing. :) On my current machine, the code below takes 70-71 seconds to perform the two tasks together, most of which time is spent just getting the primes < 50,000,000 for the stretch. The rest of the stretch only takes just under three seconds and everything else is crammed into 0.002 seconds.
<syntaxhighlight lang="applescript">-- Find the longest run of "CalmoSoft primes" ≤ limit.
on CalmoSoftPrimes(limit)
script o
property primes : sieveOfSundaram(2, limit)
end script
set maxSum to 0
repeat with p in o's primes
set maxSum to maxSum + p
end repeat
if (isPrime(maxSum)) then return {sum:maxSum, |run|:o's primes}
set {j, topRunLen} to {count o's primes, 0}
repeat while (j > topRunLen)
set testSum to maxSum
repeat with i from 1 to (j - topRunLen)
set testSum to testSum - (o's primes's item i)
if (isPrime(testSum)) then exit repeat
end repeat
set runLen to j - i
if (runLen > topRunLen) then
set topRunLen to runLen
set topRunStart to i + 1
set topRunEnd to j
set topRunSum to testSum
end if
set maxSum to maxSum - (o's primes's item j)
set j to j - 1
end repeat
return {sum:topRunSum, |run|:o's primes's items topRunStart thru topRunEnd}
end CalmoSoftPrimes
 
on sieveOfSundaram(lowerLimit, upperLimit)
if (upperLimit < lowerLimit) then set {upperLimit, lowerLimit} to {lowerLimit, upperLimit}
if (upperLimit < 2) then return {}
if (lowerLimit < 2) then set lowerLimit to 2
set k to (upperLimit - 1) div 2
set shift to lowerLimit div 2 - 1
script o
property sieve : makeList(k - shift, true)
on zapMultiples(n)
set i to (n * n) div 2
if (i ≤ shift) then set i to shift + n - (shift - i) mod n
repeat with i from (i - shift) to (k - shift) by n
set my sieve's item i to false
end repeat
end zapMultiples
end script
o's zapMultiples(3)
set addends to {2, 6, 8, 12, 14, 18, 24, 26}
repeat with n from 5 to (upperLimit ^ 0.5 div 1) by 30
o's zapMultiples(n)
repeat with a in addends
o's zapMultiples(n + a)
end repeat
end repeat
repeat with i from 1 to (k - shift)
if (o's sieve's item i) then set o's sieve's item i to (i + shift) * 2 + 1
end repeat
set o's sieve to o's sieve's numbers
if (lowerLimit is 2) then set o's sieve's beginning to 2
return o's sieve
end sieveOfSundaram
 
on makeList(limit, filler)
if (limit < 1) then return {}
script o
property lst : {filler}
end script
set counter to 1
repeat until (counter + counter > limit)
set o's lst to o's lst & o's lst
set counter to counter + counter
end repeat
if (counter < limit) then set o's lst to o's lst & o's lst's items 1 thru (limit - counter)
return o's lst
end makeList
 
on isPrime(n)
if (n < 4) then return (n > 1)
if ((n mod 2 is 0) or (n mod 3 is 0)) then return false
repeat with i from 5 to (n ^ 0.5) div 1 by 6
if ((n mod i is 0) or (n mod (i + 2) is 0)) then return false
end repeat
return true
end isPrime
 
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
 
on intToText(int, separator)
set groups to {}
repeat while (int > 999)
set groups's beginning to ((1000 + (int mod 1000 as integer)) as text)'s text 2 thru 4
set int to int div 1000
end repeat
set groups's beginning to int
return join(groups, separator)
end intToText
 
on task()
set output to {"Longest run of CalmoSoft primes < 100:"}
set {sum:sum, |run|:|run|} to CalmoSoftPrimes(99)
set end of output to join(|run|, ", ")
set end of output to "They add up to " & sum
set end of output to "Beginning & end of longest run of CalmoSoft primes < 50,000,000:"
script o
property |run| : missing value
end script
set {sum:sum, |run|:o's |run|} to CalmoSoftPrimes(49999999)
set end of output to join(o's |run|'s items 1 thru 6, ", ") & " … " & join(o's |run|'s items -6 thru -1, ", ")
set end of output to "The entire run adds up to " & intToText(sum, ",")
return join(output, linefeed)
end task
 
task()</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">"Longest run of CalmoSoft primes < 100:
7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89
They add up to 953
Beginning & end of longest run of CalmoSoft primes < 50,000,000:
7, 11, 13, 17, 19, 23 … 49999699, 49999711, 49999739, 49999751, 49999753, 49999757
The entire run adds up to 72,618,848,632,313"</syntaxhighlight>
 
=={{header|Arturo}}==
Line 261 ⟶ 402:
Sleep</syntaxhighlight>
{{out}}
<pre>[ 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 889 ]
7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 + 37 + 41 + 43 + 47 + 53 + 59 + 61 + 67 + 71 + 73 + 79 + 83 + 889 = 953 is prime number
The longest sequence of CalmoSoft primes = 21</pre>
 
Line 314 ⟶ 455:
 
=={{header|C}}==
{{libheader|GMP}}
Run time is 310 milliseconds (GCC -O1) which is slightly slower than Go.
Run time is 250 milliseconds (GCC -O1) which is slightly slower than Go.
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
Line 321 ⟶ 463:
#include <stdint.h>
#include <locale.h>
#include <gmp.h>
 
#define MAX 50000000
 
typedef uint64_t u64;
 
bool isPrime(u64 n) {
if (n < 2) return false;
if (n%2 == 0) return n == 2;
if (n%3 == 0) return n == 3;
u64 d = 5;
while (d*d <= n) {
if (n%d == 0) return false;
d += 2;
if (n%d == 0) return false;
d += 4;
}
return true;
}
 
int *primeSieve(int limit, int *length) {
Line 373 ⟶ 502:
int calmoPrimes(int limit, int *primes, int len, int *sIndices, int *eIndices, u64 *sums, int *ilen) {
int i, j, temp, pc = len, longest = 0, ic = 0;
bool isEven;
u64 sum = 0, sum2;
mpz_t bsum;
mpz_init(bsum);
if (limit < MAX) {
for (i = 0; i < len; ++i) {
Line 386 ⟶ 518:
if (pc - i < longest) break;
if (i > 0) sum -= primes[i-1];
isEven = i == 0;
sum2 = sum;
for (j = pc - 1; j >= i; --j) {
Line 391 ⟶ 524:
if (temp < longest) break;
if (j < pc - 1) sum2 -= primes[j+1];
if (isPrime(sum2temp % 2) == 0 != isEven) {continue;
mpz_set_ui(bsum, sum2);
if (mpz_probab_prime_p(bsum, 5) > 0) {
if (temp > longest) {
longest = temp;
Line 609 ⟶ 744:
import (
"fmt"
"math/big"
"rcu"
"time"
Line 643 ⟶ 779:
sum -= primes[i-1]
}
isEven := i == 0
sum2 := sum
for j := pc - 1; j >= i; j-- {
Line 652 ⟶ 789:
sum2 -= primes[j+1]
}
if rcu.IsPrime(sum2temp % 2) == 0 != isEven {
continue
}
bsum := big.NewInt(int64(sum2))
if bsum.ProbablyPrime(5) {
if temp > longest {
longest = temp
Line 726 ⟶ 867:
7 + 11 + 13 + 17 + 19 + 23 + .. + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72,618,848,632,313
 
Took 270210 ms
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
type TLongInfo = record
RangeStart,RangeStop: integer;
SeqStart,SeqStop: integer;
Count,Sum: integer;
end;
 
procedure CalmoSoftPrimes(Memo: TMemo);
{Find longest sequence of prime numbers that adds up to a prime}
var Sieve: TPrimeSieve;
var Best,Tmp: TLongInfo;
var I,Cnt: integer;
var S: string;
 
function GetLongest(N,Limit: integer): TLongInfo;
{Get longest sequence starting at N}
{Find longest sequence of primes whose sum is prime}
var Next,Sum,Cnt: integer;
begin
Result.Count:=1;
Result.SeqStart:=N;
Result.SeqStop:=N;
Result.Sum:=1;
Sum:=N; Next:=N;
Cnt:=1;
while true do
begin
Next:=Sieve.NextPrime(Next);
if Next>Limit then break;
Sum:=Sum+Next;
Inc(Cnt);
if IsPrime(Sum) then
begin
Result.SeqStop:=Next;
Result.Count:=Cnt;
Result.Sum:=Sum;
end;
end;
end;
 
 
function LongestRange(Start,Limit: integer): TLongInfo;
{Find longest sequence between Start and Limit}
{Start should be a prime number}
var I: integer;
begin
I:=Start;
Result.SeqStart:=0;
Result.SeqStop:=0;
Result.Count:=0;
while I<=Limit do
begin
Tmp:=GetLongest(I,Limit);
if Tmp.Count>Result.Count then Result:=Tmp;
I:=Sieve.NextPrime(I);
end;
Result.RangeStart:=Start;
Result.RangeStop:=Limit;
end;
 
 
procedure ShowSequenceHeader(Best: TLongInfo);
{Show summary of information}
begin
Memo.Lines.Add('Range: '+IntToStr(Best.RangeStart)+' '+IntToStr(Best.RangeStop));
Memo.Lines.Add('Longest Sequence: '+IntToStr(Best.Count));
Memo.Lines.Add('Sum: '+IntToStr(Best.Sum));
end;
 
 
 
procedure ShowSequence(Best: TLongInfo; Start,Limit: integer);
{Extract sequence info from best and display it}
var S: string;
var I,Cnt: integer;
begin
S:=''; Cnt:=0;
{if Start=0 display full range other wise}
{display from start to limit}
if Start=0 then I:=Best.SeqStart
else I:=Start;
while I<=Best.SeqStop do
begin
Inc(Cnt);
S:=S+Format('%5d',[I]);
if (Cnt mod 10)=0 then S:=S+CRLF;
if Cnt>=Limit then break;
I:=Sieve.NextPrime(I);
end;
Memo.Lines.Add(S);
end;
 
 
procedure ShowHeaderSequence(Best: TLongInfo);
{Show header and sequence}
begin
ShowSequenceHeader(Best);
ShowSequence(Best,0,high(integer));
end;
 
 
 
begin
Sieve:=TPrimeSieve.Create;
try
{Create enough primes to cover range}
Sieve.Intialize(1000);
{Find longest sequence in range}
Best:=LongestRange(2,100);
ShowHeaderSequence(Best);
finally Sieve.Free; end;
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Range: 2 100
Longest Sequence: 21
Sum: 953
7 11 13 17 19 23 29 31 37 41
43 47 53 59 61 67 71 73 79 83
89
Elapsed Time: 2.277 ms.
 
</pre>
 
 
=={{header|J}}==
 
It would be useful to find the length of the longest sequence of these primes where the sum is prime:
 
<syntaxhighlight lang=J> >./,(+/\\. 99#1)*1 p: +/\\. p:i.99
96</syntaxhighlight>
 
With this, we can check all sums of subsequences of 96 primes (from the first 99 primes) for primality:
 
<syntaxhighlight lang=J> 1 p: 96+/\p:i.99
1 0 0 0</syntaxhighlight>
 
In other words, the sum of these primes
 
<syntaxhighlight lang=J> p:i.8 12
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</syntaxhighlight>
 
is this prime:
 
<syntaxhighlight lang=J> +/p:i.96
22039</syntaxhighlight>
 
=={{header|Java}}==
{{trans|Phix}}
Uses the PrimeGenerator class from [[Extensible prime generator#Java]].
<syntaxhighlight lang="java">import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class CalmoSoftPrimes {
public static void main(String[] args) {
PrimeGenerator primeGen = new PrimeGenerator(100000, 250000);
List<Integer> primes = new ArrayList<>();
final int[] limits = {100, 5000, 10000, 500000, 50000000};
long total = 0;
int last = 0;
int prime = primeGen.nextPrime();
for (int limit : limits) {
do {
primes.add(prime);
total += prime;
++last;
prime = primeGen.nextPrime();
} while (prime < limit);
long sum = total;
int longest = 1;
List<Integer> starts = new ArrayList<>();
for (int start = 0; start <= last - longest; ++start) {
long s = sum;
for (int finish = last; finish-- >= start + longest;) {
if (isPrime(s)) {
int length = finish - start + 1;
if (length > longest) {
longest = length;
starts.clear();
}
starts.add(start);
}
s -= primes.get(finish);
}
sum -= primes.get(start);
}
System.out.printf("For primes up to %d:\nThe following sequence%s of %d consecutive primes yield%s a prime sum:\n",
limit, starts.size() == 1 ? "" : "s", longest, starts.size() == 1 ? "s" : "");
for (int i = 0; i < starts.size(); ++i) {
int start = starts.get(i);
sum = 0;
for (int j = start; j < start + longest; ++j)
sum += primes.get(j);
final String separator = " + ";
if (longest > 12) {
System.out.print(join(separator, primes.subList(start, start + 6))
+ separator + "..." + separator
+ join(separator, primes.subList(start + longest - 6, start + longest)));
} else {
System.out.print(join(separator, primes.subList(start, start + longest)));
}
System.out.println(" = " + sum);
}
System.out.println();
}
}
 
private static <T> String join(String separator, List<T> list) {
return list.stream().map(Object::toString).collect(Collectors.joining(separator));
}
 
private static boolean isPrime(long n) {
if (n < 2)
return false;
if (n % 2 == 0)
return n == 2;
if (n % 3 == 0)
return n == 3;
for (long p = 5; p * p <= n; p += 4) {
if (n % p == 0)
return false;
p += 2;
if (n % p == 0)
return false;
}
return true;
}
}</syntaxhighlight>
 
{{out}}
<pre>
For primes up to 100:
The following sequence of 21 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 + ... + 67 + 71 + 73 + 79 + 83 + 89 = 953
 
For primes up to 5000:
The following sequence of 665 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 + ... + 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1543127
 
For primes up to 10000:
The following sequences of 1223 consecutive primes yield a prime sum:
3 + 5 + 7 + 11 + 13 + 17 + ... + 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5686633
7 + 11 + 13 + 17 + 19 + 23 + ... + 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5706497
 
For primes up to 500000:
The following sequence of 41530 consecutive primes yields a prime sum:
2 + 3 + 5 + 7 + 11 + 13 + ... + 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9910236647
 
For primes up to 50000000:
The following sequence of 3001117 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 + ... + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72618848632313
 
</pre>
 
Line 734 ⟶ 1,148:
function calmo_prime_sequence(N)
pri = primes(N)
for window_sizew in lastindex(pri):-1:2
forpsum i= in firstindexsum(pri)[1:lastindex(priw])-window_size
for d in if isprime(sum0:lastindex(pri[i:i+window_size]))-w
if d > 0
println("Longest Calmo prime seq (length ", window_size + 1,
psum -= ") of primes less than $N totals ", sum(pri[i:i+window_sized]))
ifpsum window_size+= >pri[w 24+ d]
println(string(pri[1:i+5])[begin:end-1], ", ... ",
if isprime(psum)
string(pri[i-6+window_size:i+window_size])[begin+1:end], "\n")
println("Longest Calmo prime seq (length ", w,
") of primes less than $N totals ", sum(pri[begin+d:d+w]))
if w > 24
println(string(pri[d+1:d+6])[begin:end-1], ", ... ",
string(pri[d-5+w:d+w])[begin+1:end], "\n")
else
println("The sequence is: ", pri[id+1:id+window_sizew], "\n")
end
return
Line 751 ⟶ 1,170:
end
 
foreach(calmo_prime_sequence, [100, 500_000, 50_000_000])
calmo_prime_sequence(100)
calmo_prime_sequence(50_000_000)
</syntaxhighlight>{{out}}
<pre>
Longest Calmo prime seq (length 21) of primes less than 100 totals 953
The sequence is: [7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89]
 
Longest Calmo prime seq (length 41530) of primes less than 500000 totals 9910236647
[2, 3, 5, 7, 11, 13, ... 499787, 499801, 499819, 499853, 499879, 499883]
 
Longest Calmo prime seq (length 3001117) of primes less than 50000000 totals 72618848632313
[2, 3, 5, 7, 11, 13, 17, 19, 23, ... 49999693, 49999699, 49999711, 49999739, 49999751, 49999753, 49999757]
</pre>
 
=={{header|Nim}}==
{{trans|Wren}}
With some modifications.
<syntaxhighlight lang="Nim">import std/[algorithm, math, strformat, strutils]
 
func initPrimes(lim: Natural): seq[int] =
## Build list of primes using a sieve of Erathostenes.
var composite = newSeq[bool]((lim + 1) shr 1)
composite[0] = true
for n in countup(3, int(sqrt(lim.toFloat)), 2):
if not composite[n shr 1]:
for k in countup(n * n, lim, 2 * n):
composite[k shr 1] = true
result.add 2
for n in countup(3, lim, 2):
if not composite[n shr 1]:
result.add n
 
func isPrime(n: Natural): bool =
## Return "true" is "n" is prime.
if n < 2: return false
if (n and 1) == 0: return n == 2
if n mod 3 == 0: return n == 3
var d = 5
var step = 2
while d * d <= n:
if n mod d == 0:
return false
inc d, step
step = 6 - step
return true
 
const Max = 50_000_000
let primes = initPrimes(Max)
 
proc calmoPrimes(limit: Positive): (int, seq[int], seq[int], seq[int]) =
## Find the longest sequence of CalmoSoft primes up to "limit".
let phigh = primes.upperBound(limit) - 1
var sum1 = sum(primes.toOpenArray(0, phigh))
var longest = 0
var sIndices, eIndices, sums: seq[int]
for i in 0..phigh:
if phigh - i + 1 < longest:
break
if i > 0:
dec sum1, primes[i - 1]
let isEven = i == 0
var sum2 = sum1
for j in countdown(phigh, i):
let temp = j - i + 1
if temp < longest:
break
if j < phigh:
dec sum2, primes[j + 1]
if ((temp and 1) == 0) != isEven:
continue
if sum2.isPrime:
if temp > longest:
longest = temp
sIndices = @[i]
eIndices = @[j]
sums = @[sum2]
else:
sIndices.add i
eIndices.add j
sums.add sum2
break
result = (longest, sIndices, eIndices, sums)
 
func plural(lg: int): (string, string) =
## Return the singular or plural form according to value of "lg".
result = if lg == 1: ("", "is") else: ("s", "are")
 
 
for limit in [100, 250, 5000, 10000, 500000, 50000000]:
let (longest, sIndices, eIndices, sums) = calmoPrimes(limit)
let (p1, p2) = plural(sums.len)
echo &"For primes up to {insertSep($limit)} the longest sequence{p1} of CalmoSoft primes"
echo &"having a length of {insertSep($longest)} {p2}:\n"
for i in 0..sIndices.high:
let cp = primes[sIndices[i]..eIndices[i]]
echo &"{cp[0..5].join(\" + \")} + ... + {cp[^6..^1].join(\" + \")} = {sums[i]}"
echo()
</syntaxhighlight>
 
{{out}}
<pre>For primes up to 100 the longest sequence of CalmoSoft primes
having a length of 21 is:
 
7 + 11 + 13 + 17 + 19 + 23 + ... + 67 + 71 + 73 + 79 + 83 + 89 = 953
 
For primes up to 250 the longest sequence of CalmoSoft primes
having a length of 49 is:
 
11 + 13 + 17 + 19 + 23 + 29 + ... + 223 + 227 + 229 + 233 + 239 + 241 = 5813
 
For primes up to 5_000 the longest sequence of CalmoSoft primes
having a length of 665 is:
 
7 + 11 + 13 + 17 + 19 + 23 + ... + 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1543127
 
For primes up to 10_000 the longest sequences of CalmoSoft primes
having a length of 1_223 are:
 
3 + 5 + 7 + 11 + 13 + 17 + ... + 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5686633
 
7 + 11 + 13 + 17 + 19 + 23 + ... + 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5706497
 
For primes up to 500_000 the longest sequence of CalmoSoft primes
having a length of 41_530 is:
 
2 + 3 + 5 + 7 + 11 + 13 + ... + 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9910236647
 
For primes up to 50_000_000 the longest sequence of CalmoSoft primes
having a length of 3_001_117 is:
 
7 + 11 + 13 + 17 + 19 + 23 + ... + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72618848632313
</pre>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl" line>use strict;
use warnings;
use ntheory <primes is_prime vecsum>;
 
for my $limit (<100 250 500 1000>) {
my @primes = @{ primes(2,$limit) };
T: for my $terms (reverse 1 .. @primes) {
for my $i (0 .. @primes-$terms) {
my @primes = @primes[$i..($i+$terms)-1];
next unless is_prime (my $sum = vecsum @primes);
print "For primes up to $limit:\n",
join ' ... ', join(' + ',@primes[0..5]), join(' + ',@primes[-5..-1]) . " = $sum ($terms primes)\n\n";
last T
}
}
}</syntaxhighlight>
{{out}}
<pre>For primes up to 100:
7 + 11 + 13 + 17 + 19 + 23 ... 71 + 73 + 79 + 83 + 89 = 953 (21 primes)
 
For primes up to 250:
11 + 13 + 17 + 19 + 23 + 29 ... 227 + 229 + 233 + 239 + 241 = 5813 (49 primes)
 
For primes up to 500:
31 + 37 + 41 + 43 + 47 + 53 ... 467 + 479 + 487 + 491 + 499 = 21407 (85 primes)
 
For primes up to 1000:
13 + 17 + 19 + 23 + 29 + 31 ... 971 + 977 + 983 + 991 + 997 = 76099 (163 primes)</pre>
 
=={{header|Phix}}==
Line 844 ⟶ 1,415:
 
 
def calmo_prime_sequence(N=100maxp):
""" find the largest prime seq in primes < Nmaxp that sums to a prime """
pri = list(primerange(Nmaxp))
for window_sizewin in range(len(pri)+-1, 1, -1): # window size
forpsum i= in range(lensum(pri[:win])-window_size):
for bot in range(-1, len(pri)-win): # the last bottom of window
if isprime(sum(pri[i:i+window_size])):
if bot >= print(0:
psum -= pri[bot]
f'Longest Calmo prime seq (length {window_size}) of primes less than {N} totals {sum(pri[i:i+window_size])}:')
ifpsum window_size+= >pri[win 24:+ bot]
if isprime(psum):
print('[', ', '.join(map(str, pri[i:i+6])), ', ... ', ', '.join(map(str, pri[i+window_size-6:i+window_size])), ']\n', sep='')
print('Longest Calmo prime seq (length', win,
') of primes less than', maxp, 'totals', sum(pri[bot+1:bot+win+1]))
if win > 24:
print('[', ', '.join(map(str, pri[bot+1:bot+7])), ', ... ',
', '.join(map(str, pri[bot-5+win:bot+win+1])), ']\n', sep='')
else:
print('The sequence is:', pri[ibot+1:ibot+win+window_size1], '\n')
return
 
 
for pmax in [100, 500_000, 50_000_000]:
calmo_prime_sequence()
calmo_prime_sequence(50_000_000pmax)
</syntaxhighlight>{{out}}
<pre>
Longest Calmo prime seq (length 21 ) of primes less than 100 totals 953:
The sequence is: [7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89]
 
Longest Calmo prime seq (length 3001117) of primes less than 50000000 totals 72618848632313:
Longest Calmo prime seq (length 41530 ) of primes less than 500000 totals 9910236647
[2, 3, 5, 7, 11, 13, ... 499787, 499801, 499819, 499853, 499879, 499883]
 
Longest Calmo prime seq (length 3001117 ) of primes less than 50000000 totals 72618848632313
[7, 11, 13, 17, 19, 23, ... 49999699, 49999711, 49999739, 49999751, 49999753, 49999757]
</pre>
Line 1,013 ⟶ 1,593:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
This runs in about 4.3.5 seconds (cf. Julia 1.3 seconds) on my Core i7 machine. However, 2.6 seconds of that is needed to sieve for primes up to 50 million.
<syntaxhighlight lang="ecmascriptwren">import "./math" for Int, Nums
import "./fmt"for Fmt
 
Line 1,030 ⟶ 1,610:
if (pc - i < longest) break
if (i > 0) sum = sum - primes[i-1]
var isEven = (i == 0)
var sum2 = sum
for (j in pc-1..i) {
var temp = j - i + 1
if (temp < longest) break
if (j < pc - 1) sum2 = sum2 - primes[j+1]
if (Int.isPrime(sum2temp % 2) == 0 != isEven) {continue
if (Int.isPrime2(sum2)) {
if (temp > longest) {
longest = temp
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/340256...358443"