Rosetta Code

Sum of primes in odd positions is prime: Difference between revisions

Page Discussion

Sum of primes in odd positions is prime (view source)

Revision as of 10:34, 11 February 2024

14,945 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(37 intermediate revisions by 20 users not shown)
Line 1:
{{Draft task|Prime Numbers}}
 
;Task:
<br>Let '''p(i)''' be a sequence of prime numbers. such that 2=p(1), 3=p(2), 5=p(3), ...
<br>Consider the '''p(1),p(3),p(5), ... ,p(i)''', for each '''p(i) < 1,000''' and '''i''' is odd.
<br>Let '''sum''' be theany [[wikipedia:Prefix_sum|prefix sum]] of these primesprimesa.
<br>If '''sum''' is prime then print '''i''', '''p(i)''' and '''sum'''.
 
<br><br>
 
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">F is_prime(n)
I n == 2
R 1B
I n < 2 | n % 2 == 0
R 0B
L(i) (3 .. Int(sqrt(n))).step(2)
I n % i == 0
R 0B
R 1B
 
print(‘ i p(i) sum’)
V idx = 0
V s = 0
V p = 1
L p < 1000
p++
I is_prime(p)
idx++
I idx % 2 != 0
s += p
I is_prime(s)
print(f:‘{idx:3} {p:3} {s:5}’)</syntaxhighlight>
 
{{out}}
<pre>
i p(i) sum
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
 
BYTE FUNC IsPrime(CARD x)
CARD i,max
 
i=2 max=x/2
WHILE i<=max
DO
IF x MOD i=0 THEN
RETURN (0)
FI
i==+1
OD
RETURN (1)
 
PROC Main()
CARD x,count,sum
CHAR ARRAY s(6)
 
Put(125) PutE() ;clear the screen
PrintF("%3S%5S%6S%E","i","p(i)","sum")
count=0 sum=0
FOR x=2 TO 999
DO
IF IsPrime(x) THEN
count==+1
IF (count&1)=1 THEN
sum==+x
IF IsPrime(sum) THEN
StrC(count,s) PrintF("%3S",s)
StrC(x,s) PrintF("%5S",s)
StrC(sum,s) PrintF("%6S%E",s)
FI
FI
FI
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_primes_in_odd_positions_is_prime.png Screenshot from Atari 8-bit computer]
<pre>
i p(i) sum
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<syntaxhighlight lang="algol68">BEGIN # find primes (up to 999) p(i) for odd i such that the sum of primes p(j), j = 1, 3, 5, ..., i is prime #
PR read "primes.incl.a68" PR
INT max prime = 999;
[]BOOL prime = PRIMESIEVE 50 000; # guess that the max sum will be <= 50 000 #
[]INT low prime = EXTRACTPRIMESUPTO max prime FROMPRIMESIEVE prime; # get a list of primes up to max prime #
# find the sums of the odd primes and test for primality #
print( ( " i p[i] sum", newline ) );
INT odd prime sum := 0;
FOR i BY 2 TO UPB low prime DO
IF odd prime sum +:= low prime[ i ];
IF odd prime sum <= UPB prime
THEN
prime[ odd prime sum ]
ELSE
print( ( "Need more primes: ", whole( odd prime sum, 0 ), newline ) );
FALSE
FI
THEN
print( ( whole( i, -3 ), " ", whole( low prime[ i ], -4 ), " ", whole( odd prime sum, -6 ), newline ) )
FI
OD
END</syntaxhighlight>
{{out}}
<pre>
i p[i] sum
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">print " i | p(i) sum"
print repeat "-" 17
idx: 0
sm: 0
p: 1
while [p < 1000][
inc 'p
if prime? p [
inc 'idx
if odd? idx [
sm: sm + p
if prime? sm ->
print (pad to :string idx 4) ++ " | " ++ (pad to :string p 3) ++ (pad to :string sm 6)
]
]
]</syntaxhighlight>
 
{{out}}
 
<pre> i | p(i) sum
-----------------
1 | 2 2
3 | 5 7
11 | 31 89
27 | 103 659
35 | 149 1181
67 | 331 5021
91 | 467 9923
95 | 499 10909
99 | 523 11941
119 | 653 17959
143 | 823 26879</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SUM_OF_PRIMES_IN_ODD_POSITIONS_IS_PRIME.AWK
# converted from Ring
BEGIN {
print(" i p sum")
print("------ ------ ------")
start = 2
stop = 999
for (i=start; i<=stop; i++) {
if (is_prime(i)) {
if (++nr % 2 == 1) {
sum += i
if (is_prime(sum)) {
count++
printf("%6d %6d %6d\n",nr,i,sum)
}
}
}
}
printf("Odd indexed primes %d-%d: %d\n",start,stop,count)
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)
}
</syntaxhighlight>
{{out}}
<pre>
i p sum
------ ------ ------
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
Odd indexed primes 2-999: 11
</pre>
 
=={{header|C}}==
<syntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
 
int isprime( int p ) {
int i;
if(p==2) return 1;
if(!(p%2)) return 0;
for(i=3; i*i<=p; i+=2) {
if(!(p%i)) return 0;
}
return 1;
}
 
int main( void ) {
int s=0, p, i=1;
for(p=2;p<=999;p++) {
if(isprime(p)) {
if(i%2) {
s+=p;
if(isprime(s)) printf( "%d %d %d\n", i, p, s );
}
i+=1;
}
}
return 0;
}</syntaxhighlight>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
Uses the [[Extensible_prime_generator#Delphi|Delphi Prime-Generator Object]]
 
<syntaxhighlight lang="Delphi">
 
procedure SumOddPrimes(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,2);
end;
 
finally Sieve.Free; end;
end;
 
</syntaxhighlight>
{{out}}
<pre>
I P(I) Sum
---------------
0 2 2
2 5 7
10 31 89
26 103 659
34 149 1181
66 331 5021
90 467 9923
94 499 10909
98 523 11941
118 653 17959
142 823 26879
 
Elapsed Time: 16.077 ms.
 
</pre>
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<syntaxhighlight lang="fsharp">
// Sum of primes in odd positions is prime. Nigel Galloway: November 9th., 2021
primes32()|>Seq.chunkBySize 2|>Seq.mapi(fun n g->(2*n+1,g.[0]))|>Seq.scan(fun(n,i,g)(e,l)->(e,l,g+l))(0,0,0)|>Seq.takeWhile(fun(_,n,_)->n<1000)|>Seq.filter(fun(_,_,n)->isPrime n)|>Seq.iter(fun(n,g,l)->printfn $"i=%3d{n} p[i]=%3d{g} sum=%5d{l}")
</syntaxhighlight>
{{out}}
<pre>
i= 1 p[i]= 2 sum= 2
i= 3 p[i]= 5 sum= 7
i= 11 p[i]= 31 sum= 89
i= 27 p[i]=103 sum= 659
i= 35 p[i]=149 sum= 1181
i= 67 p[i]=331 sum= 5021
i= 91 p[i]=467 sum= 9923
i= 95 p[i]=499 sum=10909
i= 99 p[i]=523 sum=11941
i=119 p[i]=653 sum=17959
i=143 p[i]=823 sum=26879
</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: assocs assocs.extras kernel math.primes math.statistics
prettyprint sequences.extras ;
 
1000 primes-upto <evens> dup cum-sum zip [ prime? ] filter-values .</langsyntaxhighlight>
{{out}}
<pre>
Line 31 ⟶ 358:
}
</pre>
 
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">s:=0;
for ii=0 to 83 do oi:=1+2*ii;s:=s+Prime(oi);if Isprime(s)=1 then !!(oi, Prime(oi), s) fi od;</syntaxhighlight>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#include "isprime.bas"
dim as uinteger i = 1, p, sum = 0
for p = 2 to 999
if isprime(p) then
if i mod 2 = 1 then
sum += p
if isprime(sum) then print i, p, sum
end if
i = i + 1
end if
next p</syntaxhighlight>
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 53 ⟶ 397:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 71 ⟶ 415:
143 823 26,879
</pre>
 
=={{header|GW-BASIC}}==
<syntaxhighlight lang="gwbasic">10 S = 2
20 A = 1
30 PRINT 1, 2, 2
40 FOR P = 3 TO 999 STEP 2
50 GOSUB 90
60 IF Q=1 THEN GOSUB 190
70 NEXT P
80 END
90 Q=0
100 IF P=3 THEN Q=1:RETURN
110 IF P = 2 THEN Q = 1: RETURN
120 IF INT(P/2)*2= P THEN Q = 0: RETURN
130 I=1
140 I=I+2
150 IF INT(P/I)*I = P THEN RETURN
160 IF I*I<=P THEN GOTO 140
170 Q = 1
180 RETURN
190 A = A + 1
200 IF A MOD 2 = 0 THEN RETURN
210 S = S + P
220 T = P
230 P = S
240 GOSUB 90
250 IF Q = 1 THEN PRINT A, T, S
260 P = T
270 RETURN</syntaxhighlight>
 
=={{header|J}}==
 
<syntaxhighlight lang=J> (i,.p,.sum) #~ 1 p: sum=. +/\p=. p:<:i=. (#~ 2|])i. 1+p:inv 1000
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879</syntaxhighlight>
 
=={{header|jq}}==
Line 77 ⟶ 465:
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
 
<langsyntaxhighlight lang="jq">def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
 
def task:
Line 89 ⟶ 477:
| "\(.i|lpad(3)) \($oddPositionPrimes[$i]|lpad(3)) \(.sum|lpad(5))" ) ;
 
" i p[$i] sum", task</langsyntaxhighlight>
{{out}}
<pre>
Line 105 ⟶ 493:
143 823 26879
</pre>
 
=={{header|Julia}}==
{{trans|Factor}}
<langsyntaxhighlight lang="julia">using Primes
p = primes(1000)
arr = filter(n -> isprime(n[2]), accumulate((x, y) -> (y, x[2] + y), p[1:2:length(p)], init = (0, 0)))
println(join(arr, "\n"))
</langsyntaxhighlight>{{out}}
<pre>
(2, 2)
Line 125 ⟶ 514:
(823, 26879)
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">p = Prime[Range[1, PrimePi[1000], 2]];
p = {p, Accumulate[p]} // Transpose;
Select[p, Last /* PrimeQ]</syntaxhighlight>
{{out}}
<pre>{{2,2},{5,7},{31,89},{103,659},{149,1181},{331,5021},{467,9923},{499,10909},{523,11941},{653,17959},{823,26879}}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strformat
 
template isOdd(n: Natural): bool = (n and 1) != 0
Line 156 ⟶ 552:
inc sum, p
if sum.isPrime:
echo &"{idx:3} {p:3} {sum:5}"</langsyntaxhighlight>
 
{{out}}
Line 171 ⟶ 567:
119 653 17959
143 823 26879</pre>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let is_prime n =
let rec test x =
let q = n / x in x > q || x * q <> n && n mod (x + 2) <> 0 && test (x + 6)
in if n < 5 then n lor 1 = 3 else n land 1 <> 0 && n mod 3 <> 0 && test 5
 
let () = Seq.ints 3
|> Seq.filter is_prime
|> Seq.take_while ((>) 1000)
|> Seq.zip (Seq.ints 2)
|> Seq.filter (fun (i, _) -> i land 1 = 1)
|> Seq.scan (fun (_, pi, sum) (i, p) -> i, p, sum + p) (1, 2, 2)
|> Seq.filter (fun (_, _, sum) -> is_prime sum)
|> Seq.iter (fun (i, pi, sum) -> Printf.printf "p(%u) = %u, %u\n" i pi sum)</syntaxhighlight>
{{out}}
<pre>
p(1) = 2, 2
p(3) = 5, 7
p(11) = 31, 89
p(27) = 103, 659
p(35) = 149, 1181
p(67) = 331, 5021
p(91) = 467, 9923
p(95) = 499, 10909
p(99) = 523, 11941
p(119) = 653, 17959
p(143) = 823, 26879
</pre>
 
=={{header|PARI-GP}}==
<syntaxhighlight lang="parigp">sm=0;for(ii=0, 83, oi=1+2*ii;sm=sm+prime(oi);if(isprime(sm),print(oi," ", prime(oi)," ",sm)))</syntaxhighlight>
{{out}}
<pre>
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl">use strict;
use warnings;
use ntheory 'is_prime';
 
my $c;
my @odd = grep { 0 != ++$c % 2 } grep { is_prime $_ } 2 .. 999;
my @sums = $odd[0];
push @sums, $sums[-1] + $_ for @odd[1..$#odd];
 
$c = 1;
for (0..$#sums) {
printf "%6d%6d%6d\n", $c, $odd[$_], $sums[$_] if is_prime $sums[$_];
$c += 2;
}</syntaxhighlight>
{{out}}
<pre> 1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879</pre>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">)</span>
Line 185 ⟶ 656:
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 201 ⟶ 672:
119 653 17,959
143 823 26,879
</pre>
 
=={{header|Quackery}}==
 
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<syntaxhighlight lang="Quackery"> [ dip number$
over size -
space swap of
swap join echo$ ] is justify ( n n --> )
 
[] 1000 times
[ i^ isprime if [ i^ join ] ]
[] swap witheach
[ i^ 1 & 0 = iff join else drop ]
0 swap witheach
[ tuck + dup isprime if
[ i^ 2 * 1+ 3 justify
over 5 justify
dup 7 justify
cr ]
nip ]
drop</syntaxhighlight>
 
{{out}}
 
<pre> 1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>my @odd = grep { ++$ !%% 2 }, grep &is-prime, 2 ..^ 1000;
my @sums = [\+] @odd;
 
say .fmt('%5d') for grep { .[12].is-prime }, ( (1,3…*) Z @odd Z @sums );</langsyntaxhighlight>
{{out}}
<pre> 1 2 2
2 3 2 5 7
5 11 731 89
27 103 659
31 89
35 149 1181
103 659
67 331 5021
149 1181
91 467 9923
331 5021
95 499 10909
467 9923
99 523 11941
499 10909
119 653 17959
523 11941
143 823 26879</pre>
653 17959
823 26879</pre>
 
=={{header|REXX}}==
<langsyntaxhighlight REXXlang="rexx">/*REXX pgm shows a prime index, the prime, & sum of odd indexed primes when sum is prime*/
parse arg hi . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 1000 /*Not specified? Then use the default.*/
Line 255 ⟶ 762:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 277 ⟶ 784:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 299 ⟶ 806:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 316 ⟶ 823:
143 823 26879
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
≪ → max
≪ { } 0 2
1 max '''FOR''' j
SWAP OVER + SWAP
'''IF''' OVER ISPRIME? '''THEN'''
j OVER 4 PICK →V3
4 ROLL SWAP + UNROT
'''END'''
NEXTPRIME NEXTPRIME
'''IF''' DUP max ≥ '''THEN''' max 'j' STO '''END'''
2 '''STEP'''
DROP2
≫ ≫ '<span style="color:blue">TASK</span>' STO
 
1000 <span style="color:blue">TASK</span>
{{out}}
<pre>
1:. {[1. 2. 2.] [3. 5. 7.] [11. 31. 89.] [27. 103. 659.] [35. 149. 1181.] [67. 331. 5021.] [91. 467. 9923.] [95. 499. 10909.] [99. 523. 11941.] [119. 653. 17959.] [143. 823. 26879.]}
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
sum = 0
Prime.each(1000).with_index(1).each_slice(2) do |(odd_i, i),(_)|
puts "%6d%6d%6d" % [i, odd_i, sum] if (sum += odd_i).prime?
end
</syntaxhighlight>
{{out}}
<pre> 1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var sum = 0
1e3.primes.each_kv {|k,v|
if (k+1 -> is_odd) {
sum += v
say "#{k+1} #{v} #{sum}" if sum.is_prime
}
}</syntaxhighlight>
{{out}}
<pre>
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Tiny BASIC}}==
<syntaxhighlight lang="tinybasic"> LET I = 0
LET S = 0
LET P = 1
10 LET P = P + 1
LET X = P
GOSUB 100
IF Z = 1 THEN LET I = I + 1
IF Z = 0 THEN GOTO 20
IF (I/2)*2<>I THEN GOSUB 200
20 IF P<917 THEN GOTO 10 REM need to cheat a little to avoid overflow
END
100 REM is X a prime? Z=1 for yes, 0 for no
LET Z = 1
IF X = 3 THEN RETURN
IF X = 2 THEN RETURN
LET A = 1
110 LET A = A + 1
IF (X/A)*A = X THEN GOTO 120
IF A*A<=X THEN GOTO 110
RETURN
120 LET Z = 0
RETURN
200 LET S = S + P
LET X = S
GOSUB 100
IF Z = 1 THEN PRINT I," ", P," ", S
RETURN</syntaxhighlight>
 
{{out}}<pre>1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-traititerate}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./traititerate" for Indexed
import "./fmt" for Fmt
 
var primes = Int.primeSieve(999)
Line 333 ⟶ 951:
sum = sum + se.value
if (Int.isPrime(sum)) Fmt.print("$3d $3d $,6d", se.index + 1, se.value, sum)
}</langsyntaxhighlight>
 
{{out}}
Line 353 ⟶ 971:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 374 ⟶ 992:
];
];
]</langsyntaxhighlight>
 
{{out}}
Line 391 ⟶ 1,009:
823 26879
</pre>
 
=={{header|Yabasic}}==
{{trans|XPL0}}
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Sum_of_primes_in_odd_positions_is_prime
// by Galileo, 04/2022
 
sub isPrime(n)
local i
if n < 4 return n >= 2
for i = 2 to sqrt(n)
if not mod(n, i) return false
next
return true
end sub
 
print "i\tp(n)\tsum\n----\t-----\t------"
for n = 1 to 1000
if isPrime(n) then
i = i + 1
if mod(i, 2) then
sum = sum + n
if isPrime(sum) print i, "\t", n, "\t", sum
end if
end if
next</syntaxhighlight>
{{out}}
<pre>i p(n) sum
---- ----- ------
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
---Program done, press RETURN---</pre>
PureFox
9,485

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/315595...355033"