Sum of two adjacent numbers are primes: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Wren}}: Recoded to do extra credit.)
(→‎{{header|C}}: Recoded to do extra credit.)
Line 331: Line 331:


=={{header|C}}==
=={{header|C}}==
{{trans|Wren}}
{{trans|Go}}
<lang c>#include <stdio.h>
<lang c>#include <stdio.h>
#include <stdlib.h>
#include <math.h>


#define TRUE 1
#define TRUE 1
#define FALSE 0
#define FALSE 0


typedef int bool;
int isPrime(int n) {

if (n < 2) return FALSE;
void primeSieve(int *c, int limit, bool processEven, bool primesOnly) {
if (!(n%2)) return n == 2;
if (!(n%3)) return n == 3;
int i, ix, p, p2;
int d = 5;
limit++;
while (d*d <= n) {
c[0] = TRUE;
⚫
c[1] = TRUE;
⚫
if (!(n%d)) return FALSE;
if (processEven) {
⚫
d += 2;
if (!(n%d)) return FALSE;
for (i = 4; i < limit; i +=2) c[i] = TRUE;
d += 4;
}
⚫
p = 3;
while (TRUE) {
p2 = p * p;
if (p2 >= limit) break;
for (i = p2; i < limit; i += 2*p) c[i] = TRUE;
while (TRUE) {
⚫
p += 2;
⚫
if (!c[p]) break;
⚫
}
}
if (primesOnly) {
/* move the actual primes to the front of the array */
c[0] = 2;
for (i = 3, ix = 1; i < limit; i += 2) {
if (!c[i]) c[ix++] = i;
}
}
}
⚫
return TRUE;
}
}


int main() {
int main() {
int count = 0, n = 1;
int i, p, hp, n = 10000000;
int limit = (int)(log(n) * (double)n * 1.2); /* should be more than enough */
int *primes = (int *)calloc(limit, sizeof(int));
primeSieve(primes, limit-1, FALSE, TRUE);
printf("The first 20 pairs of natural numbers whose sum is prime are:\n");
printf("The first 20 pairs of natural numbers whose sum is prime are:\n");
while (count < 20) {
for (i = 1; i <= 20; ++i) {
if (isPrime(2*n + 1)) {
p = primes[i];
printf("%2d + %2d = %2d\n", n, n + 1, 2*n + 1);
hp = p / 2;
count++;
printf("%2d + %2d = %2d\n", hp, hp+1, p);
⚫
}
⚫
n++;
}
}
printf("\nThe 10 millionth such pair is:\n");
p = primes[n];
hp = p / 2;
printf("%2d + %2d = %2d\n", hp, hp+1, p);
free(primes);
return 0;
return 0;
}</lang>
}</lang>
Line 387: Line 410:
35 + 36 = 71
35 + 36 = 71
36 + 37 = 73
36 + 37 = 73

The 10 millionth such pair is:
89712345 + 89712346 = 179424691
</pre>
</pre>


Revision as of 13:02, 6 February 2022

Sum of two adjacent numbers are primes 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


Show on this page the first 20 numbers and sum of two adjacent numbers which sum is prime.

Extra credit

Show the ten millionth such prime sum.

ALGOL 68

Library: ALGOL 68-primes

<lang algol68>BEGIN # find the first 20 primes which are n + ( n + 1 ) for some n # 

   PR read "primes.incl.a68" PR           # include prime utilities #
   []BOOL prime = PRIMESIEVE 200;         # should be enough primes #
   INT p count := 0;
   FOR n WHILE p count < 20 DO
       INT n1 = n + 1;
       INT p  = n + n1;
       IF prime[ p ] THEN
           p count +:= 1;
           print( ( whole( n, -2 ), " + ", whole( n1, -2 ), " = ", whole( p, -3 ), newline ) )
       FI
   OD

END</lang>

Output:
 1 +  2 =   3
 2 +  3 =   5
 3 +  4 =   7
 5 +  6 =  11
 6 +  7 =  13
 8 +  9 =  17
 9 + 10 =  19
11 + 12 =  23
14 + 15 =  29
15 + 16 =  31
18 + 19 =  37
20 + 21 =  41
21 + 22 =  43
23 + 24 =  47
26 + 27 =  53
29 + 30 =  59
30 + 31 =  61
33 + 34 =  67
35 + 36 =  71
36 + 37 =  73

AWK

<lang AWK>

  1. syntax: GAWK -f SUM_OF_TWO_ADJACENT_NUMBERS_ARE_PRIMES.AWK

BEGIN { 

   n = 1
   stop = 20
   printf("The first %d pairs of numbers whose sum is prime:\n",stop)
   while (count < stop) {
     if (is_prime(2*n + 1)) {
       printf("%2d + %2d = %2d\n",n,n+1,2*n+1)
       count++
     }
     n++
   }
   exit(0)

} function is_prime(n, d) { 

   d = 5
   if (n < 2) { return(0) }
   if (n % 2 == 0) { return(n == 2) }
   if (n % 3 == 0) { return(n == 3) }
   while (d*d <= n) {
     if (n % d == 0) { return(0) }
     d += 2
     if (n % d == 0) { return(0) }
     d += 4
   }
   return(1)

} </lang>

Output:
The first 20 pairs of numbers whose sum is prime:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73


BASIC

BASIC256

Translation of: FreeBASIC

<lang BASIC256>function isPrime(v) if v < 2 then return False if v mod 2 = 0 then return v = 2 if v mod 3 = 0 then return v = 3 d = 5 while d * d <= v if v mod d = 0 then return False else d += 2 end while return True end function

n = 0 num = 0

print "The first 20 pairs of numbers whose sum is prime:" while True n += 1 suma = 2*n+1 if isPrime(suma) then num += 1 if num < 21 then print n; " + "; (n+1); " = "; suma else exit while end if end if end while end</lang>

Output:
Igual que la entrada de FreeBASIC.

FreeBASIC

<lang freebasic>Function isPrime(Byval ValorEval As Integer) As Boolean 

   If ValorEval <= 1 Then Return False
   For i As Integer = 2 To Int(Sqr(ValorEval))
       If ValorEval Mod i = 0 Then Return False
   Next i
   Return True

End Function

Dim As Integer n = 0, num = 0, suma print "The first 20 pairs of numbers whose sum is prime:" Do 

   n += 1
   suma = 2*n+1
   If isPrime(suma) Then
       num += 1
       If num < 21 Then
           Print using "## + ## = ##"; n; (n+1); suma
       Else
           Exit Do
       End If
   End If

Loop Sleep</lang>

Output:
The first 20 pairs of numbers whose sum is prime:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

PureBasic

<lang PureBasic>Procedure isPrime(v.i) 

 If     v <= 1    : ProcedureReturn #False
 ElseIf v < 4     : ProcedureReturn #True
 ElseIf v % 2 = 0 : ProcedureReturn #False
 ElseIf v < 9     : ProcedureReturn #True
 ElseIf v % 3 = 0 : ProcedureReturn #False
 Else
   Protected r = Round(Sqr(v), #PB_Round_Down)
   Protected f = 5
   While f <= r
     If v % f = 0 Or v % (f + 2) = 0
       ProcedureReturn #False
     EndIf
     f + 6
   Wend
 EndIf
 ProcedureReturn #True

EndProcedure

If OpenConsole() Define n.i = 0, num.i = 0, suma.i

PrintN("The first 20 pairs of numbers whose sum is prime:") Repeat n + 1 suma = 2*n+1 If isPrime(suma) num + 1 If num < 21 PrintN(Str(n) + " + " + Str(n+1) + " = " + Str(suma)) Else Break EndIf EndIf ForEver CloseConsole() EndIf</lang>

Output:
Igual que la entrada de FreeBASIC.

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Translation of: FreeBASIC

<lang qbasic>FUNCTION isPrime (ValorEval) 

   IF ValorEval <= 1 THEN isPrime = 0
   FOR i = 2 TO INT(SQR(ValorEval))
       IF ValorEval MOD i = 0 THEN isPrime = 0
   NEXT i
   isPrime = 1

END FUNCTION

n = 0 num = 0 PRINT "The first 20 pairs of numbers whose sum is prime:" DO 

   n = n + 1
   suma = 2 * n + 1
   IF isPrime(suma) THEN
       num = num + 1
       IF num < 21 THEN
           PRINT USING "## + ## = ##"; n; (n + 1); suma
       ELSE
           EXIT DO
       END IF
   END IF

LOOP END</lang>

Output:
Igual que la entrada de FreeBASIC.

True BASIC

<lang qbasic>FUNCTION isPrime (ValorEval) 

   IF ValorEval <= 1 THEN LET isPrime = 0
   FOR i = 2 TO INT(SQR(ValorEval))
       IF MOD(ValorEval, i) = 0 THEN LET isPrime = 0
   NEXT i
   LET isPrime = 1

END FUNCTION

LET n = 0 LET num = 0 PRINT "The first 20 pairs of numbers whose sum is prime:" DO 

  LET n = n + 1
  LET suma = 2 * n + 1
  IF isPrime(suma) = 1 THEN
     LET num = num + 1
     IF num < 21 THEN
        PRINT USING "##": n;
        PRINT " + ";
        PRINT USING "##": n+1;
        PRINT " = ";
        PRINT USING "##": suma
     ELSE
        EXIT DO
     END IF
  END IF

LOOP END</lang>

Output:
Igual que la entrada de FreeBASIC.

Yabasic

<lang yabasic>sub isPrime(v) 

   if v < 2 then return False : fi
   if mod(v, 2) = 0 then return v = 2 : fi
   if mod(v, 3) = 0 then return v = 3 : fi
   d = 5
   while d * d <= v
       if mod(v, d) = 0 then return False else d = d + 2 : fi
   wend
   return True

end sub

n = 0 num = 0 print "The first 20 pairs of numbers whose sum is prime:" do 

   n = n + 1
   suma = 2*n+1
   if isPrime(suma) then
       num = num + 1
       if num < 21 then
           print n using "##", " + ", (n+1) using "##", " = ", suma using "##"
       else
           break
       end if
   end if

loop end</lang>

Output:
Igual que la entrada de FreeBASIC.


C

Translation of: Go

<lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. include <math.h>
  1. define TRUE 1
  2. define FALSE 0

typedef int bool;

void primeSieve(int *c, int limit, bool processEven, bool primesOnly) { 

   int i, ix, p, p2;
   limit++;
   c[0] = TRUE;
   c[1] = TRUE;
   if (processEven) {
       for (i = 4; i < limit; i +=2) c[i] = TRUE;
   }
   p = 3;
   while (TRUE) {
       p2 = p * p;
       if (p2 >= limit) break;
       for (i = p2; i < limit; i += 2*p) c[i] = TRUE;
       while (TRUE) {
           p += 2;
           if (!c[p]) break;
       }
   }
   if (primesOnly) {
       /* move the actual primes to the front of the array */
       c[0] = 2;
       for (i = 3, ix = 1; i < limit; i += 2) {
           if (!c[i]) c[ix++] = i;
       }
   }

}

int main() { 

   int i, p, hp, n = 10000000;
   int limit = (int)(log(n) * (double)n * 1.2);  /* should be more than enough */
   int *primes = (int *)calloc(limit, sizeof(int));
   primeSieve(primes, limit-1, FALSE, TRUE);
   printf("The first 20 pairs of natural numbers whose sum is prime are:\n");
   for (i = 1; i <= 20; ++i) {
       p = primes[i];
       hp = p / 2;
       printf("%2d + %2d = %2d\n", hp, hp+1, p);
   }
   printf("\nThe 10 millionth such pair is:\n");
   p = primes[n];
   hp = p / 2;
   printf("%2d + %2d = %2d\n", hp, hp+1, p);
   free(primes);
   return 0;

}</lang>

Output:
The first 20 pairs of natural numbers whose sum is prime are:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

The 10 millionth such pair is:
89712345 + 89712346 = 179424691

F#

This task uses Extensible Prime Generator (F#) <lang fsharp> // 2n+1 is prime. Nigel Galloway: Januuary 22nd., 2022 primes32()|>Seq.skip 1|>Seq.take 20|>Seq.map(fun n->n/2)|>Seq.iteri(fun n g->printfn "%2d: %2d + %2d=%d" (n+1) g (g+1) (g+g+1)) </lang>

Output:
 1:  1 +  2=3
 2:  2 +  3=5
 3:  3 +  4=7
 4:  5 +  6=11
 5:  6 +  7=13
 6:  8 +  9=17
 7:  9 + 10=19
 8: 11 + 12=23
 9: 14 + 15=29
10: 15 + 16=31
11: 18 + 19=37
12: 20 + 21=41
13: 21 + 22=43
14: 23 + 24=47
15: 26 + 27=53
16: 29 + 30=59
17: 30 + 31=61
18: 33 + 34=67
19: 35 + 36=71
20: 36 + 37=73

Factor

Works with: Factor version 0.99 2021-06-02

<lang factor>USING: arrays formatting kernel lists lists.lazy math math.primes.lists sequences ;

20 lprimes cdr [ 2/ dup 1 + 2array ] lmap-lazy ltake [ dup sum suffix "%d + %d = %d\n" vprintf ] leach</lang>

Output:
1 + 2 = 3
2 + 3 = 5
3 + 4 = 7
5 + 6 = 11
6 + 7 = 13
8 + 9 = 17
9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

Go

Library: Go-rcu

<lang go>package main

import ( 

   "fmt"
   "math"
   "rcu"

)

func main() { 

   limit := int(math.Log(1e7) * 1e7 * 1.2) // should be more than enough
   primes := rcu.Primes(limit)
   fmt.Println("The first 20 pairs of natural numbers whose sum is prime are:")
   for i := 1; i <= 20; i++ {
       p := primes[i]
       hp := p / 2
       fmt.Printf("%2d + %2d = %2d\n", hp, hp+1, p)
   }
   fmt.Println("\nThe 10 millionth such pair is:")
   p := primes[1e7]
   hp := p / 2
   fmt.Printf("%2d + %2d = %2d\n", hp, hp+1, p)

}</lang>

Output:
The first 20 pairs of natural numbers whose sum is prime are:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

The 10 millionth such pair is:
89712345 + 89712346 = 179424691

J

Here, we generate the first 20 odd primes, divide by 2, drop the fractional part and add 0 and 1 to that value. Then we format that pair of numbers with their sum and with decorations indicating the relevant arithmetic:

<lang J> (+/,&":'=',{.,&":'+',&":{:)"#. 0 1+/~<.-: p:1+i.20 3=1+2 5=2+3 7=3+4 11=5+6 13=6+7 17=8+9 19=9+10 23=11+12 29=14+15 31=15+16 37=18+19 41=20+21 43=21+22 47=23+24 53=26+27 59=29+30 61=30+31 67=33+34 71=35+36 73=36+37</lang>

Julia

<lang julia>using Lazy using Primes

seq = @>> Lazy.range() filter(n -> isprime(2n + 1)) for n in take(20, seq) 

   println("$n + $(n + 1) = $(n + n + 1)")

end

let 

   i, cnt = 0, 0
   while cnt < 10_000_000
       i += 1
       if isprime(2i + 1)
           cnt += 1
       end
   end
   println("Ten millionth: $i + $(i + 1) = $(i + i + 1)")

end

</lang>

Output:
1 + 2 = 3
2 + 3 = 5
3 + 4 = 7
5 + 6 = 11
6 + 7 = 13
8 + 9 = 17
9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73
Ten millionth: 89712345 + 89712346 = 179424691

Perl

Library: ntheory

<lang perl>use strict; use warnings; use ntheory 'is_prime';

my($n,$c); while () { is_prime(1 + 2*++$n) and printf "%2d + %2d = %2d\n", $n, $n+1, 1+2*$n and ++$c == 20 and last }</lang>

Output:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

Phix

Every prime p greater than 2 is odd, hence p/2 is k.5 and the adjacent numbers needed are k and k+1. DOH. 

with javascript_semantics
procedure doh(integer p)
    printf(1,"%d + %d = %d\n",{floor(p/2),ceil(p/2),p})
end procedure
papply(get_primes(-21)[2..$],doh)
doh(get_prime(1e7+1))
Output:
1 + 2 = 3
2 + 3 = 5
3 + 4 = 7
5 + 6 = 11
6 + 7 = 13
8 + 9 = 17
9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73
89712345 + 89712346 = 179424691


Python

<lang python>#!/usr/bin/python

def isPrime(n): 

   for i in range(2, int(n**0.5) + 1):
       if n % i == 0:
           return False        
   return True

if __name__ == "__main__": 

   n = 0
   num = 0

   print('The first 20 pairs of numbers whose sum is prime:') 
   while True:
       n += 1
       suma = 2*n+1
       if isPrime(suma):
           num += 1
           if num < 21:
               print('{:2}'.format(n), "+", '{:2}'.format(n+1), "=", '{:2}'.format(suma))
           else:
               break</lang>
Output:
The first 20 pairs of numbers whose sum is prime:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73


Raku

<lang perl6>my @n-n1-triangular = map { $_, $_ + 1, $_ + ($_ + 1) }, ^Inf;

my @wanted = @n-n1-triangular.grep: *.[2].is-prime;

printf "%2d + %2d = %2d\n", |.list for @wanted.head(20);</lang>

Output:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

Ring

<lang ring> load "stdlibcore.ring" see "working..." + nl n = 0 num = 0

while true 

    n++
    sum = 2*n+1
    if isprime(sum)
       num++
       if num < 21
         ? "" + n + " + " + (n+1) + " = " + sum
       else
         exit
       ok
     ok

end

see "done..." + nl </lang>

Output:
working...
1 + 2 = 3
2 + 3 = 5
3 + 4 = 7
5 + 6 = 11
6 + 7 = 13
8 + 9 = 17
9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73
done...

Wren

Translation of: Go
Library: Wren-math
Library: Wren-fmt

<lang ecmascript>import "./math" for Int import "./fmt" for Fmt

var limit = (1e7.log * 1e7 * 1.2).floor // should be more than enough var primes = Int.primeSieve(limit) System.print("The first 20 pairs of natural numbers whose sum is prime are:") for (i in 1..20) { 

   var p = primes[i]
   var hp = (p/2).floor
   Fmt.print("$2d + $2d = $2d", hp, hp + 1, p)

} System.print("\nThe 10 millionth such pair is:") var p = primes[1e7] var hp = (p/2).floor Fmt.print("$2d + $2d = $2d", hp, hp + 1, p)</lang>

Output:
The first 20 pairs of natural numbers whose sum is prime are:
 1 +  2 =  3
 2 +  3 =  5
 3 +  4 =  7
 5 +  6 = 11
 6 +  7 = 13
 8 +  9 = 17
 9 + 10 = 19
11 + 12 = 23
14 + 15 = 29
15 + 16 = 31
18 + 19 = 37
20 + 21 = 41
21 + 22 = 43
23 + 24 = 47
26 + 27 = 53
29 + 30 = 59
30 + 31 = 61
33 + 34 = 67
35 + 36 = 71
36 + 37 = 73

The 10 millionth such pair is:
89712345 + 89712346 = 179424691

XPL0

Translation of: Ring

<lang XPL0> include xpllib; int N, Num, Sum; [Text(0, "Working...^M^J"); N:= 0; Num:= 0; loop 

   [N:= N+1;
   Sum:= 2*N + 1;
   if IsPrime(Sum) then
       [Num:= Num+1;
       if Num < 21 then
         [Text(0,"N = "); IntOut(0,N); Text(0,"  Sum = "); IntOut(0,Sum); CrLf(0)]
       else
         quit
       ]
   ];

Text(0, "Done...^M^J"); ]</lang>

Output:
Working...
N = 1  Sum = 3
N = 2  Sum = 5
N = 3  Sum = 7
N = 5  Sum = 11
N = 6  Sum = 13
N = 8  Sum = 17
N = 9  Sum = 19
N = 11  Sum = 23
N = 14  Sum = 29
N = 15  Sum = 31
N = 18  Sum = 37
N = 20  Sum = 41
N = 21  Sum = 43
N = 23  Sum = 47
N = 26  Sum = 53
N = 29  Sum = 59
N = 30  Sum = 61
N = 33  Sum = 67
N = 35  Sum = 71
N = 36  Sum = 73
Done...
Retrieved from "https://rosettacode.org/wiki/Sum_of_two_adjacent_numbers_are_primes?oldid=319077"