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

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.

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

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

` # syntax: GAWK -f SUM_OF_TWO_ADJACENT_NUMBERS_ARE_PRIMES.AWKBEGIN {    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)} `
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
`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 Trueend function n = 0num = 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 ifend whileend`
Output:
```Igual que la entrada de FreeBASIC.
```

### 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 TrueEnd Function Dim As Integer n = 0, num = 0, sumaprint "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 IfLoopSleep`
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

`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 #TrueEndProcedure 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`
Output:
```Igual que la entrada de FreeBASIC.
```

### QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Translation of: FreeBASIC
`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 = 1END FUNCTION n = 0num = 0PRINT "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 IFLOOPEND`
Output:
```Igual que la entrada de FreeBASIC.
```

### True BASIC

`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 = 1END FUNCTION LET n = 0LET num = 0PRINT "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 IFLOOPEND`
Output:
```Igual que la entrada de FreeBASIC.
```

### 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 Trueend sub n = 0num = 0print "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 ifloopend`
Output:
```Igual que la entrada de FreeBASIC.
```

## C

Translation of: Go
`#include <stdio.h>#include <stdlib.h>#include <math.h> #define TRUE 1#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;}`
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#)

` // 2n+1 is prime. Nigel Galloway: Januuary 22nd., 2022primes32()|>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)) `
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
`USING: arrays formatting kernel lists lists.lazy mathmath.primes.lists sequences ; 20 lprimes cdr [ 2/ dup 1 + 2array ] lmap-lazy ltake[ dup sum suffix "%d + %d = %d\n" vprintf ] leach`
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
`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)}`
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:

`   (+/,&":'=',{.,&":'+',&":{:)"#. 0 1+/~<.-: p:1+i.203=1+2   5=2+3   7=3+4   11=5+6  13=6+7  17=8+9  19=9+10 23=11+1229=14+1531=15+1637=18+1941=20+2143=21+2247=23+2453=26+2759=29+3061=30+3167=33+3471=35+3673=36+37`

## jq

Works with: jq

Works with gojq, the Go implementation of jq

This entry uses a memory-less approach to computing `is_prime`, and so a naive approach to computing the first 20 numbers satisfying the condition is appropriate.

`def is_prime:  . as \$n  | if (\$n < 2)         then false    elif (\$n % 2 == 0)  then \$n == 2    elif (\$n % 3 == 0)  then \$n == 3    else 5    | until( . <= 0;        if .*. > \$n then -1	elif (\$n % . == 0) then 0        else . + 2        |  if (\$n % . == 0) then 0           else . + 4           end        end)    | . == -1    end; def naive:  limit(20;    range(0; infinite) as \$i    | (2*\$i + 1) as \$q    | select(\$q | is_prime)    | "\(\$i) + \(\$i + 1) = \(\$q)" ); naive`
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
```

## Julia

`using Lazyusing 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 `
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
`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 }`
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

`#!/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`
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

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

` load "stdlibcore.ring"see "working..." + nln = 0num = 0 while true     n++     sum = 2*n+1     if isprime(sum)        num++        if num < 21          ? "" + n + " + " + (n+1) + " = " + sum        else          exit        ok      okend see "done..." + nl `
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...
```

## Sidef

`var wanted = (1..Inf -> lazy.map  {|n| [n, n+1, n+(n+1)] }\                            .grep { .tail.is_prime }) wanted.first(20).each_2d {|a,b,c|    printf("%2d + %2d = %2d\n", a,b,c)}`
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
```

## Wren

Translation of: Go
Library: Wren-math
Library: Wren-fmt
`import "./math" for Intimport "./fmt" for Fmt var limit = (1e7.log * 1e7 * 1.2).floor  // should be more than enoughvar 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).floorFmt.print("\$2d + \$2d = \$2d", hp, hp + 1, p)`
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
` 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");]`
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...
```