Rosetta Code

Special neighbor primes: Difference between revisions

Page Discussion

Special neighbor primes (view source)

Revision as of 14:44, 21 April 2024

9,681 bytes added ,  28 days ago
m
→‎{{header|PL/M}}: tweak - Q must be odd
(add tinybasic)
m (→‎{{header|PL/M}}: tweak - Q must be odd)
 
(21 intermediate revisions by 14 users not shown)
Line 2:
 
;Task:
Let &nbsp; ('''p<sub>1</sub>''', &nbsp;'''p<sub>2</sub>''') &nbsp; are [[Neighbour_primes|neighbor primes]].
 
Find and show here in base ten if &nbsp; '''p<sub>1</sub>+&nbsp;p<sub>2</sub>&nbsp;-1''' &nbsp; is prime, &nbsp; where &nbsp; '''p<sub>1</sub>, &nbsp; p<sub>2</sub> &nbsp;&lt;&nbsp; 100'''.
<br><br>
 
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">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
 
V primes = (0.<100).filter(n -> is_prime(n))
 
L(i) 0 .< primes.len - 1
V p1 = primes[i]
V p2 = primes[i + 1]
I is_prime(p1 + p2 - 1)
print((p1, p2))</syntaxhighlight>
 
{{out}}
<pre>
(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)
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"
 
INT FUNC GetNextPrime(INT i BYTE ARRAY primes)
DO
i==+1
UNTIL primes(i)
OD
RETURN (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
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Special_neighbor_primes.png Screenshot from Atari 8-bit computer]
<pre>
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
</pre>
 
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
Very similar to [[Neighbour_primes#ALGOL_68|The ALGOL 68 sample in the Neighbour primes task]]
<lang algol68>BEGIN # find adjacent primes p1, p2 such that p1 + p2 - 1 is also prime #
<syntaxhighlight lang="algol68">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; # constructget 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
Line 26 ⟶ 112:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 43 ⟶ 129:
( 73 + 79 ) - 1 = 151
</pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">primesBelow100: select 1..100 => prime?
 
loop 1..dec size primesBelow100 'p [
p1: primesBelow100\[p-1]
p2: primesBelow100\[p]
if prime? dec p1 + p2 ->
print ["(" p1 "," p2 ")"]
]</syntaxhighlight>
 
{{out}}
 
<pre>( 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 )</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SPECIAL_NEIGHBOR_PRIMES.AWK
BEGIN {
Line 75 ⟶ 187:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 92 ⟶ 204:
73,79 -> 151
Special neighbor primes 3-99: 13
</pre>
 
=={{header|BASIC}}==
==={{header|FreeBASIC}}===
<syntaxhighlight lang="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 q
end 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 if
next p1
</syntaxhighlight>
{{out}}<pre>
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
</pre>
 
==={{header|GW-BASIC}}===
{{works with|BASICA}}
<syntaxhighlight lang="gwbasic">10 FOR P = 3 TO 99 STEP 2
20 GOSUB 130
30 IF Q = 0 THEN GOTO 110
40 GOSUB 220
50 IF P2>100 THEN END
60 T = P
70 P = P2 + T - 1
80 GOSUB 130
90 IF Q = 1 THEN PRINT USING "## + ## - 1 = ###";T;P2;P
100 P=T
110 NEXT P
120 END
130 REM tests if a number is prime
140 Q=0
150 IF P=3 THEN Q=1:RETURN
160 I=1
170 I=I+1
180 IF INT(P/I)*I = P THEN RETURN
190 IF I*I<=P THEN GOTO 170
200 Q = 1
210 RETURN
220 REM finds the next prime after P, result in P2
230 IF P = 0 THEN P2 = 2: RETURN
240 IF P<3 THEN P2 = P + 1: RETURN
250 T = P
260 P = P + 1
270 GOSUB 130
280 IF Q = 1 THEN P2 = P: P = T: RETURN
290 GOTO 260</syntaxhighlight>
{{out}}
<pre> 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
</pre>
 
==={{header|Tiny BASIC}}===
<syntaxhighlight lang="tinybasic"> 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 = 2
110 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 = P
130 LET P = P + 1
GOSUB 100
IF Z = 1 THEN GOTO 140
GOTO 130
140 LET B = P
LET P = T
RETURN</syntaxhighlight>
{{out}}<pre>
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
</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
 
Line 125 ⟶ 385:
}
return 0;
}</langsyntaxhighlight>
{{out}}<pre>3 + 5 - 1 = 7
5 + 7 - 1 = 11
Line 140 ⟶ 400:
73 + 79 - 1 = 151
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Uses the [[Extensible_prime_generator#Delphi|Delphi Prime-Generator Object]]
 
 
<syntaxhighlight lang="Delphi">
procedure SpecialNeighborPrimes(Memo: TMemo);
var I: integer;
var P1,P2: integer;
var Sieve: TPrimeSieve;
begin
Sieve:=TPrimeSieve.Create;
try
{Build more primes than we need}
Sieve.Intialize(200);
{Go through all primes}
for I:=1 to High(Sieve.Primes) do
begin
{Get neighbor primes}
P1:=Sieve.Primes[I-1];
P2:=Sieve.Primes[I];
{only test up to 100}
if P2>=100 then break;
{if P1+P2-1 is prime then display}
if Sieve.Flags[P1 + P2 - 1] then Memo.Lines.Add(Format('(%d, %d)',[P1,P2]));
end;
finally Sieve.Free; end;
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
(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)
Elapsed Time: 9.926 ms.
 
</pre>
 
 
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<langsyntaxhighlight lang="fsharp">
// Special neighbor primes. Nigel Galloway: August 6th., 2021
pCache|>Seq.pairwise|>Seq.takeWhile(snd>>(>)100)|>Seq.filter(fun(n,g)->isPrime(n+g-1))|>Seq.iter(printfn "%A")
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 167 ⟶ 479:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: kernel lists lists.lazy math math.primes
math.primes.lists prettyprint sequences ;
 
lprimes dup cdr lzip [ sum 1 - prime? ] lfilter
[ second 100 < ] lwhile [ . ] leach</langsyntaxhighlight>
{{out}}
<pre>
Line 190 ⟶ 502:
 
=={{header|Fermat}}==
<langsyntaxhighlight lang="fermat">Func Nextprime(p) =
q:=1;
while not Isprime(p+q)=1 do
Line 202 ⟶ 514:
!!(p1,' +',p2,' - 1 =',p1+p2-1);
fi;
od;</langsyntaxhighlight>
{{out}}<pre>
3 + 5 - 1 = 7
Line 217 ⟶ 529:
67 + 71 - 1 = 137
73 + 79 - 1 = 151
</pre>
 
=={{header|FreeBASIC}}==
<lang 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 q
end 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 if
next p1
</lang>
{{out}}<pre>
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
</pre>
 
Line 261 ⟶ 534:
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 303 ⟶ 576:
pow *= 10
}
}</langsyntaxhighlight>
 
{{out}}
Line 335 ⟶ 608:
</pre>
 
=={{header|GW-BASICJ}}==
<syntaxhighlight lang="j"> (#~ 1 p: {:"1) 2 (, _1 + +/)\ i.&.(p:inv) 100
<lang gwbasic>10 FOR P = 3 TO 99 STEP 2
3 5 7
20 GOSUB 130
5 7 11
30 IF Q = 0 THEN GOTO 110
7 11 17
40 GOSUB 220
11 13 23
50 IF P2>100 THEN END
6013 T17 = P29
19 23 41
70 P = P2 + T - 1
29 31 59
80 GOSUB 130
31 37 67
90 IF Q = 1 THEN PRINT USING "## + ## - 1 = ###";T;P2;P
41 43 83
100 P=T
43 47 89
110 NEXT P
61 67 127
120 END
67 71 137
130 REM tests if a number is prime
73 79 151</syntaxhighlight>
140 Q=0
 
150 IF P=3 THEN Q=1:RETURN
160 I=1
170 I=I+1
180 IF INT(P/I)*I = P THEN RETURN
190 IF I*I<=P THEN GOTO 170
200 Q = 1
210 RETURN
220 REM finds the next prime after P, result in P2
230 IF P = 0 THEN P2 = 2: RETURN
240 IF P<3 THEN P2 = P + 1: RETURN
250 T = P
260 P = P + 1
270 GOSUB 130
280 IF Q = 1 THEN P2 = P: P = T: RETURN
290 GOTO 260</lang>
{{out}}<pre>
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
</pre>
=={{header|jq}}==
{{works with|jq}}
Line 385 ⟶ 629:
 
This entry uses `is_prime` as defined at [[Erd%C5%91s-primes#jq]].
<langsyntaxhighlight lang="jq"># Assumes . > 2
def next_prime:
first(range(.+2; infinite) | select(is_prime));
Line 403 ⟶ 647:
| if $savePairs then {pcount, neighbors} else {pcount} end;
 
100|specialNP(true)</langsyntaxhighlight>
{{out}}
<pre>
Line 410 ⟶ 654:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function specialneighbors(N, savepairs=true)
Line 433 ⟶ 677:
print("\nCount of such prime pairs under 1,000,000,000: ",
specialneighbors(1_000_000_000, false)[2])
</langsyntaxhighlight>{{out}}
<pre>
13 special neighbor prime pairs under 100:
Line 456 ⟶ 700:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">p = Prime@Range@PrimePi[100];
Select[Partition[p, 2, 1], Total/*(# - 1 &)/*PrimeQ]</langsyntaxhighlight>
{{out}}
<pre>{{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}}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils, sugar
 
const Max = 100 - 1
Line 485 ⟶ 729:
 
echo "Found $1 special neighbor primes less than $2:".format(list.len, Max + 1)
echo list.join(", ")</langsyntaxhighlight>
 
{{out}}
Line 492 ⟶ 736:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">for(p1=1,100,p2=nextprime(p1+1); if(isprime(p1)&&p2<100&&isprime(p1+p2-1),print(p1," ",p2," ",p1+p2-1)))</langsyntaxhighlight>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Special_neighbor_primes
Line 506 ⟶ 750:
is_prime( $@ = $primes[$_-1] + $primes[$_] - 1 ) and
printf "%2d + %2d - 1 = %3d\n", $primes[$_-1], $primes[$_], $@;
}</langsyntaxhighlight>
{{out}}
<pre>
Line 525 ⟶ 769:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">np</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)+</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
Line 543 ⟶ 787:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Found %,d special neighbour primes &lt; %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">l</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 568 ⟶ 812:
Found 103,611 special neighbour primes < 10,000,000
</pre>
 
 
=={{header|PL/0}}==
PL/0 can only output a single integer per line, so to avoid confusing output, this sample just shows the first prime of each pair.
<br>
This is almost identical to the [[Neighbour primes#PL/0|PL/0 sample in the Neighbour primes task]]
<syntaxhighlight lang="pascal">
var n, p1, p2, prime;
procedure isnprime;
var p;
begin
prime := 1;
if n < 2 then prime := 0;
if n > 2 then begin
prime := 0;
if odd( n ) then prime := 1;
p := 3;
while p * p <= n * prime do begin
if n - ( ( n / p ) * p ) = 0 then prime := 0;
p := p + 2;
end
end
end;
begin
p1 := 3;
p2 := 5;
while p2 < 100 do begin
n := ( p1 + p2 ) - 1;
call isnprime;
if prime = 1 then ! p1;
n := p2 + 2;
call isnprime;
while prime = 0 do begin
n := n + 2;
call isnprime;
end;
p1 := p2;
p2 := n;
end
end.
</syntaxhighlight>
{{out}}
<pre>
3
5
7
11
13
19
29
31
41
43
61
67
73
</pre>
 
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
<syntaxhighlight lang="plm">
100H: /* FIND SOME PAIRS OF PRIMES P, Q BETWEEN 1 AND 99 SUCH THAT P + Q -1 */
/* IS ALSO A PRIME */
 
/* CP/M BDOS SYSTEM CALL AND I/O ROUTINES */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$STRING( .( 0DH, 0AH, '$' ) ); END;
PR$NUMBER: PROCEDURE( N );
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
 
/* TASK */
 
DECLARE FALSE LITERALLY '0';
DECLARE TRUE LITERALLY '0FFH';
DECLARE MAX$LOW$PRIME LITERALLY '99';
DECLARE PRIME ( 200 )BYTE;
/* THE SIZE OF PRIME SHOULD BE AT LEAST MAX$LOW$PRIME DOUBLED */
/* SIEVE THE PRIMES TO MAX$PRIME */
DECLARE ( P, Q, COUNT ) ADDRESS;
PRIME( 1 ) = FALSE; PRIME( 2 ) = TRUE;
DO P = 3 TO LAST( PRIME ) BY 2; PRIME( P ) = TRUE; END;
DO P = 4 TO LAST( PRIME ) BY 2; PRIME( P ) = FALSE; END;
DO P = 3 TO MAX$LOW$PRIME + 1;
IF PRIME( P ) THEN DO;
DO Q = P * P TO LAST( PRIME ) BY P + P; PRIME( Q ) = FALSE; END;
END;
END;
/* FIND AND SHOW THE SPECIAL NEIGHBOUR PRIMES */
COUNT = 0;
P = 2;
Q = 3;
DO WHILE Q < MAX$LOW$PRIME;
IF PRIME( Q ) THEN DO;
DECLARE SNP ADDRESS;
SNP = P + Q - 1;
IF PRIME( SNP ) THEN DO;
/* P AND Q ARE SPECIAL NEIGHBOUR PRIMES */
CALL PR$STRING( .'( $' );
IF P < 10 THEN CALL PR$CHAR( ' ' );
CALL PR$NUMBER( P );
CALL PR$STRING( .' + $' );
IF Q < 10 THEN CALL PR$CHAR( ' ' );
CALL PR$NUMBER( Q );
CALL PR$STRING( .' ) - 1 = $' );
IF SNP < 100 THEN CALL PR$CHAR( ' ' );
IF SNP < 10 THEN CALL PR$CHAR( ' ' );
CALL PR$NUMBER( SNP );
CALL PR$NL;
END;
P = Q;
END;
Q = Q + 2;
END;
 
EOF
</syntaxhighlight>
{{out}}
<pre>
( 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
</pre>
 
=={{header|Python}}==
<syntaxhighlight 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
 
def nextPrime(n):
#finds the next prime after n
if n == 0:
return 2
if n < 3:
return n + 1
q = n + 2
while not isPrime(q):
q += 2
return q
 
 
if __name__ == "__main__":
for p1 in range(3,100,2):
p2 = nextPrime(p1)
if isPrime(p1) and p2 < 100 and isPrime(p1 + p2 - 1):
print(p1,'\t', p2,'\t', p1 + p2 - 1)</syntaxhighlight>
{{out}}
<pre>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</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line># 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, $_
}</langsyntaxhighlight>
{{out}}
<pre> 3, 5 => 7
Line 593 ⟶ 1,022:
=={{header|REXX}}==
A little extra code was added to present the results in a grid-like format.
<langsyntaxhighlight lang="rexx">/*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.*/
Line 639 ⟶ 1,068:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 653 ⟶ 1,082:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 674 ⟶ 1,103:
see "Found " + row + " special neighbor primes"
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 694 ⟶ 1,123:
Found 13 special neighbor primes
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
≪ → max
≪ <span style="color:red">{ } 3 5</span>
'''DO'''
'''IF''' DUP2 + <span style="color:red">1</span> - ISPRIME? '''THEN''' DUP2 R→C <span style="color:red">4</span> ROLL SWAP + UNROT '''END'''
NIP DUP NEXTPRIME
'''UNTIL''' DUP max ≥ '''END'''
DROP2
≫ ≫ '<span style="color:blue">SNP</span>' STO
 
100 <span style="color:blue">SNP</span>
{{out}}
<pre>
1: { (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.) }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
Prime.each(100).each_cons(2).select{|p1, p2|(p1+p2-1).prime?}.each{|ar| p ar}</syntaxhighlight>
{{out}}
<pre>[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]
</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func special_neighbor_primes(upto) {
var list = []
upto.primes.each_cons(2, {|p1,p2|
Line 721 ⟶ 1,187:
var list = special_neighbor_primes(10**n)
say "Found #{list.len} special neighbour primes < 10^#{n}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 747 ⟶ 1,213:
Found 103611 special neighbour primes < 10^7
</pre>
 
=={{header|Tiny BASIC}}==
<lang tinybasic> 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 = 2
110 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 = P
130 LET P = P + 1
GOSUB 100
IF Z = 1 THEN GOTO 140
GOTO 130
140 LET B = P
LET P = T
RETURN</lang>
{{out}}<pre>
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</lang>
 
=={{header|Wren}}==
Line 812 ⟶ 1,218:
{{libheader|Wren-fmt}}
I assume that 'neighbor' primes means pairs of successive primes.
<syntaxhighlight lang="wren">import "./math" for Int
 
import "./fmt" for Fmt
Anticipating a likely stretch goal.
<lang ecmascript>import "/math" for Int
import "/fmt" for Fmt
 
var max = 1e7 - 1
Line 838 ⟶ 1,242:
for (i in 3..7) {
specialNP.call(10.pow(i), false)
}</langsyntaxhighlight>
 
{{out}}
Line 871 ⟶ 1,275:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 892 ⟶ 1,296:
];
];
]</langsyntaxhighlight>
 
{{out}}
Tigerofdarkness
3,022

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/314732...363863"