Summarize primes

From Rosetta Code
Task
Summarize primes
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Considering in order of length, n, all sequences of consecutive primes, p, from 2 onwards, where p < 1000 and n>0, select those sequences whose sum is prime, and for these display the length of the sequence, the last item in the sequence, and the sum.

11l

Translation of: Nim
F is_prime(a)
   I a == 2
      R 1B
   I a < 2 | a % 2 == 0
      R 0B
   L(i) (3 .. Int(sqrt(a))).step(2)
      I a % i == 0
         R 0B
   R 1B

print(‘index  prime  prime sum’)
V s = 0
V idx = 0
L(n) 2..999
   I is_prime(n)
      idx++
      s += n
      I is_prime(s)
         print(f:‘{idx:3}   {n:5}   {s:7}’)
Output:
index  prime  prime sum
  1       2         2
  2       3         5
  4       7        17
  6      13        41
 12      37       197
 14      43       281
 60     281      7699
 64     311      8893
 96     503     22039
100     541     24133
102     557     25237
108     593     28697
114     619     32353
122     673     37561
124     683     38921
130     733     43201
132     743     44683
146     839     55837
152     881     61027
158     929     66463
162     953     70241

ALGOL 68

BEGIN # sum the primes below n and report the sums that are prime             #
    # sieve the primes to 999 #
    PR read "primes.incl.a68" PR
    []BOOL prime = PRIMESIEVE 999;
    # sum the primes and test the sum                                         #
    INT prime sum       := 0;
    INT prime count     := 0;
    INT prime sum count := 0;
    print( ( "prime         prime", newline ) );
    print( ( "count  prime    sum", newline ) );
    FOR i TO UPB prime DO
        IF prime[ i ] THEN
            # have another prime                                              #
            prime count  +:= 1;
            prime sum    +:= i;
            # check whether the prime sum is prime or not                     #
            BOOL is prime := TRUE;
            FOR p TO i OVER 2 WHILE is prime DO
                IF prime[ p ] THEN is prime := prime sum MOD p /= 0 FI
            OD;
            IF is prime THEN
                # the prime sum is also prime                                 #
                prime sum count +:= 1;
                print( ( whole( prime count, -5 )
                       , " "
                       , whole( i,           -6 )
                       , " "
                       , whole( prime sum,   -6 )
                       , newline
                       )
                     )
            FI
        FI
    OD;
    print( ( newline
           , "Found "
           , whole( prime sum count, 0 )
           , " prime sums of primes below "
           , whole( UPB prime + 1, 0 )
           , newline
           )
         )
END
Output:
prime         prime
count  prime    sum
    1      2      2
    2      3      5
    4      7     17
    6     13     41
   12     37    197
   14     43    281
   60    281   7699
   64    311   8893
   96    503  22039
  100    541  24133
  102    557  25237
  108    593  28697
  114    619  32353
  122    673  37561
  124    683  38921
  130    733  43201
  132    743  44683
  146    839  55837
  152    881  61027
  158    929  66463
  162    953  70241

Found 21 prime sums of primes below 1000

ALGOL W

begin % sum the primes below n and report the sums that are prime             %
    integer MAX_NUMBER;
    MAX_NUMBER := 999;
    begin
        logical array prime( 1 :: MAX_NUMBER );
        integer       primeCount, primeSum, primeSumCount;
        % sieve the primes to MAX_NUMBER                                      %
        prime( 1 ) := false; prime( 2 ) := true;
        for i := 3 step 2 until MAX_NUMBER do prime( i ) := true;
        for i := 4 step 2 until MAX_NUMBER do prime( i ) := false;
        for i := 3 step 2 until truncate( sqrt( MAX_NUMBER ) ) do begin
            integer ii; ii := i + i;
            if prime( i ) then begin
                for p := i * i step ii until MAX_NUMBER do prime( p ) := false
            end if_prime_i
        end for_i ;
        % find the prime sums that are prime                                  %
        primeCount := primeSum := primeSumCount := 0;
        write( "prime  prime" );
        write( "count    sum" );
        for i := 1 until MAX_NUMBER do begin
            if prime( i ) then begin
                % have another prime                                          %
                logical isPrime;
                primeSum   := primeSum + i;
                primeCount := primeCount + 1;
                % check whether the prime sum is also prime                   %
                isPrime := true;
                for p := 1 until i div 2 do begin
                    if prime( p ) then begin
                        isPrime := primeSum rem p not = 0;
                        if not isPrime then goto endPrimeCheck
                    end if_prime_p
                end for_p ;
endPrimeCheck:
                if isPrime then begin
                    % the prime sum is also prime                             %
                    primeSumCount := primeSumCount + 1;
                    write( i_w := 5, s_w := 0
                         , primeCount
                         , " "
                         , i_w := 6
                         , primeSum
                         )
                end if_isPrime
            end if_prime_i
        end for_i ;
        write();
        write( i_w := 1, s_w := 0
             , "Found "
             , primeSumCount
             , " prime sums of primes below "
             , MAX_NUMBER + 1
             )
    end
end.
Output:
prime  prime
count    sum
    1      2
    2      5
    4     17
    6     41
   12    197
   14    281
   60   7699
   64   8893
   96  22039
  100  24133
  102  25237
  108  28697
  114  32353
  122  37561
  124  38921
  130  43201
  132  44683
  146  55837
  152  61027
  158  66463
  162  70241

Found 21 prime sums of primes below 1000

Arturo

print (pad "index" 6) ++ " | " ++
      (pad "prime" 6) ++ " | " ++
      (pad "prime sum" 11)
print "------------------------------"

s: 0
idx: 0
loop 2..999 'n [
    if prime? n [
        idx: idx + 1
        s: s + n
        if prime? s ->
            print (pad to :string idx 6) ++ " | " ++
                  (pad to :string n 6) ++ " | " ++
                  (pad to :string s 11)
    ]
]
Output:
 index |  prime |   prime sum
------------------------------
     1 |      2 |           2
     2 |      3 |           5
     4 |      7 |          17
     6 |     13 |          41
    12 |     37 |         197
    14 |     43 |         281
    60 |    281 |        7699
    64 |    311 |        8893
    96 |    503 |       22039
   100 |    541 |       24133
   102 |    557 |       25237
   108 |    593 |       28697
   114 |    619 |       32353
   122 |    673 |       37561
   124 |    683 |       38921
   130 |    733 |       43201
   132 |    743 |       44683
   146 |    839 |       55837
   152 |    881 |       61027
   158 |    929 |       66463
   162 |    953 |       70241

AWK

# syntax: GAWK -f SUMMARIZE_PRIMES.AWK
BEGIN {
    start = 1
    stop = 999
    for (i=start; i<=stop; i++) {
      if (is_prime(i)) {
        count1++
        sum += i
        if (is_prime(sum)) {
          printf("the sum of %3d primes from primes 2-%-3s is %5d which is also prime\n",count1,i,sum)
          count2++
        }
      }
    }
    printf("Summarized primes %d-%d: %d\n",start,stop,count2)
    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)
}
Output:
the sum of   1 primes from primes 2-2   is     2 which is also prime
the sum of   2 primes from primes 2-3   is     5 which is also prime
the sum of   4 primes from primes 2-7   is    17 which is also prime
the sum of   6 primes from primes 2-13  is    41 which is also prime
the sum of  12 primes from primes 2-37  is   197 which is also prime
the sum of  14 primes from primes 2-43  is   281 which is also prime
the sum of  60 primes from primes 2-281 is  7699 which is also prime
the sum of  64 primes from primes 2-311 is  8893 which is also prime
the sum of  96 primes from primes 2-503 is 22039 which is also prime
the sum of 100 primes from primes 2-541 is 24133 which is also prime
the sum of 102 primes from primes 2-557 is 25237 which is also prime
the sum of 108 primes from primes 2-593 is 28697 which is also prime
the sum of 114 primes from primes 2-619 is 32353 which is also prime
the sum of 122 primes from primes 2-673 is 37561 which is also prime
the sum of 124 primes from primes 2-683 is 38921 which is also prime
the sum of 130 primes from primes 2-733 is 43201 which is also prime
the sum of 132 primes from primes 2-743 is 44683 which is also prime
the sum of 146 primes from primes 2-839 is 55837 which is also prime
the sum of 152 primes from primes 2-881 is 61027 which is also prime
the sum of 158 primes from primes 2-929 is 66463 which is also prime
the sum of 162 primes from primes 2-953 is 70241 which is also prime
Summarized primes 1-999: 21

BASIC

BASIC256

#include "isprime.kbs"

print 1, 2, 2
sum = 2
n = 1
for i = 3 to 999 step 2
	if isPrime(i) then
		sum += i
		n += 1
		if isPrime(sum) then
			print n, i, sum
		end if
	end if
next i
Output:
Same as FreeBASIC entry.

FreeBASIC

#include "isprime.bas"

print 1,2,2
dim as integer sum = 2, i, n=1
for i = 3 to 999 step 2
    if isprime(i) then
        sum += i
        n+=1
        if isprime(sum) then
            print n, i, sum
        end if
    end if
next i
Output:
 1             2             2
 2             3             5
 4             7             17
 6             13            41
 12            37            197
 14            43            281
 60            281           7699
 64            311           8893
 96            503           22039
 100           541           24133
 102           557           25237
 108           593           28697
 114           619           32353
 122           673           37561
 124           683           38921
 130           733           43201
 132           743           44683
 146           839           55837
 152           881           61027
 158           929           66463
 162           953           70241

Gambas

Use "isprime.bas"

Public Sub Main() 
  
  Print 1, 2, 2 
  Dim n As Integer = 1, i As Integer, sum As Integer = 2 
  For i = 3 To 999 Step 2 
    If isPrime(i) Then 
      sum += i 
      n += 1 
      If isPrime(sum) Then 
        Print n, i, sum 
      End If 
    End If 
  Next  

End
Output:
Same as FreeBASIC entry.

PureBasic

;XIncludeFile "isprime.pb"

OpenConsole()
Define.i sum, i, n
PrintN("1" + #TAB$ +  "2" + #TAB$ + "2")
sum = 2
n = 1
For i = 3 To 999 Step 2
  If isPrime(i):
    sum + i
    n + 1
    If isPrime(sum):
      PrintN(Str(n) + #TAB$ +  Str(i) + #TAB$ + Str(sum))
    EndIf
  EndIf
Next i

Input()
CloseConsole()
Output:
Same as FreeBASIC entry.

Yabasic

//import isprime
print 1, chr$(9), 2, chr$(9), 2
sum = 2
n = 1
for i = 3 to 999 step 2
    if isPrime(i) then
        sum = sum + i
        n = n + 1
        if isPrime(sum)  print n, chr$(9), i, chr$(9), sum
    fi
next i
end
Output:
Same as FreeBASIC entry.

C

Translation of: C++
#include <stdbool.h>
#include <stdio.h>

bool is_prime(int n) {
    int i = 5;

    if (n < 2) {
        return false;
    }

    if (n % 2 == 0) {
        return n == 2;
    }
    if (n % 3 == 0) {
        return n == 3;
    }

    while (i * i <= n) {
        if (n % i == 0) {
            return false;
        }
        i += 2;

        if (n % i == 0) {
            return false;
        }
        i += 4;
    }

    return true;
}

int main() {
    const int start = 1;
    const int stop = 1000;

    int sum = 0;
    int count = 0;
    int sc = 0;
    int p;

    for (p = start; p < stop; p++) {
        if (is_prime(p)) {
            count++;
            sum += p;
            if (is_prime(sum)) {
                printf("The sum of %3d primes in [2, %3d] is %5d which is also prime\n", count, p, sum);
                sc++;
            }
        }
    }
    printf("There are %d summerized primes in [%d, %d)\n", sc, start, stop);

    return 0;
}
Output:
The sum of   1 primes in [2,   2] is     2 which is also prime
The sum of   2 primes in [2,   3] is     5 which is also prime
The sum of   4 primes in [2,   7] is    17 which is also prime
The sum of   6 primes in [2,  13] is    41 which is also prime
The sum of  12 primes in [2,  37] is   197 which is also prime
The sum of  14 primes in [2,  43] is   281 which is also prime
The sum of  60 primes in [2, 281] is  7699 which is also prime
The sum of  64 primes in [2, 311] is  8893 which is also prime
The sum of  96 primes in [2, 503] is 22039 which is also prime
The sum of 100 primes in [2, 541] is 24133 which is also prime
The sum of 102 primes in [2, 557] is 25237 which is also prime
The sum of 108 primes in [2, 593] is 28697 which is also prime
The sum of 114 primes in [2, 619] is 32353 which is also prime
The sum of 122 primes in [2, 673] is 37561 which is also prime
The sum of 124 primes in [2, 683] is 38921 which is also prime
The sum of 130 primes in [2, 733] is 43201 which is also prime
The sum of 132 primes in [2, 743] is 44683 which is also prime
The sum of 146 primes in [2, 839] is 55837 which is also prime
The sum of 152 primes in [2, 881] is 61027 which is also prime
The sum of 158 primes in [2, 929] is 66463 which is also prime
The sum of 162 primes in [2, 953] is 70241 which is also prime
There are 21 summerized primes in [1, 1000)

C++

#include <iostream>

bool is_prime(int n) {
    if (n < 2) {
        return false;
    }

    if (n % 2 == 0) {
        return n == 2;
    }
    if (n % 3 == 0) {
        return n == 3;
    }

    int i = 5;
    while (i * i <= n) {
        if (n % i == 0) {
            return false;
        }
        i += 2;

        if (n % i == 0) {
            return false;
        }
        i += 4;
    }

    return true;
}

int main() {
    const int start = 1;
    const int stop = 1000;

    int sum = 0;
    int count = 0;
    int sc = 0;

    for (int p = start; p < stop; p++) {
        if (is_prime(p)) {
            count++;
            sum += p;
            if (is_prime(sum)) {
                printf("The sum of %3d primes in [2, %3d] is %5d which is also prime\n", count, p, sum);
                sc++;
            }
        }
    }
    printf("There are %d summerized primes in [%d, %d)\n", sc, start, stop);

    return 0;
}
Output:
The sum of   1 primes in [2,   2] is     2 which is also prime
The sum of   2 primes in [2,   3] is     5 which is also prime
The sum of   4 primes in [2,   7] is    17 which is also prime
The sum of   6 primes in [2,  13] is    41 which is also prime
The sum of  12 primes in [2,  37] is   197 which is also prime
The sum of  14 primes in [2,  43] is   281 which is also prime
The sum of  60 primes in [2, 281] is  7699 which is also prime
The sum of  64 primes in [2, 311] is  8893 which is also prime
The sum of  96 primes in [2, 503] is 22039 which is also prime
The sum of 100 primes in [2, 541] is 24133 which is also prime
The sum of 102 primes in [2, 557] is 25237 which is also prime
The sum of 108 primes in [2, 593] is 28697 which is also prime
The sum of 114 primes in [2, 619] is 32353 which is also prime
The sum of 122 primes in [2, 673] is 37561 which is also prime
The sum of 124 primes in [2, 683] is 38921 which is also prime
The sum of 130 primes in [2, 733] is 43201 which is also prime
The sum of 132 primes in [2, 743] is 44683 which is also prime
The sum of 146 primes in [2, 839] is 55837 which is also prime
The sum of 152 primes in [2, 881] is 61027 which is also prime
The sum of 158 primes in [2, 929] is 66463 which is also prime
The sum of 162 primes in [2, 953] is 70241 which is also prime
There are 21 summerized primes in [1, 1000)

Delphi

Works with: Delphi version 6.0

Uses the Delphi Prime-Generator Object


procedure SumOfPrimeSequences(Memo: TMemo);
var Sieve: TPrimeSieve;
var I,Inx, Sum: integer;
begin
Sieve:=TPrimeSieve.Create;
try
Sieve.Intialize(100000);
Memo.Lines.Add('  I  P(I)   Sum');
Memo.Lines.Add('---------------');
I:=0;
Sum:=0;
while Sieve.Primes[I]<1000 do
	begin
	Sum:=Sum+Sieve.Primes[I];
	if Sieve.Flags[Sum] then
		begin
		Memo.Lines.Add(Format('%3d %4d %6d',[I,Sieve.Primes[I],Sum]));
		end;
	Inc(I,1);
	end;

finally Sieve.Free; end;
end;
Output:
  I  P(I)   Sum
---------------
  0    2      2
  1    3      5
  3    7     17
  5   13     41
 11   37    197
 13   43    281
 59  281   7699
 63  311   8893
 95  503  22039
 99  541  24133
101  557  25237
107  593  28697
113  619  32353
121  673  37561
123  683  38921
129  733  43201
131  743  44683
145  839  55837
151  881  61027
157  929  66463
161  953  70241

Elapsed Time: 31.759 ms.

EasyLang

func prime n .
   if n mod 2 = 0 and n > 2
      return 0
   .
   i = 3
   while i <= sqrt n
      if n mod i = 0
         return 0
      .
      i += 2
   .
   return 1
.
for i = 2 to 999
   if prime i = 1
      ind += 1
      sum += i
      if prime sum = 1
         print ind & ": " & sum
      .
   .
.

F#

This task uses Extensible Prime Generator (F#)

// Summarize Primes: Nigel Galloway. April 16th., 2021
primes32()|>Seq.takeWhile((>)1000)|>Seq.scan(fun(n,g) p->(n+1,g+p))(0,0)|>Seq.filter(snd>>isPrime)|>Seq.iter(fun(n,g)->printfn "%3d->%d" n g)
Output:
  1->2
  2->5
  4->17
  6->41
 12->197
 14->281
 60->7699
 64->8893
 96->22039
100->24133
102->25237
108->28697
114->32353
122->37561
124->38921
130->43201
132->44683
146->55837
152->61027
158->66463
162->70241
Real: 00:00:00.015

Factor

Works with: Factor version 0.99 2021-02-05
USING: assocs formatting kernel math.primes math.ranges
math.statistics prettyprint ;

1000 [ [1,b] ] [ primes-upto cum-sum ] bi zip
[ nip prime? ] assoc-filter
[ "The sum of the first  %3d  primes is  %5d  (which is prime).\n" printf ] assoc-each
Output:
The sum of the first    1  primes is      2  (which is prime).
The sum of the first    2  primes is      5  (which is prime).
The sum of the first    4  primes is     17  (which is prime).
The sum of the first    6  primes is     41  (which is prime).
The sum of the first   12  primes is    197  (which is prime).
The sum of the first   14  primes is    281  (which is prime).
The sum of the first   60  primes is   7699  (which is prime).
The sum of the first   64  primes is   8893  (which is prime).
The sum of the first   96  primes is  22039  (which is prime).
The sum of the first  100  primes is  24133  (which is prime).
The sum of the first  102  primes is  25237  (which is prime).
The sum of the first  108  primes is  28697  (which is prime).
The sum of the first  114  primes is  32353  (which is prime).
The sum of the first  122  primes is  37561  (which is prime).
The sum of the first  124  primes is  38921  (which is prime).
The sum of the first  130  primes is  43201  (which is prime).
The sum of the first  132  primes is  44683  (which is prime).
The sum of the first  146  primes is  55837  (which is prime).
The sum of the first  152  primes is  61027  (which is prime).
The sum of the first  158  primes is  66463  (which is prime).
The sum of the first  162  primes is  70241  (which is prime).

Fermat

n:=0
s:=0
for i=1, 162 do s:=s+Prime(i);if Isprime(s)=1 then n:=n+1;!!(n,Prime(i),s) fi od
Output:
 1 2 2
 2 3 5
 3 7 17
 4 13 41
 5 37 197
 6 43 281
 7 281 7699
 8 311 8893
 9 503 22039
 10 541 24133
 11 557 25237
 12 593 28697
 13 619 32353
 14 673 37561
 15 683 38921
 16 733 43201
 17 743 44683
 18 839 55837
 19 881 61027
 20 929 66463
 21 953 70241

Forth

Works with: Gforth
: prime? ( n -- flag )
  dup 2 < if drop false exit then
  dup 2 mod 0= if 2 = exit then
  dup 3 mod 0= if 3 = exit then
  5
  begin
    2dup dup * >=
  while
    2dup mod 0= if 2drop false exit then
    2 +
    2dup mod 0= if 2drop false exit then
    4 +
  repeat
  2drop true ;

: main
  0 0 { count sum }
  ." count  prime      sum" cr
  1000 2 do
    i prime? if
      count 1+ to count
      sum i + to sum
      sum prime? if
        ."   " count 3 .r ."     " i 3 .r ."     " sum 5 .r cr
      then
    then
  loop ;

main
bye
Output:
count  prime      sum
    1      2        2
    2      3        5
    4      7       17
    6     13       41
   12     37      197
   14     43      281
   60    281     7699
   64    311     8893
   96    503    22039
  100    541    24133
  102    557    25237
  108    593    28697
  114    619    32353
  122    673    37561
  124    683    38921
  130    733    43201
  132    743    44683
  146    839    55837
  152    881    61027
  158    929    66463
  162    953    70241

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website.

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Solution

File:Fōrmulæ - Summarize primes 01.png

File:Fōrmulæ - Summarize primes 02.png

Go

Translation of: Wren
Library: Go-rcu
package main

import (
    "fmt"
    "rcu"
)

func main() {
    primes := rcu.Primes(999)
    sum, n, c := 0, 0, 0
    fmt.Println("Summing the first n primes (<1,000) where the sum is itself prime:")
    fmt.Println("  n  cumulative sum")
    for _, p := range primes {
        n++
        sum += p
        if rcu.IsPrime(sum) {
            c++
            fmt.Printf("%3d   %6s\n", n, rcu.Commatize(sum))
        }
    }
    fmt.Println()
    fmt.Println(c, "such prime sums found")
}
Output:
Same as Wren example.

Haskell

import Data.List (scanl)
import Data.Numbers.Primes (isPrime, primes)

--------------- PRIME SUMS OF FIRST N PRIMES -------------

indexedPrimeSums :: [(Integer, Integer, Integer)]
indexedPrimeSums =
  filter (\(_, _, n) -> isPrime n) $
    scanl
      (\(i, _, m) p -> (succ i, p, p + m))
      (0, 0, 0)
      primes

--------------------------- TEST -------------------------
main :: IO ()
main =
  mapM_ print $
    takeWhile (\(_, p, _) -> 1000 > p) indexedPrimeSums
Output:
(1,2,2)
(2,3,5)
(4,7,17)
(6,13,41)
(12,37,197)
(14,43,281)
(60,281,7699)
(64,311,8893)
(96,503,22039)
(100,541,24133)
(102,557,25237)
(108,593,28697)
(114,619,32353)
(122,673,37561)
(124,683,38921)
(130,733,43201)
(132,743,44683)
(146,839,55837)
(152,881,61027)
(158,929,66463)
(162,953,70241)

J

primes=: p: i. _1 p: 1000   NB. all prime numbers below 1000 
sums=: +/\ primes           NB. running sum of those primes 
mask=: 1 p: sums            NB. array of 0s, 1s where sums are primes 

NB. indices of prime sums (incremented for 1-based indexing)
NB. "copy" only the final primes in the prime sums
NB. "copy" only the sums which are prime 
results=: (>: I. mask) ,. (mask # primes) ,. (mask # sums)

NB. pretty-printed "boxed" output 
output=: 2 1 $ ' n prime sum ' ; < results
Output:
   output
┌─────────────┐
│ n prime sum │
├─────────────┤
│  1   2     2│
│  2   3     5│
│  4   7    17│
│  6  13    41│
│ 12  37   197│
│ 14  43   281│
│ 60 281  7699│
│ 64 311  8893│
│ 96 503 22039│
│100 541 24133│
│102 557 25237│
│108 593 28697│
│114 619 32353│
│122 673 37561│
│124 683 38921│
│130 733 43201│
│132 743 44683│
│146 839 55837│
│152 881 61027│
│158 929 66463│
│162 953 70241│
└─────────────┘

jq

Works with: jq

Works with gojq, the Go implementation of jq

def is_prime:
  . as $n
  | if ($n < 2)         then false
    elif ($n % 2 == 0)  then $n == 2
    elif ($n % 3 == 0)  then $n == 3
    elif ($n % 5 == 0)  then $n == 5
    elif ($n % 7 == 0)  then $n == 7
    elif ($n % 11 == 0) then $n == 11
    elif ($n % 13 == 0) then $n == 13
    elif ($n % 17 == 0) then $n == 17
    elif ($n % 19 == 0) then $n == 19
    else {i:23}
         | until( (.i * .i) > $n or ($n % .i == 0); .i += 2)
	 | .i * .i > $n
    end;

# primes up to but excluding $n
def primes($n): [range(2;$n) | select(is_prime)];

"Prime sums of primes less than 1000",
(primes(1000)
 | range(1; length) as $n
 | (.[: $n] | add) as $sum
 | select($sum | is_prime)
 | "The sum of the \($n) primes from 2 to \(.[$n-1]) is \($sum)." )
Output:
Prime sums of primes less than 1000
The sum of the 1 primes from 2 to 2 is 2.
The sum of the 2 primes from 2 to 3 is 5.
The sum of the 4 primes from 2 to 7 is 17.
The sum of the 6 primes from 2 to 13 is 41.
The sum of the 12 primes from 2 to 37 is 197.
The sum of the 14 primes from 2 to 43 is 281.
The sum of the 60 primes from 2 to 281 is 7699.
The sum of the 64 primes from 2 to 311 is 8893.
The sum of the 96 primes from 2 to 503 is 22039.
The sum of the 100 primes from 2 to 541 is 24133.
The sum of the 102 primes from 2 to 557 is 25237.
The sum of the 108 primes from 2 to 593 is 28697.
The sum of the 114 primes from 2 to 619 is 32353.
The sum of the 122 primes from 2 to 673 is 37561.
The sum of the 124 primes from 2 to 683 is 38921.
The sum of the 130 primes from 2 to 733 is 43201.
The sum of the 132 primes from 2 to 743 is 44683.
The sum of the 146 primes from 2 to 839 is 55837.
The sum of the 152 primes from 2 to 881 is 61027.
The sum of the 158 primes from 2 to 929 is 66463.
The sum of the 162 primes from 2 to 953 is 70241.

Julia

using Primes

p1000 = primes(1000)

for n in 1:length(p1000)
    parray = p1000[1:n]
    sparray = sum(parray)
    if isprime(sparray)
        println("The sum of the $n primes from prime 2 to prime $(p1000[n]) is $sparray, which is prime.")
    end
end
Output:
The sum of the 1 primes from prime 2 to prime 2 is 2, which is prime.
The sum of the 2 primes from prime 2 to prime 3 is 5, which is prime.
The sum of the 4 primes from prime 2 to prime 7 is 17, which is prime.
The sum of the 6 primes from prime 2 to prime 13 is 41, which is prime.
The sum of the 12 primes from prime 2 to prime 37 is 197, which is prime.
The sum of the 14 primes from prime 2 to prime 43 is 281, which is prime.
The sum of the 60 primes from prime 2 to prime 281 is 7699, which is prime.
The sum of the 64 primes from prime 2 to prime 311 is 8893, which is prime.
The sum of the 96 primes from prime 2 to prime 503 is 22039, which is prime.
The sum of the 100 primes from prime 2 to prime 541 is 24133, which is prime.
The sum of the 102 primes from prime 2 to prime 557 is 25237, which is prime.
The sum of the 108 primes from prime 2 to prime 593 is 28697, which is prime.
The sum of the 114 primes from prime 2 to prime 619 is 32353, which is prime.
The sum of the 122 primes from prime 2 to prime 673 is 37561, which is prime.
The sum of the 124 primes from prime 2 to prime 683 is 38921, which is prime.
The sum of the 130 primes from prime 2 to prime 733 is 43201, which is prime.
The sum of the 132 primes from prime 2 to prime 743 is 44683, which is prime.
The sum of the 146 primes from prime 2 to prime 839 is 55837, which is prime.
The sum of the 152 primes from prime 2 to prime 881 is 61027, which is prime.
The sum of the 158 primes from prime 2 to prime 929 is 66463, which is prime.
The sum of the 162 primes from prime 2 to prime 953 is 70241, which is prime.

Mathematica/Wolfram Language

p = Prime[Range[PrimePi[1000]]];
TableForm[
 Select[Transpose[{Range[Length[p]], p, Accumulate[p]}], Last /* PrimeQ], 
 TableHeadings -> {None, {"Prime count", "Prime", "Prime sum"}}
]
Output:
Prime count	Prime	Prime sum
1		2	2
2		3	5
4		7	17
6		13	41
12		37	197
14		43	281
60		281	7699
64		311	8893
96		503	22039
100		541	24133
102		557	25237
108		593	28697
114		619	32353
122		673	37561
124		683	38921
130		733	43201
132		743	44683
146		839	55837
152		881	61027
158		929	66463
162		953	70241

Nim

import math, strformat

const N = 999

func isPrime(n: Positive): bool =
  if (n and 1) == 0: return n == 2
  if (n mod 3) == 0: return n == 3
  var d = 5
  var delta = 2
  while d <= sqrt(n.toFloat).int:
    if n mod d == 0: return false
    inc d, delta
    delta = 6 - delta
  result = true

echo "index  prime  prime sum"
var s = 0
var idx = 0
for n in 2..N:
  if n.isPrime:
    inc idx
    s += n
    if s.isPrime: echo &"{idx:3}   {n:5}   {s:7}"
Output:
index  prime  prime sum
  1       2         2
  2       3         5
  4       7        17
  6      13        41
 12      37       197
 14      43       281
 60     281      7699
 64     311      8893
 96     503     22039
100     541     24133
102     557     25237
108     593     28697
114     619     32353
122     673     37561
124     683     38921
130     733     43201
132     743     44683
146     839     55837
152     881     61027
158     929     66463
162     953     70241

Perl

Library: ntheory
use strict;
use warnings;
use ntheory <nth_prime is_prime>;

my($n, $s, $limit, @sums) = (0, 0, 1000);
do {
    push @sums, sprintf '%3d %8d', $n, $s if is_prime($s += nth_prime ++$n)
} until $n >= $limit;

print "Of the first $limit primes: @{[scalar @sums]} cumulative prime sums:\n", join "\n", @sums;
Output:
Of the first 1000 primes: 76 cumulative prime sums:
  1        2
  2        5
  4       17
  6       41
 12      197
 14      281
 60     7699
 64     8893
 96    22039
100    24133
102    25237
108    28697
114    32353
122    37561
124    38921
130    43201
132    44683
146    55837
152    61027
158    66463
162    70241
178    86453
192   102001
198   109147
204   116533
206   119069
208   121631
214   129419
216   132059
296   263171
308   287137
326   325019
328   329401
330   333821
332   338279
334   342761
342   360979
350   379667
350   379667
356   393961
358   398771
426   581921
446   642869
458   681257
460   687767
464   700897
480   754573
484   768373
488   782263
512   868151
530   935507
536   958577
548  1005551
568  1086557
620  1313041
630  1359329
676  1583293
680  1603597
696  1686239
708  1749833
734  1891889
762  2051167
768  2086159
776  2133121
780  2156813
784  2180741
808  2327399
814  2364833
820  2402537
836  2504323
844  2556187
848  2582401
852  2608699
926  3120833
942  3238237
984  3557303
992  3619807

Phix

function sp(integer n) return is_prime(sum(get_primes(-n))) end function
sequence res = apply(filter(tagset(length(get_primes_le(1000))),sp),sprint)
printf(1,"Found %d of em: %s\n",{length(res),join(shorten(res,"",5),", ")})
Output:
Found 21 of em: 1, 2, 4, 6, 12, ..., 132, 146, 152, 158, 162

Prolog

works with swi-prolog

isPrime(2).
isPrime(N):-
	between(3, inf, N),
	N /\ 1 > 0,             % odd
	M is floor(sqrt(N)) - 1, % reverse 2*I+1
	Max is M div 2,
	forall(between(1, Max, I), N mod (2*I+1) > 0).

primeSum([], _, _, []).
primeSum([P|PList], Index, Acc, [Index|CList]):-
	Sum is Acc + P,
	isPrime(Sum),!,
	format('~|~t~d~3+  ~|~t~d~3+  ~|~t~d~5+', [Index, P, Sum]),nl,
	Index1 is Index + 1,
	primeSum(PList, Index1, Sum, CList).
primeSum([P|PList], Index, Acc, CntList):-
	Index1 is Index + 1,
	Sum is Acc + P,
	primeSum(PList, Index1, Sum, CntList).

do:-Limit is 1000,
	numlist(1, Limit, List),
	include(isPrime, List, PrimeList),
	primeSum(PrimeList, 1, 0, CntList),
	length(CntList, Number),
	format('~nfound ~d such primes~n', [Number]).
Output:
?- do.
  1    2      2
  2    3      5
  4    7     17
  6   13     41
 12   37    197
 14   43    281
 60  281   7699
 64  311   8893
 96  503  22039
100  541  24133
102  557  25237
108  593  28697
114  619  32353
122  673  37561
124  683  38921
130  733  43201
132  743  44683
146  839  55837
152  881  61027
158  929  66463
162  953  70241

found 21 such primes

Python

'''Prime sums of primes up to 1000'''


from itertools import accumulate, chain, takewhile


# primeSums :: [(Int, (Int, Int))]
def primeSums():
    '''Non finite stream of enumerated tuples,
       in which the first value is a prime,
       and the second the sum of that prime and all
       preceding primes.
    '''
    return (
        x for x in enumerate(
            accumulate(
                chain([(0, 0)], primes()),
                lambda a, p: (p, p + a[1])
            )
        ) if isPrime(x[1][1])
    )


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Prime sums of primes below 1000'''
    for x in takewhile(
            lambda t: 1000 > t[1][0],
            primeSums()
    ):
        print(f'{x[0]} -> {x[1][1]}')


# ----------------------- GENERIC ------------------------

# isPrime :: Int -> Bool
def isPrime(n):
    '''True if n is prime.'''
    if n in (2, 3):
        return True
    if 2 > n or 0 == n % 2:
        return False
    if 9 > n:
        return True
    if 0 == n % 3:
        return False

    def p(x):
        return 0 == n % x or 0 == n % (2 + x)

    return not any(map(p, range(5, 1 + int(n ** 0.5), 6)))


# primes :: [Int]
def primes():
    ''' Non finite sequence of prime numbers.
    '''
    n = 2
    dct = {}
    while True:
        if n in dct:
            for p in dct[n]:
                dct.setdefault(n + p, []).append(p)
            del dct[n]
        else:
            yield n
            dct[n * n] = [n]
        n = 1 + n


# MAIN ---
if __name__ == '__main__':
    main()
Output:
1 -> 2
2 -> 5
4 -> 17
6 -> 41
12 -> 197
14 -> 281
60 -> 7699
64 -> 8893
96 -> 22039
100 -> 24133
102 -> 25237
108 -> 28697
114 -> 32353
122 -> 37561
124 -> 38921
130 -> 43201
132 -> 44683
146 -> 55837
152 -> 61027
158 -> 66463
162 -> 70241

Quackery

isprime is defined at Primality by trial division#Quackery.

  [ number$
    space 6 of swap join
    -7 split nip echo$ ]    is rjust   (   n -->   )

  say "  index  prime    sum" cr
  say "  -----  -----    ---" cr
  [] 1000 times
    [ i^ isprime if [ i^ join ] ]
  0 swap
  witheach
    [ dup dip +
      over isprime iff
        [ i^ 1+ rjust
          rjust
          dup rjust
          cr ]
      else drop ]
  drop
Output:
  index  prime    sum
  -----  -----    ---
      1      2      2
      2      3      5
      4      7     17
      6     13     41
     12     37    197
     14     43    281
     60    281   7699
     64    311   8893
     96    503  22039
    100    541  24133
    102    557  25237
    108    593  28697
    114    619  32353
    122    673  37561
    124    683  38921
    130    733  43201
    132    743  44683
    146    839  55837
    152    881  61027
    158    929  66463
    162    953  70241

Raku

use Lingua::EN::Numbers;

my @primes    = grep *.is-prime, ^Inf;
my @primesums = [\+] @primes;
say "{.elems} cumulative prime sums:\n",
    .map( -> $p {
        sprintf "The sum of the first %3d (up to {@primes[$p]}) is prime: %s",
        1 + $p, comma @primesums[$p]
      }
    ).join("\n")
    given grep { @primesums[$_].is-prime }, ^1000;
Output:
76 cumulative prime sums:
The sum of the first   1 (up to 2) is prime: 2
The sum of the first   2 (up to 3) is prime: 5
The sum of the first   4 (up to 7) is prime: 17
The sum of the first   6 (up to 13) is prime: 41
The sum of the first  12 (up to 37) is prime: 197
The sum of the first  14 (up to 43) is prime: 281
The sum of the first  60 (up to 281) is prime: 7,699
The sum of the first  64 (up to 311) is prime: 8,893
The sum of the first  96 (up to 503) is prime: 22,039
The sum of the first 100 (up to 541) is prime: 24,133
The sum of the first 102 (up to 557) is prime: 25,237
The sum of the first 108 (up to 593) is prime: 28,697
The sum of the first 114 (up to 619) is prime: 32,353
The sum of the first 122 (up to 673) is prime: 37,561
The sum of the first 124 (up to 683) is prime: 38,921
The sum of the first 130 (up to 733) is prime: 43,201
The sum of the first 132 (up to 743) is prime: 44,683
The sum of the first 146 (up to 839) is prime: 55,837
The sum of the first 152 (up to 881) is prime: 61,027
The sum of the first 158 (up to 929) is prime: 66,463
The sum of the first 162 (up to 953) is prime: 70,241
The sum of the first 178 (up to 1061) is prime: 86,453
The sum of the first 192 (up to 1163) is prime: 102,001
The sum of the first 198 (up to 1213) is prime: 109,147
The sum of the first 204 (up to 1249) is prime: 116,533
The sum of the first 206 (up to 1277) is prime: 119,069
The sum of the first 208 (up to 1283) is prime: 121,631
The sum of the first 214 (up to 1307) is prime: 129,419
The sum of the first 216 (up to 1321) is prime: 132,059
The sum of the first 296 (up to 1949) is prime: 263,171
The sum of the first 308 (up to 2029) is prime: 287,137
The sum of the first 326 (up to 2161) is prime: 325,019
The sum of the first 328 (up to 2203) is prime: 329,401
The sum of the first 330 (up to 2213) is prime: 333,821
The sum of the first 332 (up to 2237) is prime: 338,279
The sum of the first 334 (up to 2243) is prime: 342,761
The sum of the first 342 (up to 2297) is prime: 360,979
The sum of the first 350 (up to 2357) is prime: 379,667
The sum of the first 356 (up to 2393) is prime: 393,961
The sum of the first 358 (up to 2411) is prime: 398,771
The sum of the first 426 (up to 2957) is prime: 581,921
The sum of the first 446 (up to 3137) is prime: 642,869
The sum of the first 458 (up to 3251) is prime: 681,257
The sum of the first 460 (up to 3257) is prime: 687,767
The sum of the first 464 (up to 3301) is prime: 700,897
The sum of the first 480 (up to 3413) is prime: 754,573
The sum of the first 484 (up to 3461) is prime: 768,373
The sum of the first 488 (up to 3491) is prime: 782,263
The sum of the first 512 (up to 3671) is prime: 868,151
The sum of the first 530 (up to 3821) is prime: 935,507
The sum of the first 536 (up to 3863) is prime: 958,577
The sum of the first 548 (up to 3947) is prime: 1,005,551
The sum of the first 568 (up to 4129) is prime: 1,086,557
The sum of the first 620 (up to 4583) is prime: 1,313,041
The sum of the first 630 (up to 4657) is prime: 1,359,329
The sum of the first 676 (up to 5051) is prime: 1,583,293
The sum of the first 680 (up to 5087) is prime: 1,603,597
The sum of the first 696 (up to 5233) is prime: 1,686,239
The sum of the first 708 (up to 5351) is prime: 1,749,833
The sum of the first 734 (up to 5563) is prime: 1,891,889
The sum of the first 762 (up to 5807) is prime: 2,051,167
The sum of the first 768 (up to 5849) is prime: 2,086,159
The sum of the first 776 (up to 5897) is prime: 2,133,121
The sum of the first 780 (up to 5939) is prime: 2,156,813
The sum of the first 784 (up to 6007) is prime: 2,180,741
The sum of the first 808 (up to 6211) is prime: 2,327,399
The sum of the first 814 (up to 6263) is prime: 2,364,833
The sum of the first 820 (up to 6301) is prime: 2,402,537
The sum of the first 836 (up to 6427) is prime: 2,504,323
The sum of the first 844 (up to 6529) is prime: 2,556,187
The sum of the first 848 (up to 6563) is prime: 2,582,401
The sum of the first 852 (up to 6581) is prime: 2,608,699
The sum of the first 926 (up to 7243) is prime: 3,120,833
The sum of the first 942 (up to 7433) is prime: 3,238,237
The sum of the first 984 (up to 7757) is prime: 3,557,303
The sum of the first 992 (up to 7853) is prime: 3,619,807

REXX

/*REXX pgm finds summation primes P,  primes which the sum of primes up to P are prime. */
parse arg hi .                                   /*obtain optional argument from the CL.*/
if hi=='' | hi==","  then hi= 1000               /*Not specified?  Then use the default.*/
call genP                                        /*build array of semaphores for primes.*/
w= 30;     w2= w*2%3;      pad= left('',w-w2)    /*the width of the columns two & three.*/
title= ' summation primes which the sum of primes up to  P  is also prime,  P  < '  ,
                                    commas(hi)
say ' index │' center(subword(title, 1, 2), w)  center('prime sum', w)  /*display title.*/
say '───────┼'center(""   , 1 + (w+1)*2,  '─')                          /*   "    sep.  */
found= 0                                         /*initialize # of summation primes.    */
                                      $= 0       /*sum of primes up to the current prime*/
          do j=1  for hi-1;  p= @.j;  $= $ + p   /*find summation primes within range.  */
          if \!.$  then iterate                  /*Is sum─of─primes a prime?  Then skip.*/
          found= found + 1                       /*bump the number of summation primes. */
          say right(j, 6) '│'strip( right(commas(p), w2)pad || right(commas($), w2), "T")
          end   /*j*/

say '───────┴'center(""   , 1 + (w+1)*2,  '─')   /*display foot separator after output. */
say
say 'Found '       commas(found)      title
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: !.= 0;  sP= 0                              /*prime semaphores;  sP= sum of primes.*/
      @.1=2;  @.2=3;  @.3=5;  @.4=7;  @.5=11     /*define some low primes.              */
      !.2=1;  !.3=1;  !.5=1;  !.7=1;  !.11=1     /*   "     "   "    "     flags.       */
                        #=5;  sq.#= @.# **2      /*number of primes so far;     prime². */
                                                 /* [↓]  generate more  primes  ≤  high.*/
        do j=@.#+2  by 2  until @.#>=hi & @.#>sP /*find odd primes where  P≥hi and P>sP.*/
        parse var j '' -1 _; if _==5  then iterate            /*J ÷ by 5?  (right digit)*/
        if j//3==0  then iterate;  if j//7==0  then iterate   /*J ÷ by 3?;   J ÷ by 7?  */
               do k=5  while sq.k<=j             /* [↓]  divide by the known odd primes.*/
               if j // @.k == 0  then iterate j  /*Is  J ÷ X?  Then not prime.     ___  */
               end   /*k*/                       /* [↑]  only process numbers  ≤  √ J   */
        #= #+1;    @.#= j;   sq.#= j*j;   !.j= 1 /*bump # Ps; assign next P; P square; P*/
        if @.#<hi  then sP= sP + @.#             /*maybe add this prime to sum─of─primes*/
        end          /*j*/;               return
output   when using the default inputs:
 index │        summation primes                  prime sum
───────┼───────────────────────────────────────────────────────────────
     1 │                   2                             2
     2 │                   3                             5
     4 │                   7                            17
     6 │                  13                            41
    12 │                  37                           197
    14 │                  43                           281
    60 │                 281                         7,699
    64 │                 311                         8,893
    96 │                 503                        22,039
   100 │                 541                        24,133
   102 │                 557                        25,237
   108 │                 593                        28,697
   114 │                 619                        32,353
   122 │                 673                        37,561
   124 │                 683                        38,921
   130 │                 733                        43,201
   132 │                 743                        44,683
   146 │                 839                        55,837
   152 │                 881                        61,027
   158 │                 929                        66,463
   162 │                 953                        70,241
───────┴───────────────────────────────────────────────────────────────

Found  21  summation primes which the sum of primes up to  P  is also prime,  P  <  1,000

Ring

load "stdlib.ring"
see "working..." + nl
see "Summarize primes:" + nl
see "n sum" + nl
row = 0
sum = 0
limit = 1000
Primes = []
 
for n = 2 to limit
    if isprime(n)
       add(Primes,n)
    ok
next

for n = 1 to len(Primes)
    sum = sum + Primes[n]
    if isprime(sum)
       row = row + 1
       see "" + n + " " + sum + nl
    ok
next

see "Found " + row + " numbers" + nl
see "done..." + nl
Output:
working...
Summarize primes:
n sum
1 2
2 5
4 17
6 41
12 197
14 281
60 7699
64 8893
96 22039
100 24133
102 25237
108 28697
114 32353
122 37561
124 38921
130 43201
132 44683
146 55837
152 61027
158 66463
162 70241
Found 21 numbers
done...

RPL

Works with: HP version 49g
≪ { } 0 0 → display length sum
  ≪ 1
     WHILE DUP 1000 < REPEAT
        NEXTPRIME
        DUP 'sum' STO+ 
        1 'length' STO+
        IF sum ISPRIME? THEN
           length OVER sum 3 →LIST 1 →LIST 'display' SWAP STO+ END
     END 
     DROP display
≫ ≫ 'TASK' STO
Output:
1: {{1 2 2} {2 3 5} {3 7 17} {4 13 41} {5 37 197} {6 43 281} {7 281 7699} {8 311 8893} {9 503 22039} {10 541 24133} {11 557 25237} {12 593 28697} {13 619 32353} {14 673 37561} {15 683 38921} {16 733 43201} {17 743 44683} {18 839 55837} {19 881 61027} {20 929 66463} {21 953 70241}}

Ruby

Translation of: C++
def isPrime(n)
    if n < 2 then
        return false
    end

    if n % 2 == 0 then
        return n == 2
    end
    if n % 3 == 0 then
        return n == 3
    end

    i = 5
    while i * i <= n
        if n % i == 0 then
            return false
        end
        i += 2

        if n % i == 0 then
            return false
        end
        i += 4
    end
    return true
end

START = 1
STOP = 1000

sum = 0
count = 0
sc = 0

for p in START .. STOP
    if isPrime(p) then
        count += 1
        sum += p
        if isPrime(sum) then
            print "The sum of %3d primes in [2, %3d] is %5d which is also prime\n" % [count, p, sum]
            sc += 1
        end
    end
end
print "There are %d summerized primes in [%d, %d]\n" % [sc, START, STOP]
Output:
The sum of   1 primes in [2,   2] is     2 which is also prime
The sum of   2 primes in [2,   3] is     5 which is also prime
The sum of   4 primes in [2,   7] is    17 which is also prime
The sum of   6 primes in [2,  13] is    41 which is also prime
The sum of  12 primes in [2,  37] is   197 which is also prime
The sum of  14 primes in [2,  43] is   281 which is also prime
The sum of  60 primes in [2, 281] is  7699 which is also prime
The sum of  64 primes in [2, 311] is  8893 which is also prime
The sum of  96 primes in [2, 503] is 22039 which is also prime
The sum of 100 primes in [2, 541] is 24133 which is also prime
The sum of 102 primes in [2, 557] is 25237 which is also prime
The sum of 108 primes in [2, 593] is 28697 which is also prime
The sum of 114 primes in [2, 619] is 32353 which is also prime
The sum of 122 primes in [2, 673] is 37561 which is also prime
The sum of 124 primes in [2, 683] is 38921 which is also prime
The sum of 130 primes in [2, 733] is 43201 which is also prime
The sum of 132 primes in [2, 743] is 44683 which is also prime
The sum of 146 primes in [2, 839] is 55837 which is also prime
The sum of 152 primes in [2, 881] is 61027 which is also prime
The sum of 158 primes in [2, 929] is 66463 which is also prime
The sum of 162 primes in [2, 953] is 70241 which is also prime
There are 21 summerized primes in [1, 1000]

Rust

// [dependencies]
// primal = "0.3"

fn main() {
    let limit = 1000;
    let mut sum = 0;
    println!("count  prime      sum");
    for (n, p) in primal::Sieve::new(limit)
        .primes_from(2)
        .take_while(|x| *x < limit)
        .enumerate()
    {
        sum += p;
        if primal::is_prime(sum as u64) {
            println!("  {:>3}    {:>3}    {:>5}", n + 1, p, sum);
        }
    }
}
Output:
count  prime      sum
    1      2        2
    2      3        5
    4      7       17
    6     13       41
   12     37      197
   14     43      281
   60    281     7699
   64    311     8893
   96    503    22039
  100    541    24133
  102    557    25237
  108    593    28697
  114    619    32353
  122    673    37561
  124    683    38921
  130    733    43201
  132    743    44683
  146    839    55837
  152    881    61027
  158    929    66463
  162    953    70241

Scala

object PrimeSum extends App {

  val oddPrimes: LazyList[Int] = 3 #:: LazyList.from(5, 2)
        .filter(p => oddPrimes.takeWhile(_ <= math.sqrt(p)).forall(p % _ > 0))
  val primes = 2 #:: oddPrimes
  
  def isPrime(n: Int): Boolean = {
    if (n < 5) (n | 1) == 3
    else primes.takeWhile(_ <= math.sqrt(n)).forall(n % _ > 0)
  }
  
  val limit = primes.takeWhile(_ <= 1000).length

  val number = (1 to limit).filter(index => {
        val list = primes.take(index)
        val sum = list.sum
        val flag = isPrime(sum)
        if (flag) println(f"$index%3d  ${list.last}%3d  $sum%5d")
        flag
      }).length

  println(s"\nfound $number such primes")
}
Output:
  1    2      2
  2    3      5
  4    7     17
  6   13     41
 12   37    197
 14   43    281
 60  281   7699
 64  311   8893
 96  503  22039
100  541  24133
102  557  25237
108  593  28697
114  619  32353
122  673  37561
124  683  38921
130  733  43201
132  743  44683
146  839  55837
152  881  61027
158  929  66463
162  953  70241

found 21 such primes

Sidef

1000.primes.map_reduce {|a,b| a + b }.map_kv {|k,v|
    [k+1, prime(k+1), v]
}.grep { .tail.is_prime }.prepend(
    ['count', 'prime', 'sum']
).each_2d {|n,p,s|
    printf("%5s %6s %8s\n", n, p, s)
}
Output:
count  prime      sum
    1      2        2
    2      3        5
    4      7       17
    6     13       41
   12     37      197
   14     43      281
   60    281     7699
   64    311     8893
   96    503    22039
  100    541    24133
  102    557    25237
  108    593    28697
  114    619    32353
  122    673    37561
  124    683    38921
  130    733    43201
  132    743    44683
  146    839    55837
  152    881    61027
  158    929    66463
  162    953    70241

Wren

Library: Wren-math
Library: Wren-fmt
import "./math" for Int
import "./fmt" for Fmt

var primes = Int.primeSieve(999)
var sum = 0
var n = 0
var c = 0
System.print("Summing the first n primes (<1,000) where the sum is itself prime:")
System.print("  n  cumulative sum")
for (p in primes) {
    n = n + 1
    sum = sum + p
    if (Int.isPrime(sum)) {
        c = c + 1
        Fmt.print("$3d   $,6d", n, sum)
    }
}
System.print("\n%(c) such prime sums found")
Output:
Summing the first n primes (<1,000) where the sum is itself prime:
  n  cumulative sum
  1        2
  2        5
  4       17
  6       41
 12      197
 14      281
 60    7,699
 64    8,893
 96   22,039
100   24,133
102   25,237
108   28,697
114   32,353
122   37,561
124   38,921
130   43,201
132   44,683
146   55,837
152   61,027
158   66,463
162   70,241

21 such prime sums found

XPL0

func IsPrime(N);        \Return 'true' if N is a prime number
int  N, I;
[if N <= 1 then return false;
for I:= 2 to sqrt(N) do
    if rem(N/I) = 0 then return false;
return true;
];

int Count, N, Sum, Prime;
[Text(0, "Prime Prime
count   sum
");
Count:= 0;  N:= 0;  Sum:= 0;
for Prime:= 2 to 1000-1 do
    if IsPrime(Prime) then
        [N:= N+1;
        Sum:= Sum + Prime;
        if IsPrime(Sum) then
            [Count:= Count+1;
            IntOut(0, N);
            ChOut(0, 9\tab\);
            IntOut(0, Sum);
            CrLf(0);
            ];
        ];
IntOut(0, Count);
Text(0, " prime sums of primes found below 1000.
");
]
Output:
Prime   Prime
count   sum
1       2
2       5
4       17
6       41
12      197
14      281
60      7699
64      8893
96      22039
100     24133
102     25237
108     28697
114     32353
122     37561
124     38921
130     43201
132     44683
146     55837
152     61027
158     66463
162     70241
21 prime sums of primes found below 1000.