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

← Older edit

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

Revision as of 10:34, 11 February 2024

20,312 bytes added , 3 months ago

m

→‎{{header|Wren}}: Minor tidy

PureFox

9,476

edits

Revision as of 19:34, 1 September 2021 (view source) Petelomax (talk \| contribs) (→‎{{header\|Phix}}) ← Older edit		Latest revision as of 10:34, 11 February 2024 (view source) PureFox (talk \| contribs) m (→‎{{header\|Wren}}: Minor tidy)
(40 intermediate revisions by 22 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 ~~the~~any [[wikipedia:Prefix_sum\|prefix sum]] of these ~~primes~~primesa. <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; ii<=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->(2n+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}} <~~lang~~syntaxhighlight 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 .</~~lang~~syntaxhighlight> {{out}} <pre> Line 31 ⟶ 358: } </pre> =={{header\|Fermat}}== <syntaxhighlight lang="fermat">s:=0; for ii=0 to 83 do oi:=1+2ii;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}} <~~lang~~syntaxhighlight lang="go">package main import ( Line 53 ⟶ 397: } } }</~~lang~~syntaxhighlight> {{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 II<=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}}== {{works with\|jq}} '''Works with gojq, the Go implementation of jq''' See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`. <syntaxhighlight lang="jq">def lpad($len): tostring \| ($len - length) as $l \| (" " * $l)[:$l] + .; def task: [2, (range(3;1000;2)\|select(is_prime))] \| [.[range(0;length;2)]] \| . as $oddPositionPrimes \| foreach range(0; length) as $i ({i: -1}; .i += 2 \| .sum += $oddPositionPrimes[$i]; select(.sum\|is_prime) \| "\(.i\|lpad(3)) \($oddPositionPrimes[$i]\|lpad(3)) \(.sum\|lpad(5))" ) ; " i p[$i] sum", task</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\|Julia}}== {{trans\|Factor}} <syntaxhighlight 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")) </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\|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}}== <~~lang~~syntaxhighlight ~~Nim~~lang="nim">import strformat template isOdd(n: Natural): bool = (n and 1) != 0 Line 102 ⟶ 552: inc sum, p if sum.isPrime: echo &"{idx:3} {p:3} {sum:5}"</~~lang~~syntaxhighlight> {{out}} Line 117 ⟶ 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+2ii;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}}== <!--<~~lang~~syntaxhighlight ~~Phix~~lang="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 131 ⟶ 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> <!--</~~lang~~syntaxhighlight>--> {{out}} <pre> Line 147 ⟶ 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" ~~perl6~~line>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 );</~~lang~~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\|REXX}}== <syntaxhighlight lang="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./ call genP /build array of semaphores for primes./ title= 'odd indexed primes the sum of the odd indexed primes' say ' index │'center(title, 65) say '───────┼'center("" , 65, '─') found= 0 /initialize # of odd indexed primes···/ $= 0 /sum of odd indexed primes (so far). / do j=1 by 2; p= @.j; if p>hi then leave /find odd indexed primes, sum = prime./ $= $ + p /add this odd index prime to the sum. / if \!.$ then iterate /This sum not prime? Then skip it. / found= found + 1 /bump the number of solutions found. / say center(j, 7)'│' right( commas(p), 13) right( commas($), 33) end /j/ say '───────┴'center("" , 65, '─') say say 'Found ' commas(found) ' 'subword(title, 1, 3) 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: @.1=2; @.2=3; @.3=5; @.4=7; @.5=11 /define some low primes. / !.=0; !.2=1; !.3=1; !.5=1; !.7=1; !.11=1 / " " " " semaphores. / #=5; sq.#= @.# * 2 /number of primes so far; prime². / do j=@.#+2 by 2 to hi33; parse var j '' -1 _ /obtain the last decimal dig./ if _==5 then iterate; if j//3==0 then iterate; if j//7==0 then iterate 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.#= jj; !.j= 1 /bump # of Ps; assign next P; P²; P# / end /j/; return</syntaxhighlight> {{out\|output\|text=  when using the default inputs:}} <pre> index │ odd indexed primes the sum of the odd indexed primes ~~2 2~~ ───────┼───────────────────────────────────────────────────────────────── ~~5 7~~ 1 │ 2 2 ~~31 89~~ 3 │ 5 7 ~~103 659~~ 11 │ 31 89 ~~149 1181~~ 27 │ 103 659 ~~331 5021~~ 35 │ 149 1,181 ~~467 9923~~ 67 │ 331 5,021 ~~499 10909~~ 91 │ 467 9,923 ~~523 11941~~ 95 │ 499 10,909 ~~653 17959~~ 99 │ 523 11,941 ~~823 26879</pre>~~ 119 │ 653 17,959 143 │ 823 26,879 ───────┴───────────────────────────────────────────────────────────────── Found 11 odd indexed primes </pre> =={{header\|Ring}}== <~~lang~~syntaxhighlight lang="ring"> load "stdlib.ring" see "working..." + nl Line 191 ⟶ 806: see "done..." + nl </syntaxhighlight> ~~</lang>~~ {{out}} <pre> Line 208 ⟶ 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-~~trait~~iterate}} {{libheader\|Wren-fmt}} <~~lang~~syntaxhighlight ~~ecmascript~~lang="wren">import "./math" for Int import "./~~trait~~iterate" for Indexed import "./fmt" for Fmt var primes = Int.primeSieve(999) Line 225 ⟶ 951: sum = sum + se.value if (Int.isPrime(sum)) Fmt.print("$3d $3d $,6d", se.index + 1, se.value, sum) }</~~lang~~syntaxhighlight> {{out}} Line 245 ⟶ 971: =={{header\|XPL0}}== <~~lang~~syntaxhighlight ~~XPL0~~lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number int N, I; [if N <= 1 then return false; Line 266 ⟶ 992: ]; ]; ]</~~lang~~syntaxhighlight> {{out}} Line 283 ⟶ 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>