# CalmoSoft primes

CalmoSoft primes is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Definition

Let p(1), p(2), p(3), ... , p(n) be consecutive prime numbers. If the sum of any consecutive sub-sequence of these numbers is a prime number, then the numbers in such a sub-sequence are called CalmoSoft primes.

Find and show here the longest sequence of CalmoSoft primes for p(n) < 100.

Stretch

Show a shortened version (first and last 6 primes) of the same for p(n) < fifty million.
Tip: if it takes longer than twenty seconds, you're doing it wrong.

## ALGOL 68

If there are multiple sequences with the maximum length, this will only show the first.

```BEGIN # find the longest sequence of primes < 100 that sums to a prime       #
# called Calmosoft primes                                              #
[]INT prime = (  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
); # primes up to 100                                      #
# returns TRUE if n is prime, FALSE otherwise - uses trial division      #
PROC is prime = ( INT n )BOOL:
IF   n < 3       THEN n = 2
ELIF n MOD 3 = 0 THEN n = 3
ELIF NOT ODD n   THEN FALSE
ELSE
BOOL is a prime := TRUE;
FOR f FROM 5 BY 2 WHILE f * f <= n AND is a prime DO
is a prime := n MOD f /= 0
OD;
is a prime
FI # is prime # ;
# calculate the sum of all the primes                                    #
INT seq sum := 0; FOR i FROM LWB prime TO UPB prime DO seq sum +:= prime[ i ] OD;
# find the longest sequence that sums to a prime                         #
INT  max start := -1;
INT  max end   := -1;
INT  max len   := -1;
INT  max sum   := -1;
FOR this start FROM LWB prime TO UPB prime - 1
WHILE
INT  this end   := UPB prime;
INT  this len   := ( this end + 1 ) - this start;
IF this len > max len THEN
INT  this sum   := seq sum;
BOOL this prime := FALSE;
WHILE this end >= this start
AND NOT ( this prime := is prime( this sum ) )
AND this len > max len
DO
this sum -:= prime[ this end ];
this end -:= 1;
this len -:= 1
OD;
IF this prime AND this len > max len THEN
max len   := this len; # found a longer sequence             #
max start := this start;
max end   := this end;
max sum   := this sum
FI
FI;
( UPB prime - this start ) > max len
DO
# the start prime won't be in the next sequence                      #
seq sum -:= prime[ this start ]
OD;
print( ( "Longest sequence of Calmosoft primes up to ",    whole( prime[ UPB prime ], 0 )
, " has sum ", whole( max sum, 0 ), " and length ", whole( max len,            0 )
, newline
)
);
FOR i FROM max start TO max end DO print( ( " ", whole( prime[ i ], 0 ) ) ) OD
END```
Output:
```Longest sequence of Calmosoft primes up to 97 has sum 953 and length 21
7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89
```

### Stretch

Basically the same algorithm as the Algol 68 Basic task sample but stops searching when there can't be a longer sequence.
Also, if the first prime in the sequence is 2, the sequence must have even length, otherwise it must have odd length.

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32

Uses Algol 68G's LONG LONG INT for the Millar Rabin test. To run this with Algol 68G, you need `-heap 512M` on the command line.
Note the source of the `is probably prime` routine used here is available from a page in Rosetta Code - see the following link.

```BEGIN # find the longest sequence of primes < 50 000 000 that sums to a prime#
# called Calmosoft primes                                              #
INT max prime = 50 000 000;
# sieve, count and sum the primes to max prime and replace the sieve     #
# with a list of primes                                                  #
[ 1 : max prime ]INT prime;
INT   yes = 1, no = 0;
prime[ 1 ] := 2;                           # the first prime in the list #
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 ] := yes OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := no  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 ] := no 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;
LONG INT  seq sum   := p sum;
# find the longest sequence that sums to a prime                         #
INT       max start := -1;
INT       max end   := -1;
INT       max len   := -1;
LONG INT  max sum   := -1;
FOR this start TO p count - 1
WHILE
INT      this end   := p count;
INT      this len   := ( this end + 1 ) - this start;
LONG INT this sum   := seq sum;
IF ODD this len THEN
IF this start = 1 THEN
# the first prime is 2, the sequence must have even length   #
this sum -:= prime[ this end ];
this end -:= 1;
this len -:= 1
FI
ELSE
IF this start > 1 THEN
# the first prime isn't 2, the sequence must have odd length #
this sum -:= prime[ this end ];
this end -:= 1;
this len -:= 1
FI
FI;
IF this len > max len THEN
BOOL this prime := FALSE;
WHILE IF   this end < this start OR this len < max len
THEN FALSE
ELSE NOT ( this prime := is probably prime( this sum ) )
FI
DO
this sum -:= prime[ this end       ];
this sum -:= prime[ this end -:= 1 ];
this end -:= 1;
this len -:= 2
OD;
IF this prime AND this len > max len THEN
max len   := this len; # found a longer sequence             #
max start := this start;
max end   := this end;
max sum   := this sum
FI
FI;
( p count - this start ) > max len
DO
# the start prime won't be in the next sequence                      #
seq sum -:= prime[ this start ]
OD;
print( ( "Longest sequence of Calmosoft primes up to ",    whole( prime[ p count ], 0 )
, " has sum ", whole( max sum, 0 ), " and length ", whole( max len,                      0 )
, newline
)
);
IF max len < 12 THEN
FOR i FROM max start   TO max end       DO print( ( " ", whole( prime[ i ], 0 ) ) ) OD
ELSE
FOR i FROM max start   TO max start + 6 DO print( ( " ", whole( prime[ i ], 0 ) ) ) OD;
print( ( " ... " ) );
FOR i FROM max end - 6 TO max end       DO print( ( " ", whole( prime[ i ], 0 ) ) ) OD
FI
END```
Output:
```Longest sequence of Calmosoft primes up to 49999991 has sum 72618848632313 and length 3001117
7 11 13 17 19 23 29 ...  49999693 49999699 49999711 49999739 49999751 49999753 49999757
```

## 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.

```-- 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)
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

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)

```
Output:
```"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
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"
```

## Arturo

```subseqs: function [a :block][
;; description: « returns every contiguous subsequence in a block
;; returns: :block
flatten.once map 0..dec size a'x ->
map x..dec size a'y -> a\[x..y]
]

calmo: 1..100 | select => prime?
| subseqs
| select => [prime? sum &]
| maximum => size

print ~{
The longest sequence of calmo primes < 100
has sum |sum calmo| (prime) and length |size calmo|:

|calmo|
}```
Output:
```The longest sequence of calmo primes < 100
has sum 953 (prime) and length 21:

[7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89]```

## BASIC

### FreeBASIC

Translation of: XPL0
```#include "isprime.bas"

Dim As Integer Primes(100), PrimeSums(100)
Dim As Integer i, n, Size, Head, Tail, Longest, Sum, SaveHead, SaveTail
i = 0                         'make table of primes
For n = 2 To 100-1
If isPrime(n) Then Primes(i) = n : i += 1
Next
Size = i                       'make table of sums
PrimeSums(0) = Primes(0)
For i = 1 To Size-1
PrimeSums(i) = PrimeSums(i-1) + Primes(i)
Next
Longest = 0                    'find longest sequence
For Head = Size-1 To 0 Step -1
For Tail = 0 To Head
If IsPrime(Sum) Then
SaveTail = Tail
End If
Sum -= Primes(Tail)
End If
Next
Next

Print "[";
For i = SaveTail To SaveHead
Print Primes(i); ",";
Next
Print Chr\$(8); Chr\$(8); " ]"

Sum = 0
For i = SaveTail To SaveHead
Sum += Primes(i)
Print Primes(i);
If i <> SaveHead Then Print " +";
Next
Print Chr\$(8); " ="; Sum; " is prime number"
Print "The longest sequence of CalmoSoft primes ="; Longest+1
Sleep
```
Output:
```[ 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 ]
7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 + 37 + 41 + 43 + 47 + 53 + 59 + 61 + 67 + 71 + 73 + 79 + 83 + 89 = 953 is prime number
The longest sequence of CalmoSoft primes = 21```

### Yabasic

Translation of: FreeBASIC
```//import isprime

dim Primes(100)
dim PrimeSums(100)
i = 1                         //make table of primes
for n = 2 to 100-1
if isPrime(n) then Primes(i) = n : i = i + 1 : fi
next
tam = i                       //make table of sums
PrimeSums(0) = Primes(0)
for i = 1 to tam-1
PrimeSums(i) = PrimeSums(i-1) + Primes(i)
next
Longest = 0                    //find longest sequence
for Head = tam-1 to 0 step -1
for Tail = 0 to Head
if isPrime(Sum) then
SaveTail = Tail
end if
Sum = Sum - Primes(Tail)
end if
next
next

print "[ ";
for i = SaveTail to SaveHead
print Primes(i), ", ";
next
print chr\$(8), chr\$(8), " ]"

Sum = 0
for i = SaveTail to SaveHead
Sum = Sum + Primes(i)
print Primes(i);
if i <> SaveHead  print " + ";
next
print chr\$(8), " = ", Sum, " is prime number"
print "The longest sequence of CalmoSoft primes = ", Longest+1
end
```
Output:
`Same as FreeBASIC entry.`

## C

Library: GMP

Run time is 250 milliseconds (GCC -O1) which is slightly slower than Go.

```#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdint.h>
#include <locale.h>
#include <gmp.h>

#define MAX 50000000

typedef uint64_t u64;

int *primeSieve(int limit, int *length) {
int i, p, *primes;
int j, pc = 0;
limit++;
// True denotes composite, false denotes prime.
bool *c = calloc(limit, sizeof(bool)); // all false by default
c = true;
c = true;
for (i = 4; i < limit; i += 2) c[i] = true;
p = 3; // Start from 3.
while (true) {
u64 p2 = p * p;
if (p2 >= limit) break;
for (i = p2; i < limit; i += 2 * p) c[i] = true;
while (true) {
p += 2;
if (!c[p]) break;
}
}
for (i = 0; i < limit; ++i) {
if (!c[i]) ++pc;
}
primes = (int *)malloc(pc * sizeof(u64));
for (i = 0, j = 0; i < limit; ++i) {
if (!c[i]) primes[j++] = i;
}
free(c);
*length = pc;
return primes;
}

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) {
if (primes[i] > limit) {
pc = i;
break;
}
}
}
for (i = 0; i < pc; ++i) sum += primes[i];
for (i = 0; i < pc; ++i) {
if (pc - i < longest) break;
if (i > 0) sum -= primes[i-1];
isEven = i == 0;
sum2 = sum;
for (j = pc - 1; j >= i; --j) {
temp = j - i + 1;
if (temp < longest) break;
if (j < pc - 1) sum2 -= primes[j+1];
if ((temp % 2) == 0 != isEven) continue;
mpz_set_ui(bsum, sum2);
if (mpz_probab_prime_p(bsum, 5) > 0) {
if (temp > longest) {
longest = temp;
ic = 0;
}
sIndices[ic] = i;
eIndices[ic] = j;
sums[ic] = sum2;
++ic;
break;
}
}
}
*ilen = ic;
return longest;
}

int main() {
int i, j, k, len, ilen, limit, longest;
int *primes = primeSieve(MAX, &len);
int limits = {100, 250, 5000, 10000, 500000, 50000000};
setlocale(LC_NUMERIC, "");
int sIndices;
int eIndices;
u64 sums;
for (i = 0; i < 6; ++i) {
limit = limits[i];
longest = calmoPrimes(limit, primes, len, sIndices, eIndices, sums, &ilen);
printf("For primes up to %'d the longest sequence(s) of CalmoSoft primes\n", limit);
printf("having a length of %'d is/are:\n\n", longest);
for (j = 0; j < ilen; ++j) {
char cps = "";
char buf;
int bytes = 0, totalBytes = 0;
for (k = sIndices[j]; k <= sIndices[j]+5; ++k) {
bytes = sprintf(buf, "%d + ", primes[k]);
strcpy(cps + totalBytes, buf);
totalBytes += bytes;
}
strcpy(cps + totalBytes, ".. + ");
totalBytes += 5;
for (k = eIndices[j]-5; k <= eIndices[j]; ++k) {
bytes = sprintf(buf, "%d + ", primes[k]);
strcpy(cps + totalBytes, buf);
totalBytes += bytes;
}
cps[totalBytes-3] = '\0';
printf("%s = %'ld\n", cps, sums[j]);
}
printf("\n");
}
free(primes);
return 0;
}
```
Output:
```For primes up to 100 the longest sequence(s) of CalmoSoft primes
having a length of 21 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 67 + 71 + 73 + 79 + 83 + 89 = 953

For primes up to 250 the longest sequence(s) of CalmoSoft primes
having a length of 49 is/are:

11 + 13 + 17 + 19 + 23 + 29 + .. + 223 + 227 + 229 + 233 + 239 + 241 = 5,813

For primes up to 5,000 the longest sequence(s) of CalmoSoft primes
having a length of 665 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1,543,127

For primes up to 10,000 the longest sequence(s) of CalmoSoft primes
having a length of 1,223 is/are:

3 + 5 + 7 + 11 + 13 + 17 + .. + 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5,686,633
7 + 11 + 13 + 17 + 19 + 23 + .. + 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5,706,497

For primes up to 500,000 the longest sequence(s) of CalmoSoft primes
having a length of 41,530 is/are:

2 + 3 + 5 + 7 + 11 + 13 + .. + 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9,910,236,647

For primes up to 50,000,000 the longest sequence(s) of CalmoSoft primes
having a length of 3,001,117 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72,618,848,632,313
```

## C++

Translation of: Phix
Library: Primesieve
```#include <chrono>
#include <iostream>
#include <locale>
#include <numeric>
#include <sstream>

#include <primesieve.hpp>

bool is_prime(uint64_t n) {
if (n < 2)
return false;
if (n % 2 == 0)
return n == 2;
if (n % 3 == 0)
return n == 3;
if (n % 5 == 0)
return n == 5;
static constexpr uint64_t wheel[] = {4, 2, 4, 2, 4, 6, 2, 6};
uint64_t p = 7;
for (;;) {
for (uint64_t w : wheel) {
if (p * p > n)
return true;
if (n % p == 0)
return false;
p += w;
}
}
}

template <typename Iterator>
std::string join(Iterator begin, Iterator end, std::string_view separator) {
std::ostringstream os;
if (begin != end) {
os << *begin++;
for (; begin != end; ++begin)
os << separator << *begin;
}
return os.str();
}

int main() {
std::cout.imbue(std::locale(""));
auto start = std::chrono::high_resolution_clock::now();
std::vector<uint64_t> primes;
uint64_t from = 0;
for (uint64_t limit : {100, 5000, 10000, 500000, 50000000}) {
primesieve::generate_primes(from, limit, &primes);
from = limit + 1;
uint64_t sum =
std::accumulate(primes.begin(), primes.end(), uint64_t(0));
size_t last = primes.size();
size_t longest = 1;
std::vector<std::pair<size_t, uint64_t>> starts;
for (size_t start = 0; start <= last - longest; ++start) {
uint64_t s = sum;
for (size_t finish = last; finish-- >= start + longest;) {
if (is_prime(s)) {
size_t length = finish - start + 1;
if (length > longest) {
longest = length;
starts.clear();
}
starts.emplace_back(start, s);
}
s -= primes[finish];
}
sum -= primes[start];
}
std::cout << "For primes up to " << limit << ":\n"
<< "The following sequence" << (starts.size() == 1 ? "" : "s")
<< " of " << longest << " consecutive primes yield"
<< (starts.size() == 1 ? "s" : "") << " a prime sum:\n";
for (auto [start, sum] : starts) {
auto begin = primes.begin() + start;
auto end = begin + longest;
const char* separator = " + ";
if (longest > 12) {
std::cout << join(begin, begin + 6, separator) << separator
<< "..." << separator
<< join(end - 6, end, separator);
} else {
std::cout << join(begin, end, separator);
}
std::cout << " = " << sum << '\n';
}
std::cout << '\n';
}
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> duration(end - start);
std::cout << "Elapsed time: " << duration.count() << " seconds\n";
}
```
Output:
```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 5,000:
The following sequence of 665 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 + ... + 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1,543,127

For primes up to 10,000:
The following sequences of 1,223 consecutive primes yield a prime sum:
3 + 5 + 7 + 11 + 13 + 17 + ... + 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5,686,633
7 + 11 + 13 + 17 + 19 + 23 + ... + 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5,706,497

For primes up to 500,000:
The following sequence of 41,530 consecutive primes yields a prime sum:
2 + 3 + 5 + 7 + 11 + 13 + ... + 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9,910,236,647

For primes up to 50,000,000:
The following sequence of 3,001,117 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 + ... + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72,618,848,632,313

Elapsed time: 0.0814633 seconds
```

## Go

Translation of: Wren
Library: Go-rcu
```package main

import (
"fmt"
"math/big"
"rcu"
"time"
)

var start = time.Now()

const max = 50_000_000

var primes = rcu.Primes(max)

func calmoPrimes(limit int) (int, []int, []int, []int) {
var pc, sum int
if limit < max {
for i := 0; i < len(primes); i++ {
if primes[i] > limit {
pc = i
break
}
}
} else {
pc = len(primes)
}
for i := 0; i < pc; i++ {
sum += primes[i]
}
longest := 0
var sIndices, eIndices, sums []int
for i := 0; i < pc; i++ {
if pc-i < longest {
break
}
if i > 0 {
sum -= primes[i-1]
}
isEven := i == 0
sum2 := sum
for j := pc - 1; j >= i; j-- {
temp := j - i + 1
if temp < longest {
break
}
if j < pc-1 {
sum2 -= primes[j+1]
}
if (temp % 2) == 0 != isEven {
continue
}
bsum := big.NewInt(int64(sum2))
if bsum.ProbablyPrime(5) {
if temp > longest {
longest = temp
sIndices = []int{i}
eIndices = []int{j}
sums = []int{sum2}
} else {
sIndices = append(sIndices, i)
eIndices = append(eIndices, j)
sums = append(sums, sum2)
}
break
}
}
}
return longest, sIndices, eIndices, sums
}

func main() {
for _, limit := range []int{100, 250, 5000, 10000, 500000, 50000000} {
longest, sIndices, eIndices, sums := calmoPrimes(limit)
fmt.Println("For primes up to", rcu.Commatize(limit), "the longest sequence(s) of CalmoSoft primes")
fmt.Println("having a length of", rcu.Commatize(longest), "is/are:\n")
for i := 0; i < len(sIndices); i++ {
cp1 := primes[sIndices[i] : sIndices[i]+6]
cp2 := primes[eIndices[i]-5 : eIndices[i]+1]
cps := ""
for _, p := range cp1 {
cps += fmt.Sprintf("%d + ", p)
}
cps += ".. + "
for _, p := range cp2 {
cps += fmt.Sprintf("%d + ", p)
}
fmt.Printf("%s = %s\n", cps[:len(cps)-3], rcu.Commatize(sums[i]))
}
fmt.Println()
}
fmt.Printf("Took %d ms\n", time.Since(start).Milliseconds())
}
```
Output:
```For primes up to 100 the longest sequence(s) of CalmoSoft primes
having a length of 21 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 67 + 71 + 73 + 79 + 83 + 89 = 953

For primes up to 250 the longest sequence(s) of CalmoSoft primes
having a length of 49 is/are:

11 + 13 + 17 + 19 + 23 + 29 + .. + 223 + 227 + 229 + 233 + 239 + 241 = 5,813

For primes up to 5,000 the longest sequence(s) of CalmoSoft primes
having a length of 665 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1,543,127

For primes up to 10,000 the longest sequence(s) of CalmoSoft primes
having a length of 1,223 is/are:

3 + 5 + 7 + 11 + 13 + 17 + .. + 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5,686,633
7 + 11 + 13 + 17 + 19 + 23 + .. + 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5,706,497

For primes up to 500,000 the longest sequence(s) of CalmoSoft primes
having a length of 41,530 is/are:

2 + 3 + 5 + 7 + 11 + 13 + .. + 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9,910,236,647

For primes up to 50,000,000 the longest sequence(s) of CalmoSoft primes
having a length of 3,001,117 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72,618,848,632,313

Took 210 ms
```

## Delphi

Works with: Delphi version 6.0

```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;

{Show summary of information}
begin
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;
end;

begin
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);
finally Sieve.Free; end;
end;
```
Output:
```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.

```

## J

It would be useful to find the length of the longest sequence of these primes where the sum is prime:

```   >./,(+/\\. 99#1)*1 p: +/\\. p:i.99
96
```

With this, we can check all sums of subsequences of 96 primes (from the first 99 primes) for primality:

```   1 p: 96+/\p:i.99
1 0 0 0
```

In other words, the sum of these primes

```   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
```

is this prime:

```    +/p:i.96
22039
```

## Java

Translation of: Phix

Uses the PrimeGenerator class from Extensible prime generator#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 {
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();
}
}
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;
}
}
```
Output:
```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

```

## Julia

```using Primes

function calmo_prime_sequence(N)
pri = primes(N)
for w in lastindex(pri):-1:2
psum = sum(pri[1:w])
for d in 0:lastindex(pri)-w
if d > 0
psum -= pri[d]
psum += pri[w + d]
end
if isprime(psum)
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[d+1:d+w], "\n")
end
return
end
end
end
end

foreach(calmo_prime_sequence, [100, 500_000, 50_000_000])
```
Output:
```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
[7, 11, 13, 17, 19, 23, ... 49999699, 49999711, 49999739, 49999751, 49999753, 49999757]
```

## Nim

Translation of: Wren

With some modifications.

```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 = 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
for n in countup(3, lim, 2):
if not composite[n shr 1]:

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:
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()
```
Output:
```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
```

## Perl

Library: ntheory
```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
}
}
}
```
Output:
```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)```

## Phix

```for lim in {100,5e3,1e4,5e5,5e7} do
sequence primes = get_primes_le(lim), starts = {}
integer l = length(primes), longest = 1, start = 1
atom t = sum(primes)
while start<=l-longest+1 do
atom s = t
for finish=l to start+longest-1 by -1 do
if is_prime(s) then
integer len = finish-start+1
if len>longest then
longest = len
starts = {start}
else
assert(len==longest)
starts &= start
end if
exit
end if
s -= primes[finish]
end for
t -= primes[start]
start += 1
end while
printf(1,"For primes up to %s:\n",ordinal(lim,true))
string {s,ns} = iff(length(starts)=1?{"","s"}:{"s",""})
printf(1,"The following sequence%s of %,d consecutive primes yield%s a prime sum:\n",{s,longest,ns})
for start in starts do
sequence p = primes[start..start+longest-1]
string f6 = join(p[1..6]," + ",fmt:="%d"),
l6 = join(p[-6..-1]," + ",fmt:="%d")
printf(1," %s +..+ %s = %,d\n",{f6,l6,sum(p)})
end for
printf(1,"\n")
end for
```
Output:
```For primes up to one hundred:
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 five thousand:
The following sequence of 665 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 +..+ 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1,543,127

For primes up to ten thousand:
The following sequences of 1,223 consecutive primes yield a prime sum:
3 + 5 + 7 + 11 + 13 + 17 +..+ 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5,686,633
7 + 11 + 13 + 17 + 19 + 23 +..+ 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5,706,497

For primes up to five hundred thousand:
The following sequence of 41,530 consecutive primes yields a prime sum:
2 + 3 + 5 + 7 + 11 + 13 +..+ 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9,910,236,647

For primes up to fifty million:
The following sequence of 3,001,117 consecutive primes yields a prime sum:
7 + 11 + 13 + 17 + 19 + 23 +..+ 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72,618,848,632,313
```

## Python

```from sympy import isprime, primerange

pri = list(primerange(1, 100))

lcal = sorted([pri[i:j] for j in range(len(pri), 0, -1)
for i in range(len(pri)) if j > i and isprime(sum(pri[i:j]))], key=len)[-1]

print(f'Longest Calmo prime seq (length {len(lcal)}) of primes less than 100 is:\n{lcal}')
```
Output:
```Longest Calmo prime seq (length 21) of primes less than 100 is:
[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89]
```

Translation of: Julia
```""" rosettacode.org/wiki/CalmoSoft_primes """

from sympy import isprime, primerange

def calmo_prime_sequence(maxp):
""" find the largest prime seq in primes < maxp that sums to a prime """
pri = list(primerange(maxp))
for win in range(len(pri)-1, 1, -1):  # window size
psum = sum(pri[:win])
for bot in range(-1, len(pri)-win):  # the last bottom of window
if bot >= 0:
psum -= pri[bot]
psum += pri[win + bot]
if isprime(psum):
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[bot+1:bot+win+1], '\n')
return

for pmax in [100, 500_000, 50_000_000]:
calmo_prime_sequence(pmax)
```
Output:
```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
[7, 11, 13, 17, 19, 23, ... 49999699, 49999711, 49999739, 49999751, 49999753, 49999757]
```

## Raku

Longest sliding window prime sums

```use Lingua::EN::Numbers;

sub sliding-window(@list, \$window) { (^(+@list - \$window)).map: { @list[\$_ .. \$_+\$window] } }

for flat (1e2, 1e3, 1e4, 1e5).map: { (1, 2.5, 5) »×» \$_ } -> \$upto {

my @primes = (^\$upto).grep: &is-prime;

for +@primes ... 1 {
my @sums = @primes.&sliding-window(\$_).grep: { .sum.is-prime }
next unless @sums;
say "\nFor primes up to {\$upto.Int.&cardinal}:\nLongest sequence of consecutive primes yielding a prime sum: elements: {comma 1+\$_}";
for @sums {  say " {join '...', .[0..5, *-5..*]».&comma».join(' + ')}, sum: {.sum.&comma}" }
last
}
}
```
Output:
```For primes up to one hundred:
Longest sequence of consecutive primes yielding a prime sum: elements: 21
7 + 11 + 13 + 17 + 19 + 23...71 + 73 + 79 + 83 + 89, sum: 953

For primes up to two hundred fifty:
Longest sequence of consecutive primes yielding a prime sum: elements: 49
11 + 13 + 17 + 19 + 23 + 29...227 + 229 + 233 + 239 + 241, sum: 5,813

For primes up to five hundred:
Longest sequence of consecutive primes yielding a prime sum: elements: 85
31 + 37 + 41 + 43 + 47 + 53...467 + 479 + 487 + 491 + 499, sum: 21,407

For primes up to one thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 163
13 + 17 + 19 + 23 + 29 + 31...971 + 977 + 983 + 991 + 997, sum: 76,099

For primes up to two thousand, five hundred:
Longest sequence of consecutive primes yielding a prime sum: elements: 359
7 + 11 + 13 + 17 + 19 + 23...2,411 + 2,417 + 2,423 + 2,437 + 2,441, sum: 408,479

For primes up to five thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 665
7 + 11 + 13 + 17 + 19 + 23...4,967 + 4,969 + 4,973 + 4,987 + 4,993, sum: 1,543,127

For primes up to ten thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 1,223
3 + 5 + 7 + 11 + 13 + 17...9,887 + 9,901 + 9,907 + 9,923 + 9,929, sum: 5,686,633
7 + 11 + 13 + 17 + 19 + 23...9,907 + 9,923 + 9,929 + 9,931 + 9,941, sum: 5,706,497

For primes up to twenty-five thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 2,759
7 + 11 + 13 + 17 + 19 + 23...24,967 + 24,971 + 24,977 + 24,979 + 24,989, sum: 32,405,707

For primes up to fifty thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 5,131
5 + 7 + 11 + 13 + 17 + 19...49,943 + 49,957 + 49,991 + 49,993 + 49,999, sum: 121,013,303

For primes up to one hundred thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 9,590
2 + 3 + 5 + 7 + 11 + 13...99,907 + 99,923 + 99,929 + 99,961 + 99,971, sum: 454,196,557

For primes up to two hundred fifty thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 22,041
7 + 11 + 13 + 17 + 19 + 23...249,947 + 249,967 + 249,971 + 249,973 + 249,989, sum: 2,623,031,141

For primes up to five hundred thousand:
Longest sequence of consecutive primes yielding a prime sum: elements: 41,530
2 + 3 + 5 + 7 + 11 + 13...499,801 + 499,819 + 499,853 + 499,879 + 499,883, sum: 9,910,236,647```

## Ring

```see "works..." + nl
limit = 100
Primes = []
OldPrimes = []
NewPrimes = []
for p = 1 to limit
if isPrime(p)
ok
next

lenPrimes = len(Primes)

for n = 1 to lenPrimes
num = 0
OldPrimes = []
for m = n to lenPrimes
num = num + Primes[m]
if isPrime(num)
if len(OldPrimes) > len(NewPrimes)
NewPrimes = OldPrimes
ok
ok
next
next

str = "["
for n = 1 to len(NewPrimes)
if n = len(NewPrimes)
str = str + newPrimes[n] + "]"
exit
ok
str = str + newPrimes[n] + ", "
next

sum = 0
strsum = ""
for n = 1 to len(NewPrimes)
sum = sum + newPrimes[n]
if n = len(NewPrimes)
strsum = strsum + newPrimes[n] + " = " + sum + " is prime number"
exit
ok
strsum = strsum + newPrimes[n] + " + "
next

see str + nl
see strsum + nl
see "The longest sequence of CalmoSoft primes = " + len(NewPrimes) + nl
see "done.." + nl

func isPrime num
if (num <= 1) return 0 ok
if (num % 2 = 0 and num != 2) return 0 ok
for i = 3 to floor(num / 2) -1 step 2
if (num % i = 0) return 0 ok
next
return 1```
Output:
```works...
[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89]
7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 + 37 + 41 + 43 + 47 + 53 + 59 + 61 + 67 + 71 + 73 + 79 + 83 + 89 = 953 is prime number
The longest sequence of CalmoSoft primes = 21
done..

```

## Wren

Library: Wren-math
Library: Wren-fmt

This runs in about 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.

```import "./math" for Int, Nums
import "./fmt"for Fmt

var max = 50000000
var primes = Int.primeSieve(max)

var calmoPrimes = Fn.new { |limit|
var pc = (limit < max) ? primes.count { |p| p <= limit } : primes.count
var sum = (limit < max) ? Nums.sum(primes.take(pc)) : Nums.sum(primes)
var longest = 0
var sIndices = []
var eIndices = []
var sums = []
for (i in 0...pc) {
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 ((temp % 2) == 0 != isEven) continue
if (Int.isPrime2(sum2)) {
if (temp > longest) {
longest = temp
sIndices = [i]
eIndices = [j]
sums = [sum2]
} else {
}
break
}
}
}
return [longest, sIndices, eIndices, sums]
}

for (limit in [100, 250, 5000, 10000, 500000, 50000000]) {
var res = calmoPrimes.call(limit)
var longest = res
var sIndices = res
var eIndices = res
var sums = res
Fmt.print("For primes up to \$,d the longest sequence(s) of CalmoSoft primes", limit)
Fmt.print("having a length of \$,d is/are:\n", longest)
for (i in 0...sIndices.count) {
var cp = primes[sIndices[i]..eIndices[i]]
var cps = Fmt.va("d", 1, cp, 0, " + ", "", "", 6, "..")
Fmt.print("\$s = \$,d", cps, sums[i])
}
System.print()
}
```
Output:
```For primes up to 100 the longest sequence(s) of CalmoSoft primes
having a length of 21 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 67 + 71 + 73 + 79 + 83 + 89 = 953

For primes up to 250 the longest sequence(s) of CalmoSoft primes
having a length of 49 is/are:

11 + 13 + 17 + 19 + 23 + 29 + .. + 223 + 227 + 229 + 233 + 239 + 241 = 5,813

For primes up to 5,000 the longest sequence(s) of CalmoSoft primes
having a length of 665 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 4957 + 4967 + 4969 + 4973 + 4987 + 4993 = 1,543,127

For primes up to 10,000 the longest sequence(s) of CalmoSoft primes
having a length of 1,223 is/are:

3 + 5 + 7 + 11 + 13 + 17 + .. + 9883 + 9887 + 9901 + 9907 + 9923 + 9929 = 5,686,633
7 + 11 + 13 + 17 + 19 + 23 + .. + 9901 + 9907 + 9923 + 9929 + 9931 + 9941 = 5,706,497

For primes up to 500,000 the longest sequence(s) of CalmoSoft primes
having a length of 41,530 is/are:

2 + 3 + 5 + 7 + 11 + 13 + .. + 499787 + 499801 + 499819 + 499853 + 499879 + 499883 = 9,910,236,647

For primes up to 50,000,000 the longest sequence(s) of CalmoSoft primes
having a length of 3,001,117 is/are:

7 + 11 + 13 + 17 + 19 + 23 + .. + 49999699 + 49999711 + 49999739 + 49999751 + 49999753 + 49999757 = 72,618,848,632,313
```

## XPL0

```include xpllib;                 \for IsPrime and Print

int Primes(100), PrimeSums(100);
[I:= 0;                         \make table of primes
for N:= 2 to 100-1 do
if IsPrime(N) then
[Primes(I):= N;  I:= I+1];
Size:= I;                       \make table of sums
PrimeSums(0):= Primes(0);
for I:= 1 to Size-1 do
PrimeSums(I):= PrimeSums(I-1) + Primes(I);
Longest:= 0;                    \find longest sequence
for Head:= Size-1 downto 0 do
for Tail:= 0 to Head do
[if IsPrime(Sum) then
SaveTail:= Tail;
];
];
Sum:= Sum - Primes(Tail);
];
];
Print( "The longest sequence of CalmoSoft primes < 100 is %d:\n", Longest+1);
Sum:= 0;
for I:= SaveTail to SaveHead do
[Sum:= Sum + Primes(I);
IntOut(0, Primes(I));
if I # SaveHead then ChOut(0, ^+);
];
Print(" = %d\n", Sum);
]```
Output:
```The longest sequence of CalmoSoft primes < 100 is 21:
7+11+13+17+19+23+29+31+37+41+43+47+53+59+61+67+71+73+79+83+89 = 953
```