I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Sum of primes in odd positions is prime

Sum of primes in odd positions is prime 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.

Let p(i) be a sequence of prime numbers.
Consider the p(1),p(3),p(5), ... ,p(i), for each p(i) < 1,000 and i is odd.
Let sum be the sum of these primes.
If sum is prime then print i, p(i) and sum.

11l

Translation of: Nim
`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 = 0V s = 0V p = 1L 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}’)`
Output:
```  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
```

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

ALGOL 68

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

AWK

` # syntax: GAWK -f SUM_OF_PRIMES_IN_ODD_POSITIONS_IS_PRIME.AWK# converted from RingBEGIN {    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)} `
Output:
```     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
```

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

F#

This task uses Extensible Prime Generator (F#)

` // Sum of primes in odd positions is prime. Nigel Galloway: November 9th., 2021primes32()|>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}") `
Output:
```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
```

Factor

Works with: Factor version 0.99 2021-06-02
`USING: assocs assocs.extras kernel math.primes math.statisticsprettyprint sequences.extras ; 1000 primes-upto <evens> dup cum-sum zip [ prime? ] filter-values .`
Output:
```{
{ 2 2 }
{ 5 7 }
{ 31 89 }
{ 103 659 }
{ 149 1181 }
{ 331 5021 }
{ 467 9923 }
{ 499 10909 }
{ 523 11941 }
{ 653 17959 }
{ 823 26879 }
}
```

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

FreeBASIC

`#include "isprime.bas"dim as uinteger i = 1, p, sum = 0for 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 ifnext p`

Go

Translation of: Wren
Library: Go-rcu
`package main import (    "fmt"    "rcu") func main() {    primes := rcu.Primes(999)    sum := 0    fmt.Println(" i   p[i]  Σp[i]")    fmt.Println("----------------")    for i := 0; i < len(primes); i += 2 {        sum += primes[i]        if rcu.IsPrime(sum) {            fmt.Printf("%3d  %3d  %6s\n", i+1, primes[i], rcu.Commatize(sum))        }    }}`
Output:
``` i   p[i]  Σp[i]
----------------
1    2       2
3    5       7
11   31      89
27  103     659
35  149   1,181
67  331   5,021
91  467   9,923
95  499  10,909
99  523  11,941
119  653  17,959
143  823  26,879
```

GW-BASIC

`10 S = 220 A = 130 PRINT 1, 2, 240 FOR P = 3 TO 999 STEP 250 GOSUB 9060 IF Q=1 THEN GOSUB 19070 NEXT P80 END90 Q=0100 IF P=3 THEN Q=1:RETURN110 IF P = 2 THEN Q = 1: RETURN120 IF INT(P/2)*2= P THEN Q =  0: RETURN130 I=1140 I=I+2150 IF INT(P/I)*I = P THEN RETURN160 IF I*I<=P THEN GOTO 140170 Q = 1180 RETURN190 A = A + 1200 IF A MOD 2 = 0 THEN RETURN210 S = S + P220 T = P230 P = S240 GOSUB 90250 IF Q = 1 THEN PRINT A, T, S260 P = T270 RETURN`

jq

Works with: jq

Works with gojq, the Go implementation of jq See e.g. Erdős-primes#jq for a suitable implementation of `is_prime`.

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

Julia

Translation of: Factor
`using Primesp = 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")) `
Output:
```(2, 2)
(5, 7)
(31, 89)
(103, 659)
(149, 1181)
(331, 5021)
(467, 9923)
(499, 10909)
(523, 11941)
(653, 17959)
(823, 26879)
```

Mathematica/Wolfram Language

`p = Prime[Range[1, PrimePi[1000], 2]];p = {p, Accumulate[p]} // Transpose;Select[p, Last /* PrimeQ]`
Output:
`{{2,2},{5,7},{31,89},{103,659},{149,1181},{331,5021},{467,9923},{499,10909},{523,11941},{653,17959},{823,26879}}`

Nim

`import strformat template isOdd(n: Natural): bool = (n and 1) != 0template isEven(n: Natural): bool = (n and 1) == 0 func isPrime(n: Positive): bool =  if n == 1: return false  if n.isEven: return n == 2  if n mod 3 == 0: return n == 3  var d = 5  while d * d <= n:    if n mod d == 0: return false    inc d, 2    if n mod d == 0: return false    inc d, 4  result = true # Compute the sums of primes at odd position.echo "  i  p(i)   sum"var idx = 0var sum = 0var p = 1while p < 1000:  inc p  if p.isPrime:    inc idx    if idx.isOdd:      inc sum, p      if sum.isPrime:        echo &"{idx:3}  {p:3}  {sum:5}"`
Output:
```  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```

PARI-GP

`sm=0;for(ii=0, 83, oi=1+2*ii;sm=sm+prime(oi);if(isprime(sm),print(oi," ", prime(oi)," ",sm)))`
Output:
```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
```

Perl

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

Phix

```with javascript_semantics
sequence primes = get_primes_le(1000)
integer total = 0
printf(1,"  i    p     sum\n")
printf(1,"----------------\n")
for i=1 to length(primes) by 2 do
total += primes[i]
if is_prime(total) then
printf(1,"%3d  %3d  %,6d\n", {i, primes[i], total})
end if
end for
```
Output:
```  i    p     sum
----------------
1    2       2
3    5       7
11   31      89
27  103     659
35  149   1,181
67  331   5,021
91  467   9,923
95  499  10,909
99  523  11,941
119  653  17,959
143  823  26,879
```

Raku

`my @odd  = grep { ++\$ !%% 2 }, grep &is-prime, 2 ..^ 1000;my @sums = [\+] @odd; say .fmt('%5d') for grep { .[2].is-prime }, ( (1,3…*) Z @odd Z @sums );`
Output:
```    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```

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, '─')saysay '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 [email protected].#+2  by 2  to hi*33;  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.#= j*j;  !.j= 1 /*bump # of Ps; assign next P;  P²; P# */        end          /*j*/;               return`
output   when using the default inputs:
``` index │  odd indexed primes         the sum of the odd indexed primes
───────┼─────────────────────────────────────────────────────────────────
1   │             2                                 2
3   │             5                                 7
11   │            31                                89
27   │           103                               659
35   │           149                             1,181
67   │           331                             5,021
91   │           467                             9,923
95   │           499                            10,909
99   │           523                            11,941
119  │           653                            17,959
143  │           823                            26,879
───────┴─────────────────────────────────────────────────────────────────

Found  11  odd indexed primes
```

Ring

` load "stdlib.ring"see "working..." + nlsee "i p sum" + nl nr = 0sum = 0limit = 1000 for n = 2 to limit     if isprime(n)       nr++       if nr%2 = 1          sum += n          if isprime(sum)             see "" + nr + " " + n + " " + sum + nl          ok       ok    oknext see "done..." + nl `
Output:
```working...
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
done...
```

Ruby

`require 'prime' sum = 0Prime.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 `
Output:
```     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

```

Tiny BASIC

`    LET I = 0    LET S = 0    LET P = 110  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 20020  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 = 1110 LET A = A + 1    IF (X/A)*A = X THEN GOTO 120    IF A*A<=X THEN GOTO 110    RETURN120 LET Z = 0    RETURN 200 LET S = S + P    LET X = S    GOSUB 100    IF Z = 1 THEN PRINT I," ", P," ", S    RETURN`
Output:
```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

```

Wren

Library: Wren-math
Library: Wren-trait
Library: Wren-fmt
`import "/math" for Intimport "/trait" for Indexedimport "/fmt" for Fmt var primes = Int.primeSieve(999)var sum = 0System.print(" i   p[i]  Σp[i]")System.print("----------------")for (se in Indexed.new(primes, 2)) {    sum = sum + se.value    if (Int.isPrime(sum)) Fmt.print("\$3d  \$3d  \$,6d", se.index + 1, se.value, sum)}`
Output:
``` i   p[i]  Σp[i]
----------------
1    2       2
3    5       7
11   31      89
27  103     659
35  149   1,181
67  331   5,021
91  467   9,923
95  499  10,909
99  523  11,941
119  653  17,959
143  823  26,879
```

XPL0

`func IsPrime(N);        \Return 'true' if N is a prime numberint  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 I, Sum, N;[Text(0, "p(n)  sum^m^j");Sum:= 0;  I:= 0;for N:= 2 to 1000-1 do    [if IsPrime(N) then        [I:= I+1;        if I&1 then     \odd            [Sum:= Sum + N;            if IsPrime(Sum) then                [IntOut(0, N);  ChOut(0, ^      );  IntOut(0, Sum);  CrLf(0)];            ];        ];    ];]`
Output:
```p(n)    sum
2       2
5       7
31      89
103     659
149     1181
331     5021
467     9923
499     10909
523     11941
653     17959
823     26879
```

Yabasic

Translation of: XPL0
`// 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 trueend 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 ifnext`
Output:
```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---```