Sum of primes in odd positions is prime


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.

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



11lEdit

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 = 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}’)
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!Edit

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

Screenshot from Atari 8-bit computer

  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 68Edit

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

AWKEdit

# 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)
}
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

CEdit

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

This task uses Extensible Prime Generator (F#)

// 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}")
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

FactorEdit

Works with: Factor version 0.99 2021-06-02
USING: assocs assocs.extras kernel math.primes math.statistics
prettyprint 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 }
}

FermatEdit

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;

FreeBASICEdit

#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

GoEdit

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

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

jqEdit

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

JuliaEdit

Translation of: Factor
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"))
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 LanguageEdit

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

NimEdit

import strformat

template isOdd(n: Natural): bool = (n and 1) != 0
template 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 = 0
var sum = 0
var p = 1
while 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-GPEdit

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

PerlEdit

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

PhixEdit

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

RakuEdit

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

REXXEdit

/*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 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

RingEdit

load "stdlib.ring"
see "working..." + nl
see "i p sum" + nl

nr = 0
sum = 0
limit = 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
    ok
next

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

RubyEdit

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

SidefEdit

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
    }
}
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 BASICEdit

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

WrenEdit

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

var primes = Int.primeSieve(999)
var sum = 0
System.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

XPL0Edit

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

YabasicEdit

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