Rosetta Code

Neighbour primes: Difference between revisions

Page Discussion

Neighbour primes (view source)

Revision as of 13:30, 21 April 2024

16,948 bytes added ,  26 days ago
→‎{{header|Prolog}}
(Added Arturo implementation)
(35 intermediate revisions by 18 users not shown)
Line 5:
Find and show primes p such that p*q+2 is prime, where q is next prime after p and '''p < 500'''
<br><br>
See also:
* [[Special neighbor primes]]
 
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">
F isPrime(n)
L(i) 2 .. Int(n ^ 0.5)
I n % i == 0
R 0B
R 1B
 
print(‘p q pq+2’)
print(‘-----------------------’)
L(p) 2..498
I !isPrime(p)
L.continue
V q = p + 1
L !isPrime(q)
q++
I !isPrime(2 + p * q)
L.continue
print(p" \t "q" \t "(2 + p * q))
</syntaxhighlight>
 
{{out}}
<pre>
p q pq+2
-----------------------
3 5 17
5 7 37
7 11 79
13 17 223
19 23 439
67 71 4759
149 151 22501
179 181 32401
229 233 53359
239 241 57601
241 251 60493
269 271 72901
277 281 77839
307 311 95479
313 317 99223
397 401 159199
401 409 164011
419 421 176401
439 443 194479
487 491 239119
</pre>
 
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
Very similar to [[Special_neighbor_primes#ALGOL_68|The ALGOL 68 sample in the Special neighbor primes task]]
<syntaxhighlight lang="algol68">
BEGIN # find adjacent primes p1, p2 such that p1*p2 + 2 s also prime #
PR read "primes.incl.a68" PR
INT max prime = 500;
[]BOOL prime = PRIMESIEVE ( ( max prime * max prime ) + 2 ); # sieve the primes to max prime ^ 2 + 2 #
[]INT low prime = EXTRACTPRIMESUPTO max prime FROMPRIMESIEVE prime; # get a list of the primes up to max prime #
# find the adjacent primes p1, p2 such that p1*p2 + 2 is prime #
FOR i TO UPB low prime - 1 DO
IF INT p1 p2 plus 2 = ( low prime[ i ] * low prime[ i + 1 ] ) + 2;
prime[ p1 p2 plus 2 ]
THEN print( ( "(", whole( low prime[ i ], -3 )
, " *", whole( low prime[ i + 1 ], -3 )
, " ) + 2 = ", whole( p1 p2 plus 2, -6 )
, newline
)
)
FI
OD
END
</syntaxhighlight>
{{out}}
<pre>
( 3 * 5 ) + 2 = 17
( 5 * 7 ) + 2 = 37
( 7 * 11 ) + 2 = 79
( 13 * 17 ) + 2 = 223
( 19 * 23 ) + 2 = 439
( 67 * 71 ) + 2 = 4759
(149 *151 ) + 2 = 22501
(179 *181 ) + 2 = 32401
(229 *233 ) + 2 = 53359
(239 *241 ) + 2 = 57601
(241 *251 ) + 2 = 60493
(269 *271 ) + 2 = 72901
(277 *281 ) + 2 = 77839
(307 *311 ) + 2 = 95479
(313 *317 ) + 2 = 99223
(397 *401 ) + 2 = 159199
(401 *409 ) + 2 = 164011
(419 *421 ) + 2 = 176401
(439 *443 ) + 2 = 194479
(487 *491 ) + 2 = 239119
</pre>
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin % find some primes where ( p*q ) + 2 is also a prime ( where p and q are adjacent primes ) %
% sets p( 1 :: n ) to a sieve of primes up to n %
procedure sieve ( logical array p( * ) ; integer value n ) ;
Line 46 ⟶ 145:
write( i_w := 1, s_w := 0, "Found ", pCount, " neighbour primes up to 500" )
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 54 ⟶ 153:
 
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">on isPrime(n)
if (n < 6) then return ((n > 1) and (n is not 4))
if ((n mod 2 = 0) or (n mod 3 = 0) or (n mod 5 = 0)) then return false
Line 82 ⟶ 181:
end neighbourPrimes
 
neighbourPrimes(499)</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{3, 5, 7, 13, 19, 67, 149, 179, 229, 239, 241, 269, 277, 307, 313, 397, 401, 419, 439, 487}</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">primesUpTo500: select 1..500 => prime?
 
print [pad "p" 5 pad "q" 4 pad "p*q+2" 7]
Line 103 ⟶ 202:
]
i: i + 1
]</langsyntaxhighlight>
 
{{out}}
Line 131 ⟶ 230:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f NEIGHBOUR_PRIMES.AWK
BEGIN {
Line 162 ⟶ 261:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 189 ⟶ 288:
Neighbour primes 1-499: 20
</pre>
 
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
<syntaxhighlight 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
 
print "p q pq+2"
print "------------------------"
for p = 2 to 499
if not isPrime(p) then continue for
q = p + 1
while Not isPrime(q)
q += 1
end while
if not isPrime(2 + p*q) then continue for
print p; chr(9); q; chr(9); 2+p*q
next p
end</syntaxhighlight>
 
==={{header|PureBasic}}===
<syntaxhighlight 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
 
OpenConsole()
PrintN("p q pq+2")
PrintN("----------------------")
For p.i = 2 To 499
If Not isPrime(p)
Continue
EndIf
q = p + 1
While Not isPrime(q)
q + 1
Wend
If Not isPrime(2 + p*q)
Continue
EndIf
PrintN(Str(p) + #TAB$ + Str(q) + #TAB$ + Str(2+p*q))
Next p
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input()
CloseConsole()</syntaxhighlight>
 
==={{header|Yabasic}}===
<syntaxhighlight 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
 
print "p q pq+2"
print "----------------------"
for p = 2 to 499
if not isPrime(p) continue
q = p + 1
while not isPrime(q)
q = q + 1
wend
if not isPrime(2 + p*q) continue
print p, chr$(9), q, chr$(9), 2+p*q
next p
end</syntaxhighlight>
 
 
=={{header|C#|CSharp}}==
How about some other offsets besides <code>+ 2</code> ?
<langsyntaxhighlight lang="fsharp">using System; using System.Collections.Generic;
using System.Linq; using static System.Console; using System.Collections;
 
Line 221 ⟶ 412:
if (!flags[j]) { yield return j;
for (int k = sq, i=j<<1; k<=lim; k += i) flags[k] = true; }
for (; j <= lim; j += 2) if (!flags[j]) yield return j; } }</langsyntaxhighlight>
{{out}}
<pre>Multiply two consecutive prime numbers, add an even number, see if the result is a prime number (up to a limit).
Line 266 ⟶ 457:
17 found under 500 for " + 18 "
25 found under 500 for " + 20 "</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function IsPrime(N: int64): boolean;
{Fast, optimised prime test}
var I,Stop: int64;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N+0.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
 
 
 
 
function GetNextPrime(var Start: integer): integer;
{Get the next prime number after Start}
{Start is passed by "reference," so the
{original variable is incremented}
begin
repeat Inc(Start)
until IsPrime(Start);
Result:=Start;
end;
 
 
 
procedure ShowNeighborPrimes(Memo: TMemo);
var P1,P2,P3,Cnt: integer;
var S: string;
begin
Memo.Lines.Add('Count P Q PQ+2');
Memo.Lines.Add('-----------------------');
Cnt:=0; P1:=1; P2:=1; S:='';
While P1< 500 do
begin
GetNextPrime(P2);
P3:=P1 * P2 + 2;
if IsPrime(P3) then
begin
Inc(Cnt);
S:=S+Format('%5D %4D %4D %6D',[Cnt,P1,P2,P3]);
S:=S+#$0D#$0A;
end;
P1:=P2;
end;
Memo.Lines.Add(S);
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Count P Q PQ+2
-----------------------
1 3 5 17
2 5 7 37
3 7 11 79
4 13 17 223
5 19 23 439
6 67 71 4759
7 149 151 22501
8 179 181 32401
9 229 233 53359
10 239 241 57601
11 241 251 60493
12 269 271 72901
13 277 281 77839
14 307 311 95479
15 313 317 99223
16 397 401 159199
17 401 409 164011
18 419 421 176401
19 439 443 194479
20 487 491 239119
</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">
// Nigel Galloway. April 13th., 2021
primes32()|>Seq.pairwise|>Seq.takeWhile(fun(n,_)->n<500)|>Seq.filter(fun(n,g)->isPrime(n*g+2))|>Seq.iter(fun(n,g)->printfn "%d*%d=%d" n g (n*g+2))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 299 ⟶ 582:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.primes ;
 
"p q p*q+2" print
Line 307 ⟶ 590:
[ 3dup "%-4d %-4d %-6d\n" printf ] when
drop nip dup next-prime
] while 2drop</langsyntaxhighlight>
{{out}}
<pre>
Line 335 ⟶ 618:
=={{header|Fermat}}==
{{trans|PARI/GP}}
<langsyntaxhighlight lang="fermat">for i = 1 to 95 do if Isprime(2+Prime(i)*Prime(i+1)) then !!Prime(i) fi od</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
 
dim as uinteger q
Line 352 ⟶ 635:
if not isprime( 2 + p*q ) then continue for
print p,q,2+p*q
next p</langsyntaxhighlight>
{{out}}
<pre>
Line 378 ⟶ 661:
487 491 239119
</pre>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn IsPrime( n as NSUInteger ) as BOOL
BOOL isPrime = YES
NSUInteger i
if n < 2 then exit fn = NO
if n = 2 then exit fn = YES
if n mod 2 == 0 then exit fn = NO
for i = 3 to int(n^.5) step 2
if n mod i == 0 then exit fn = NO
next
end fn = isPrime
 
local fn FindNeighborPrimes( searchLimit as long )
NSUInteger p, q
printf @"p q p*q+2"
printf @"----------------------"
for p = 2 to searchLimit
if ( fn IsPrime(p) == NO ) then continue
q = p + 1
while ( fn IsPrime(q) == NO )
q += 1
wend
if ( fn IsPrime( p * q + 2 ) == NO ) then continue
printf @"%lu\t\t%-6lu\t%-6lu", p, q, p * q + 2
next
end fn
 
fn FindNeighborPrimes( 499 )
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre style="height:20ex;">
p q p*q+2
----------------------
3 5 17
5 7 37
7 11 79
13 17 223
19 23 439
67 71 4759
149 151 22501
179 181 32401
229 233 53359
239 241 57601
241 251 60493
269 271 72901
277 281 77839
307 311 95479
313 317 99223
397 401 159199
401 409 164011
419 421 176401
439 443 194479
487 491 239119
 
</pre>
 
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Neighbour_primes}}
 
'''Solution'''
 
[[File:Fōrmulæ - Neighbour primes 01.png]]
 
[[File:Fōrmulæ - Neighbour primes 02.png]]
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 401 ⟶ 755:
rcu.PrintTable(nprimes, 10, 3, false)
fmt.Println("\nFound", len(nprimes), "such primes.")
}</langsyntaxhighlight>
 
{{out}}
Line 410 ⟶ 764:
 
Found 20 such primes.
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
import Data.List.Split ( divvy )
 
isPrime :: Int -> Bool
isPrime n
|n < 2 = False
|otherwise = null $ filter (\i -> mod n i == 0 ) [2 .. root]
where
root :: Int
root = floor $ sqrt $ fromIntegral n
solution :: [Int]
solution = map head $ filter (\li -> isPrime ((head li * last li) + 2 ))
$ divvy 2 1 $ filter isPrime [2..upTo]
where
upTo :: Int
upTo = head $ take 1 $ filter isPrime [500..]
</syntaxhighlight>
{{out}}
<pre>
[3,5,7,13,19,67,149,179,229,239,241,269,277,307,313,397,401,419,439,487]
</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> (#~ 1 p: {:"1) 2 (, 2 + */)\ i.&.(p:inv) 500
3 5 17
5 7 37
7 11 79
13 17 223
19 23 439
67 71 4759
149 151 22501
179 181 32401
229 233 53359
239 241 57601
241 251 60493
269 271 72901
277 281 77839
307 311 95479
313 317 99223
397 401 159199
401 409 164011
419 421 176401
439 443 194479
487 491 239119</syntaxhighlight>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
This entry uses `is_prime` as defined at [[Erd%C5%91s-primes#jq]].
<syntaxhighlight lang="jq">def next_prime:
if . == 2 then 3
else first(range(.+2; infinite; 2) | select(is_prime))
end;
# (not actually used)
def is_neighbour_prime:
is_prime and ((. * next_prime) + 2 | is_prime);
 
# The task, implemented using only `next_prime` for efficiency
{p: 2}
| while (.p < 500;
(.p|next_prime) as $np
| .emit = false
| if (.p * $np) + 2 | is_prime
then .emit = .p
else .
end
| .p = $np )
| select(.emit).emit
</syntaxhighlight>
{{out}}
<pre>
3
5
7
13
19
67
149
179
229
239
241
269
277
307
313
397
401
419
439
487
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
isneiprime(known) = isprime(known) && isprime(known * nextprime(known + 1) + 2)
println(filter(isneiprime, primes(500)))
</langsyntaxhighlight>{{out}}<pre>[3, 5, 7, 13, 19, 67, 149, 179, 229, 239, 241, 269, 277, 307, 313, 397, 401, 419, 439, 487]</pre>
 
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
 
# Find and show primes p such that p*q+2 is prime, where q is next prime after p and p<500
# # Variables:
#
integer MAX_PRIME=500
 
typeset -a parr
 
# # Functions:
#
 
# # Function _isprime(n) return 1 for prime, 0 for not prime
#
function _isprime {
typeset _n ; integer _n=$1
typeset _i ; integer _i
 
(( _n < 2 )) && return 0
for (( _i=2 ; _i*_i<=_n ; _i++ )); do
(( ! ( _n % _i ) )) && return 0
done
return 1
}
 
# # Function _neighbourprime(n) return p*q+2 if prime; 0 if not
#
function _neighbourprime {
typeset _indx ; integer _indx=$1
typeset _arr ; nameref _arr="$2"
typeset _neighbor
 
(( _neighbor = _arr[_indx] * _arr[_indx+1] + 2 ))
_isprime ${_neighbor}
(( $? )) && echo ${_neighbor} && return
echo 0
}
 
######
# main #
######
 
for ((i=2; i<MAX_PRIME; i++)); do
_isprime ${i} ; (( $? )) && parr+=( ${i} )
done
 
printf "%3s %3s %6s\n" p q p*q+2
printf "%3s %3s %6s\n" --- --- -----
for ((i=0; i<$((${#parr[*]}-1)); i++)); do
np=$(_neighbourprime ${i} parr)
(( np > 0 )) && printf "%3d %3d %6d\n" ${parr[i]} ${parr[i+1]} ${np}
done</syntaxhighlight>
{{out}}<pre>
p q p*q+2
--- --- -----
3 5 17
5 7 37
7 11 79
13 17 223
19 23 439
67 71 4759
149 151 22501
179 181 32401
229 233 53359
239 241 57601
241 251 60493
269 271 72901
277 281 77839
307 311 95479
313 317 99223
397 401 159199
401 409 164011
419 421 176401
439 443 194479
487 491 239119
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">p = Prime@Range@PrimePi[499];
Select[p, PrimeQ[# NextPrime[#] + 2] &]</syntaxhighlight>
{{out}}
<pre>{3, 5, 7, 13, 19, 67, 149, 179, 229, 239, 241, 269, 277, 307, 313, 397, 401, 419, 439, 487}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strformat, sugar
 
const
Line 450 ⟶ 987:
if (p * q + 2).isPrime:
echo &"{p:3} {q:3} {p*q+2:6}"
p = q</langsyntaxhighlight>
 
{{out}}
Line 476 ⟶ 1,013:
=={{header|PARI/GP}}==
Cheats a little in the sense that it requires knowing the 95th prime is 499 beforehand.
<langsyntaxhighlight lang="parigp">for(i=1, 95, if(isprime(2+prime(i)*prime(i+1)),print(prime(i))))</langsyntaxhighlight>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use ntheory <next_prime is_prime>;
Line 489 ⟶ 1,026:
printf "%3d%5d%8d\n", $p, $q, $p*$q+2 if is_prime $p*$q+2;
$p = $q;
} until $p >= 500;</langsyntaxhighlight>
{{out}}
<pre> 3 5 17
Line 513 ⟶ 1,050:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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;">p</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;">p</span><span style="color: #0000FF;">)*</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">N</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">500</span><span style="color: #0000FF;">))</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">N</span><span style="color: #0000FF;">),</span><span style="color: #000000;">np</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">)</span>
<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 such primes: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Found 20 such primes: 3, 5, 7, 13, 19, ..., 397, 401, 419, 439, 487
</pre>
 
 
=={{header|PL/0}}==
Formatted output isn't PL/0's forté, so this sample just shows each p1 of the p1, p2 neighbours.
<br>
This is almost identical to the [[Special neighbor primes#PL/0|PL/0 sample in the Special Neighbor 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 < 500 do begin
n := ( p1 * p2 ) + 2;
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
13
19
67
149
179
229
239
241
269
277
307
313
397
401
419
439
487
</pre>
 
=={{header|Prolog}}==
for swi prolog (© 2024)
<syntaxhighlight lang="prolog">
primes(2, Limit):- 2 =< Limit.
primes(P, Limit):-
between(3, Limit, P),
P /\ 1 > 0, % odd
M is floor(sqrt(P)) - 1, % reverse 2*I+1
Max is M div 2,
forall(between(1, Max, I), P mod (2*I+1) > 0).
 
isPrime(P):-
primes(P, inf).
 
primeProd(PList, [P1, P2]):-
append([_, [P1, P2], _], PList),
Prod is P1 * P2 + 2,
isPrime(Prod).
 
showList(List):-
findnsols(10, _, (member(Pair, List), format('~|~t(~d,~d)~9+ ', Pair)), _),
nl,
fail.
showList(_).
 
do:-Limit is 500,
findall(P, primes(P, Limit), PrimeList),
findall(Pair, primeProd(PrimeList, Pair), P1P2List),
showList(P1P2List).
</syntaxhighlight>
{{out}}
<pre>
?- do.
(3,5) (5,7) (7,11) (13,17) (19,23) (67,71) (149,151) (179,181) (229,233) (239,241)
(241,251) (269,271) (277,281) (307,311) (313,317) (397,401) (401,409) (419,421) (439,443) (487,491)
true.
</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
 
 
if __name__ == '__main__':
print("p q pq+2")
print("-----------------------")
for p in range(2, 499):
if not isPrime(p):
continue
q = p + 1
while not isPrime(q):
q += 1
if not isPrime(2 + p*q):
continue
print(p, "\t", q, "\t", 2+p*q)</syntaxhighlight>
{{out}}
<pre>p q pq+2
-----------------------
3 5 17
5 7 37
7 11 79
13 17 223
19 23 439
67 71 4759
149 151 22501
179 181 32401
229 233 53359
239 241 57601
241 251 60493
269 271 72901
277 281 77839
307 311 95479
313 317 99223
397 401 159199
401 409 164011
419 421 176401
439 443 194479
487 491 239119</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>my @primes = grep &is-prime, ^Inf;
my $last_p = @primes.first: :k, * >= 500;
my $last_q = $last_p + 1;
Line 534 ⟶ 1,219:
.grep( *.[2].is-prime );
 
say .fmt('%6d') for @cousins;</langsyntaxhighlight>
{{out}}
<pre>
Line 561 ⟶ 1,246:
=={{header|REXX}}==
'''Neighbor''' primes can also be spelled '''neighbour''' primes.
<langsyntaxhighlight lang="rexx">/*REXX program finds neighbor primes: P, Q, P*Q+2 are primes, and P < some specified N.*/
parse arg hi cols . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 500 /*Not specified? Then use the default.*/
Line 599 ⟶ 1,284:
/* [↓] generate more primes ≤ high.*/
do j=@.#+2 by 2 to limit /*find odd primes from here on. */
parse var j '' -1 _; if if _==5 then iterate /*J divisible÷ by 5? (right digdigit).*/
if j//3==0 then iterate; if j// 37==0 then iterate /*" " " 3? J ÷ by 7? */
if j// 7==0 then iterate /*" " " 7? */
/* [↑] the above 3 lines saves time.*/
do k=5 while s.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; s.#= 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 620 ⟶ 1,303:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 653 ⟶ 1,336:
see "Found " + row + " neighbour primes" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 681 ⟶ 1,364:
Found 20 neighbour primes
done...
</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn main() {
let mut primes_first : Vec<u64> = Vec::new( ) ;
primal::Primes::all( ).take_while( | n | *n < 500 ).for_each( | num |
primes_first.push( num as u64 ) ) ;
let mut current : u64 = *primes_first.iter( ).last( ).unwrap( ) + 1 ;
while ! primal::is_prime( current ) {
current += 1 ;
}
primes_first.push( current ) ;
let len = primes_first.len( ) ;
let mut primes_searched : Vec<u64> = Vec::new( ) ;
for i in 0..len - 2 {
if primal::is_prime( primes_first[ i ] * primes_first[ i + 1 ] + 2 ) {
let num = primes_first[ i ] ;
primes_searched.push( num ) ;
}
}
println!("{:?}" , primes_searched ) ;
}</syntaxhighlight>
{{out}}
<pre>
[3, 5, 7, 13, 19, 67, 149, 179, 229, 239, 241, 269, 277, 307, 313, 397, 401, 419, 439, 487]
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
≪ → max
≪ { } 2
'''WHILE''' DUP max < '''REPEAT'''
DUP NEXTPRIME
'''IF''' DUP2 * 2 + ISPRIME? '''THEN''' UNROT + SWAP '''ELSE''' NIP '''END'''
'''END''' DROP
≫ ≫ '<span style="color:blue">NEIGHB</span>' STO
 
500 <span style="color:blue">NEIGHB</span>
{{out}}
<pre>
1: {3 5 7 13 19 67 149 179 229 239 241 269 277 307 313 397 401 419 439 487}
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
p Prime.each(500).each_cons(2).select{|p, q| (p*q+2).prime? }</syntaxhighlight>
{{out}}
<pre>
[[3, 5], [5, 7], [7, 11], [13, 17], [19, 23], [67, 71], [149, 151], [179, 181], [229, 233], [239, 241], [241, 251], [269, 271], [277, 281], [307, 311], [313, 317], [397, 401], [401, 409], [419, 421], [439, 443], [487, 491]]
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">500.primes.grep {|p| p * p.next_prime + 2 -> is_prime }.say</syntaxhighlight>
{{out}}
<pre>
[3, 5, 7, 13, 19, 67, 149, 179, 229, 239, 241, 269, 277, 307, 313, 397, 401, 419, 439, 487]
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var primes = Int.primeSieve(504)
Line 698 ⟶ 1,437:
if (Int.isPrime(p)) nprimes.add(primes[i])
}
Fmt.tprint("$3d", nprimes, 10)
for (chunk in Lst.chunks(nprimes, 10)) Fmt.print("$3d", chunk)
System.print("\nFound %(nprimes.count) such primes.")</langsyntaxhighlight>
 
{{out}}
Line 711 ⟶ 1,450:
 
=={{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 736 ⟶ 1,475:
Text(0, " neighbour primes found below 500.
");
]</langsyntaxhighlight>
 
{{out}}
Achim121
64

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311437...363861"