Rosetta Code

Neighbour primes: Difference between revisions

Page Discussion

Neighbour primes (view source)

Revision as of 13:30, 21 April 2024

4,375 bytes added ,  26 days ago
→‎{{header|Prolog}}
(Added PL/0)
(16 intermediate revisions by 9 users not shown)
Line 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#}}==
Line 568 ⟶ 660:
439 443 194479
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}}
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation &mdash;i.e. XML, JSON&mdash; they are intended for storage and transfer purposes more than visualization and edition.
 
'''Solution'''
 
[[File:Fōrmulæ - Neighbour primes 01.png]]
Programs in Fōrmulæ are created/edited online in its [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.
 
[[File:Fōrmulæ - Neighbour primes 02.png]]
In '''[https://formulae.org/?example=Neighbour_primes this]''' page you can see the program(s) related to this task and their results.
 
=={{header|Go}}==
Line 634 ⟶ 789:
[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}}==
Line 885 ⟶ 1,063:
 
=={{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;
Line 943 ⟶ 1,123:
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>
 
Line 1,172 ⟶ 1,390:
<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>
 
Line 1,183 ⟶ 1,426:
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascriptwren">import "./math" for Int
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var primes = Int.primeSieve(504)
Line 1,196 ⟶ 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.")</syntaxhighlight>
 
Achim121
64

edits

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