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)

# Special neighbor primes

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

Let   (p1,  p2)   are neighbor primes.

Find and show here in base ten if   p1+ p2 -1   is prime,   where   p1,   p2  <  100.

## Action!

`INCLUDE "H6:SIEVE.ACT" INT FUNC GetNextPrime(INT i BYTE ARRAY primes)  DO    i==+1  UNTIL primes(i)  ODRETURN (i) PROC Main()  DEFINE MAXPRIME="99"  DEFINE MAX="200"  BYTE ARRAY primes(MAX+1)  INT i,p   Put(125) PutE() ;clear the screen  Sieve(primes,MAX+1)  FOR i=2 TO MAXPRIME  DO    IF primes(i) THEN      p=GetNextPrime(i,primes)      IF p<=MAXPRIME AND primes(i+p-1)=1 THEN        PrintF("%I+%I-1=%I%E",i,p,i+p-1)      FI    FI  ODRETURN`
Output:
```3+5-1=7
5+7-1=11
7+11-1=17
11+13-1=23
13+17-1=29
19+23-1=41
29+31-1=59
31+37-1=67
41+43-1=83
43+47-1=89
61+67-1=127
67+71-1=137
73+79-1=151
```

## ALGOL 68

`BEGIN  # find adjacent primes p1, p2 such that p1 + p2 - 1 is also prime #    PR read "primes.incl.a68" PR    INT max prime = 100;    []BOOL prime    = PRIMESIEVE ( max prime * 2 );                      # sieve the primes to max prime * 2              #    []INT low prime = EXTRACTPRIMESUPTO max prime FROMPRIMESIEVE prime;  # construct a list of the primes up to max prime #    # find the adjacent primes p1, p2 such that p1 + p2 - 1 is prime #    FOR i TO UPB low prime - 1 DO        IF   INT p1 plus p2 minus 1 = ( low prime[ i ] + low prime[ i + 1 ] ) - 1;             prime[ p1 plus p2 minus 1 ]        THEN print( ( "(",         whole( low prime[ i     ], -3 )                    , " +",        whole( low prime[ i + 1 ], -3 )                    , " ) - 1 = ", whole( p1 plus p2 minus 1, -3 )                    , newline                    )                  )        FI    ODEND`
Output:
```(  3 +  5 ) - 1 =   7
(  5 +  7 ) - 1 =  11
(  7 + 11 ) - 1 =  17
( 11 + 13 ) - 1 =  23
( 13 + 17 ) - 1 =  29
( 19 + 23 ) - 1 =  41
( 29 + 31 ) - 1 =  59
( 31 + 37 ) - 1 =  67
( 41 + 43 ) - 1 =  83
( 43 + 47 ) - 1 =  89
( 61 + 67 ) - 1 = 127
( 67 + 71 ) - 1 = 137
( 73 + 79 ) - 1 = 151
```

## AWK

` # syntax: GAWK -f SPECIAL_NEIGHBOR_PRIMES.AWKBEGIN {    start = 3    stop = 99    old_prime = 2    for (n=start; n<=stop; n++) {      if (is_prime(n) && is_prime(old_prime)) {        sum = old_prime + n - 1        if (is_prime(sum)) {          count++          printf("%d,%d -> %d\n",old_prime,n,sum)        }        old_prime = n      }    }    printf("Special neighbor 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:
```3,5 -> 7
5,7 -> 11
7,11 -> 17
11,13 -> 23
13,17 -> 29
19,23 -> 41
29,31 -> 59
31,37 -> 67
41,43 -> 83
43,47 -> 89
61,67 -> 127
67,71 -> 137
73,79 -> 151
Special neighbor primes 3-99: 13
```

## 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 nextprime( int p ) {    int i=0;    if(p==0) return 2;    if(p<3) return p+1;    while(!isprime(++i + p));    return i+p;} int main(void) {    int p1, p2;    for(p1=3;p1<=99;p1+=2) {        p2=nextprime(p1);        if(p2<100&&isprime(p1)&&isprime(p2+p1-1)) {            printf( "%d + %d - 1 = %d\n", p1, p2, p1+p2-1 );        }    }    return 0;}`
Output:
```3 + 5 - 1 = 7
5 + 7 - 1 = 11
7 + 11 - 1 = 17
11 + 13 - 1 = 23
13 + 17 - 1 = 29
19 + 23 - 1 = 41
29 + 31 - 1 = 59
31 + 37 - 1 = 67
41 + 43 - 1 = 83
43 + 47 - 1 = 89
61 + 67 - 1 = 127
67 + 71 - 1 = 137
73 + 79 - 1 = 151

```

## F#

This task uses Extensible Prime Generator (F#)

` // Special neighbor primes. Nigel Galloway: August 6th., 2021pCache|>Seq.pairwise|>Seq.takeWhile(snd>>(>)100)|>Seq.filter(fun(n,g)->isPrime(n+g-1))|>Seq.iter(printfn "%A") `
Output:
```(3, 5)
(5, 7)
(7, 11)
(11, 13)
(13, 17)
(19, 23)
(29, 31)
(31, 37)
(41, 43)
(43, 47)
(61, 67)
(67, 71)
(73, 79)
```

## Factor

Works with: Factor version 0.99 2021-06-02
`USING: kernel lists lists.lazy math math.primesmath.primes.lists prettyprint sequences ; lprimes dup cdr lzip [ sum 1 - prime? ] lfilter[ second 100 < ] lwhile [ . ] leach`
Output:
```{ 3 5 }
{ 5 7 }
{ 7 11 }
{ 11 13 }
{ 13 17 }
{ 19 23 }
{ 29 31 }
{ 31 37 }
{ 41 43 }
{ 43 47 }
{ 61 67 }
{ 67 71 }
{ 73 79 }
```

## Fermat

`Func Nextprime(p) =    q:=1;    while not Isprime(p+q)=1 do        q:=q + 1;    od;    p+q.; for p1 = 3 to 99 by 2 do    p2:=Nextprime(p1);    if p2<100 and Isprime(p1)=1 and Isprime(p1+p2-1) then       !!(p1,' +',p2,' - 1 =',p1+p2-1);    fi;od;`
Output:
```
3 +  5 - 1 =  7
5 +  7 - 1 =  11
7 +  11 - 1 =  17
11 +  13 - 1 =  23
13 +  17 - 1 =  29
19 +  23 - 1 =  41
29 +  31 - 1 =  59
31 +  37 - 1 =  67
41 +  43 - 1 =  83
43 +  47 - 1 =  89
61 +  67 - 1 =  127
67 +  71 - 1 =  137
73 +  79 - 1 =  151

```

## FreeBASIC

`#include"isprime.bas" function nextprime( n as uinteger ) as uinteger    'finds the next prime after n    if n = 0 then return 2    if n < 3 then return n + 1    dim as integer q = n + 2    while not isprime(q)        q+=2    wend    return qend function dim as uinteger p1, p2 for p1 = 3 to 100 step 2    p2 = nextprime(p1)    if isprime(p1) andalso p2<100 andalso isprime( p1 + p2 - 1 ) then        print p1, p2, p1 + p2 - 1    end ifnext p1 `
Output:
```
3             5             7
5             7             11
7             11            17
11            13            23
13            17            29
19            23            41
29            31            59
31            37            67
41            43            83
43            47            89
61            67            127
67            71            137
73            79            151

```

## Go

Translation of: Wren
Library: Go-rcu
`package main import (    "fmt"    "rcu") const MAX = 1e7 - 1 var primes = rcu.Primes(MAX) func specialNP(limit int, showAll bool) {    if showAll {        fmt.Println("Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime:")    }    count := 0    for i := 1; i < len(primes); i++ {        p2 := primes[i]        if p2 >= limit {            break        }        p1 := primes[i-1]        p3 := p1 + p2 - 1        if rcu.IsPrime(p3) {            if showAll {                fmt.Printf("(%2d, %2d) => %3d\n", p1, p2, p3)            }            count++        }    }    ccount := rcu.Commatize(count)    climit := rcu.Commatize(limit)    fmt.Printf("\nFound %s special neighbor primes under %s.\n", ccount, climit)} func main() {    specialNP(100, true)    var pow = 1000    for i := 3; i < 8; i++ {        specialNP(pow, false)        pow *= 10    }}`
Output:
```Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime:
( 3,  5) =>   7
( 5,  7) =>  11
( 7, 11) =>  17
(11, 13) =>  23
(13, 17) =>  29
(19, 23) =>  41
(29, 31) =>  59
(31, 37) =>  67
(41, 43) =>  83
(43, 47) =>  89
(61, 67) => 127
(67, 71) => 137
(73, 79) => 151

Found 13 special neighbor primes under 100.

Found 71 special neighbor primes under 1,000.

Found 367 special neighbor primes under 10,000.

Found 2,165 special neighbor primes under 100,000.

Found 14,526 special neighbor primes under 1,000,000.

Found 103,611 special neighbor primes under 10,000,000.
```

## GW-BASIC

`10 FOR P = 3 TO 99 STEP 220 GOSUB 13030 IF Q = 0 THEN GOTO 11040 GOSUB 22050 IF P2>100 THEN END60 T = P70 P = P2 + T - 180 GOSUB 13090 IF Q = 1 THEN PRINT USING "## + ## - 1 = ###";T;P2;P100 P=T110 NEXT P120 END130 REM tests if a number is prime140 Q=0150 IF P=3 THEN Q=1:RETURN160 I=1170 I=I+1180 IF INT(P/I)*I = P THEN RETURN190 IF I*I<=P THEN GOTO 170200 Q = 1210 RETURN220 REM finds the next prime after P, result in P2230 IF P = 0 THEN P2 = 2: RETURN240 IF P<3 THEN P2 = P + 1: RETURN250 T = P260 P = P + 1270 GOSUB 130280 IF Q = 1 THEN P2 = P: P = T: RETURN290 GOTO 260`
Output:
```
3 + 5 - 1 = 7
5 + 7 - 1 = 11
7 + 11 - 1 = 17
11 + 13 - 1 = 23
13 + 17 - 1 = 29
19 + 23 - 1 = 41
29 + 31 - 1 = 59
31 + 37 - 1 = 67
41 + 43 - 1 = 83
43 + 47 - 1 = 89
61 + 67 - 1 = 127
67 + 71 - 1 = 137
73 + 79 - 1 = 151

```

## jq

Works with: jq

Works with gojq, the Go implementation of jq

This entry uses `is_prime` as defined at Erdős-primes#jq.

`# Assumes . > 2def next_prime:  first(range(.+2; infinite) | select(is_prime)); def specialNP(\$savePairs):  . as \$limit  | {p1: 2, p2: 3}  | until( .p2 >= \$limit;      if (.p1 + .p2 - 1 | is_prime)      then .pcount += 1      | if \$savePairs then .neighbors = .neighbors + [[.p1, .p2]] else . end      else .      end      | .p1 = .p2      | .p2 = (.p1|next_prime)      )  | if \$savePairs then {pcount, neighbors} else {pcount} end; 100|specialNP(true)`
Output:
```{"pcount":13,"neighbors":[[3,5],[5,7],[7,11],[11,13],[13,17],[19,23],[29,31],[31,37],[41,43],[43,47],[61,67],[67,71],[73,79]]}
```

## Julia

`using Primes function specialneighbors(N, savepairs=true)    neighbors, p1, pcount = Pair{Int}[], 2, 0    while (p2 = nextprime(p1 + 1)) < N        if isprime(p2 + p1 - 1)            savepairs && push!(neighbors, p1 => p2)            pcount += 1        end        p1 = p2    end    return neighbors, pcountend spn, n = specialneighbors(100)println("\$n special neighbor prime pairs under 100:")println("p1   p2   p1 + p2 - 1\n--------------------------")for (p1, p2) in specialneighbors(100)[1]    println(lpad(p1, 2), "   ", rpad(p2, 7), p1 + p2 - 1)end print("\nCount of such prime pairs under 1,000,000,000: ",    specialneighbors(1_000_000_000, false)[2]) `
Output:
```13 special neighbor prime pairs under 100:
p1   p2   p1 + p2 - 1
--------------------------
3   5      7
5   7      11
7   11     17
11   13     23
13   17     29
19   23     41
29   31     59
31   37     67
41   43     83
43   47     89
61   67     127
67   71     137
73   79     151

Count of such prime pairs under 1,000,000,000: 6041231
```

## Mathematica/Wolfram Language

`p = [email protected]@PrimePi[100];Select[Partition[p, 2, 1], Total/*(# - 1 &)/*PrimeQ]`
Output:
`{{3, 5}, {5, 7}, {7, 11}, {11, 13}, {13, 17}, {19, 23}, {29, 31}, {31, 37}, {41, 43}, {43, 47}, {61, 67}, {67, 71}, {73, 79}}`

## Nim

`import strutils, sugar const Max = 100 - 1 func isPrime(n: Positive): bool =  if n == 1: return false  if n mod 2 == 0: return n == 2  for d in countup(3, n, 2):    if d * d > n: break    if n mod d == 0: return false  result = true const Primes = collect(newSeq):                 for n in 2..Max:                   if n.isPrime: n let list = collect(newSeq):             for i in 0..<Primes.high:               let p1 = Primes[i]               let p2 = Primes[i + 1]               if (p1 + p2 - 1).isPrime: (p1, p2) echo "Found \$1 special neighbor primes less than \$2:".format(list.len, Max + 1)echo list.join(", ")`
Output:
```Found 13 special neighbor primes less than 100:
(3, 5), (5, 7), (7, 11), (11, 13), (13, 17), (19, 23), (29, 31), (31, 37), (41, 43), (43, 47), (61, 67), (67, 71), (73, 79)```

## PARI/GP

`for(p1=1,100,p2=nextprime(p1+1); if(isprime(p1)&&p2<100&&isprime(p1+p2-1),print(p1," ",p2," ",p1+p2-1)))`

## Perl

`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Special_neighbor_primesuse warnings;use ntheory qw( primes is_prime ); my @primes = @{ primes(100) };for ( 1 .. \$#primes )  {  is_prime( [email protected] = \$primes[\$_-1] + \$primes[\$_] - 1 ) and    printf "%2d + %2d - 1 = %3d\n", \$primes[\$_-1], \$primes[\$_], [email protected];  }`
Output:
``` 3 +  5 - 1 =   7
5 +  7 - 1 =  11
7 + 11 - 1 =  17
11 + 13 - 1 =  23
13 + 17 - 1 =  29
19 + 23 - 1 =  41
29 + 31 - 1 =  59
31 + 37 - 1 =  67
41 + 43 - 1 =  83
43 + 47 - 1 =  89
61 + 67 - 1 = 127
67 + 71 - 1 = 137
73 + 79 - 1 = 151
```

## Phix

```with javascript_semantics
function np(integer n) return is_prime(get_prime(n)+get_prime(n+1)-1) end function
function npt(integer p) return filter(tagset(length(get_primes_le(p))-1),np) end function
sequence s = npt(100)
printf(1,"Found %d special neighbour primes < 100:\n",length(s))
for i=1 to length(s) do
integer si = s[i],
pi = get_prime(si),
pj = get_prime(si+1)
printf(1," (%2d,%2d) => %d\n",{pi,pj,pi+pj-1})
end for
printf(1,"\n")
for i=2 to 7 do
integer p = power(10,i),
l = length(npt(p))
printf(1,"Found %,d special neighbour primes < %,d\n",{l,p})
end for
```
Output:
```Found 13 special neighbour primes < 100:
( 3, 5) => 7
( 5, 7) => 11
( 7,11) => 17
(11,13) => 23
(13,17) => 29
(19,23) => 41
(29,31) => 59
(31,37) => 67
(41,43) => 83
(43,47) => 89
(61,67) => 127
(67,71) => 137
(73,79) => 151

Found 13 special neighbour primes < 100
Found 71 special neighbour primes < 1,000
Found 367 special neighbour primes < 10,000
Found 2,165 special neighbour primes < 100,000
Found 14,526 special neighbour primes < 1,000,000
Found 103,611 special neighbour primes < 10,000,000
```

## Raku

`# 20210809 Raku programming solution  for (grep {.is-prime}, 3..*).rotor(2 => -1) -> (\P1,\P2) {   last if P2 ≥ Ⅽ;   (\$_ = P1+P2-1).is-prime and printf "%2d, %2d => %3d\n", P1, P2, \$_}`
Output:
``` 3,  5 =>   7
5,  7 =>  11
7, 11 =>  17
11, 13 =>  23
13, 17 =>  29
19, 23 =>  41
29, 31 =>  59
31, 37 =>  67
41, 43 =>  83
43, 47 =>  89
61, 67 => 127
67, 71 => 137
73, 79 => 151```

## REXX

A little extra code was added to present the results in a grid-like format.

`/*REXX pgm finds special neighbor primes:  P1, P2, P1+P2-1  are prime, and P1 and P2<100*/parse arg hi cols .                              /*obtain optional argument from the CL.*/if   hi=='' |   hi==","  then   hi=  100         /*Not specified?  Then use the default.*/if cols=='' | cols==","  then cols=    5         /* "      "         "   "   "     "    */call genP hi                                     /*build semaphore array for low primes.*/     do p=1  while @.p<hi     end  /*p*/;           lim= p-1;   q= p+1    /*set LIM to prime for P; calc. 2nd HI.*/#m= # - 1call genP @.# + @.#m  -  1                       /*build semaphore array for high primes*/w= 20                                            /*width of a number in any column.     */title= ' special neighbor primes:  P1, P2, P1+P2-1  are primes,  and P1 and P2 < ' ,                                                                      commas(hi)if cols>0 then say ' index │'center(title,   1 + cols*(w+1)     )if cols>0 then say '───────┼'center(""   ,   1 + cols*(w+1), '─')found= 0;                  idx= 1                /*initialize # neighbor primes & index.*/\$=                                               /*a list of  neighbor  primes (so far).*/     do j=1  to  lim;      jp= j+1;   q= @.jp    /*look for neighbor primes within range*/     y= @.j + q  -  1;     if \!.y  then iterate /*is X also a prime?  No, then skip it.*/     found= found + 1                            /*bump the number of  neighbor primes. */     if cols==0            then iterate          /*Build the list  (to be shown later)? */     \$= \$  right( @.j','q"──►"y, w)              /*add neighbor prime ──► the  \$  list. */     if found//cols\==0  then iterate            /*have we populated a line of output?  */     say center(idx, 7)'│'  substr(\$, 2);   \$=   /*display what we have so far  (cols). */     idx= idx + cols                             /*bump the  index  count for the output*/     end   /*j*/ if \$\==''  then say center(idx, 7)"│"  substr(\$, 2)  /*possible display residual output.*/if cols>0 then say '───────┴'center(""                         ,  1 + cols*(w+1), '─')saysay 'Found '       commas(found)      titleexit 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: !.= 0;            parse arg limit          /*placeholders for primes (semaphores).*/      @.1=2;  @.2=3;  @.3=5;  @.4=7;  @.5=11     /*define some low primes.              */      !.2=1;  !.3=1;  !.5=1;  !.7=1;  !.11=1     /*   "     "   "    "     flags.       */                        #=5;     sq.#= @.# **2   /*number of primes so far;     prime². */                                                 /* [↓]  generate more  primes  ≤  high.*/        do [email protected].#+2  by 2  to limit               /*find odd primes from here on.        */        parse var j '' -1 _;       if    _==5  then iterate  /*J ÷ by 5?  (right digit).*/        if j//3==0  then iterate;  if j//7==0  then iterate  /*" "  " 3?     J ÷ by 7?  */               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 │               special neighbor primes:  P1, P2, P1+P2-1  are primes,  and P1 and P2 <  100
───────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────
1   │              3,5──►7             5,7──►11            7,11──►17           11,13──►23           13,17──►29
6   │           19,23──►41           29,31──►59           31,37──►67           41,43──►83           43,47──►89
11   │          61,67──►127          67,71──►137          73,79──►151
───────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  13  special neighbor primes:  P1, P2, P1+P2-1  are primes,  and P1 and P2 <  100
```

## Ring

` load "stdlib.ring" see "working..." + nlsee "Special neighbor primes are:" + nlrow = 0oldPrime = 2 for n = 3 to 100    if isprime(n) and isprime(oldPrime)        sum = oldPrime + n - 1       if isprime(sum)          row++          see "" + oldPrime + "," + n + " => " + sum + nl       ok       oldPrime = n    oknext see "Found " + row + " special neighbor primes"see "done..." + nl `
Output:
```working...
Special neighbor primes are:
3,5 => 7
5,7 => 11
7,11 => 17
11,13 => 23
13,17 => 29
19,23 => 41
29,31 => 59
31,37 => 67
41,43 => 83
43,47 => 89
61,67 => 127
67,71 => 137
73,79 => 151
Found 13 special neighbor primes
done...
```

## Sidef

`func special_neighbor_primes(upto) {    var list = []    upto.primes.each_cons(2, {|p1,p2|        var n = (p1 + p2 - 1)        if (n.is_prime) {            list << [p1, p2, n]        }    })    return list} with (100) {|n|    var list = special_neighbor_primes(n)    say "Found #{list.len} special neighbour primes < n:"    list.each_2d {|p1,p2,q|        printf(" (%2s, %2s) => %s\n", p1, p2, q)    }} say '' for n in (1..7) {    var list = special_neighbor_primes(10**n)    say "Found #{list.len} special neighbour primes < 10^#{n}"}`
Output:
```Found 13 special neighbour primes < n:
( 3,  5) => 7
( 5,  7) => 11
( 7, 11) => 17
(11, 13) => 23
(13, 17) => 29
(19, 23) => 41
(29, 31) => 59
(31, 37) => 67
(41, 43) => 83
(43, 47) => 89
(61, 67) => 127
(67, 71) => 137
(73, 79) => 151

Found 2 special neighbour primes < 10^1
Found 13 special neighbour primes < 10^2
Found 71 special neighbour primes < 10^3
Found 367 special neighbour primes < 10^4
Found 2165 special neighbour primes < 10^5
Found 14526 special neighbour primes < 10^6
Found 103611 special neighbour primes < 10^7
```

## Tiny BASIC

`    REM B = SECOND OF THE NEIGBOURING PRIMES    REM C = P + B - 1    REM I = index variable    REM P = INPUT TO NEXTPRIME ROUTINE AND ISPRIME ROUTINE, also first of the two primes    REM T = Temporary variable, multiple uses    REM Z = OUTPUT OF ISPRIME, 1=prime, 0=not     LET P = 1 20 LET P = P + 2    IF P > 100 THEN END    GOSUB 100    IF Z = 0 THEN GOTO 20    GOSUB 120    IF B > 100 THEN END    LET T = P    LET P = P + B - 1    GOSUB 100    LET C = P    LET P = T    IF Z = 0 THEN GOTO 20    PRINT P," + ",B," - 1 = ", C    GOTO 20 100 REM PRIMALITY BY TRIAL DIVISION    LET Z = 1    LET I = 2110 IF (P/I)*I = P THEN LET Z = 0    IF Z = 0 THEN RETURN    LET I = I + 1    IF I*I <= P THEN GOTO 110    RETURN 120 REM next prime after P    IF P < 2 THEN LET B = 2    IF P = 2 THEN LET B = 3    IF P < 3 THEN RETURN    LET T = P130 LET P = P + 1    GOSUB 100    IF Z = 1 THEN GOTO 140    GOTO 130140 LET B = P    LET P = T    RETURN`
Output:
```
3 + 5 - 1 = 7
5 + 7 - 1 = 11
7 + 11 - 1 = 17
11 + 13 - 1 = 23
13 + 17 - 1 = 29
19 + 23 - 1 = 41
29 + 31 - 1 = 59
31 + 37 - 1 = 67
41 + 43 - 1 = 83
43 + 47 - 1 = 89
61 + 67 - 1 = 127
67 + 71 - 1 = 137
73 + 79 - 1 = 151

```

## Wren

Library: Wren-math
Library: Wren-fmt

I assume that 'neighbor' primes means pairs of successive primes.

Anticipating a likely stretch goal.

`import "/math" for Intimport "/fmt" for Fmt var max = 1e7 - 1var primes = Int.primeSieve(max) var specialNP = Fn.new { |limit, showAll|    if (showAll) System.print("Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime:")    var count = 0    var p3    for (i in 1...primes.where { |p| p < limit }.count) {        var p2 = primes[i]        var p1 = primes[i-1]        if (Int.isPrime(p3 = p1 + p2 - 1)) {            if (showAll) Fmt.print("(\$2d, \$2d) => \$3d", p1, p2, p3)            count = count + 1        }    }    Fmt.print("\nFound \$,d special neighbor primes under \$,d.", count, limit)} specialNP.call(100, true)for (i in 3..7) {    specialNP.call(10.pow(i), false)}`
Output:
```Neighbor primes, p1 and p2, where p1 + p2 - 1 is prime:
( 3,  5) =>   7
( 5,  7) =>  11
( 7, 11) =>  17
(11, 13) =>  23
(13, 17) =>  29
(19, 23) =>  41
(29, 31) =>  59
(31, 37) =>  67
(41, 43) =>  83
(43, 47) =>  89
(61, 67) => 127
(67, 71) => 137
(73, 79) => 151

Found 13 special neighbor primes under 100.

Found 71 special neighbor primes under 1,000.

Found 367 special neighbor primes under 10,000.

Found 2,165 special neighbor primes under 100,000.

Found 14,526 special neighbor primes under 1,000,000.

Found 103,611 special neighbor primes under 10,000,000.
```

## 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 P, P1, P2;[P:= 2;loop    [P1:= P;        repeat  P:= P+1;                if P >= 100 then quit;        until   IsPrime(P);        P2:= P;        if IsPrime(P1+P2-1) then                [IntOut(0, P1);  ChOut(0, ^ );                 IntOut(0, P2);  ChOut(0, ^ );                 IntOut(0, P1+P2-1);  CrLf(0);                ];        ];]`
Output:
```3 5 7
5 7 11
7 11 17
11 13 23
13 17 29
19 23 41
29 31 59
31 37 67
41 43 83
43 47 89
61 67 127
67 71 137
73 79 151
```