Special neighbor primes: Difference between revisions
m
→{{header|PL/M}}: tweak - Q must be odd
(Dialects of BASIC moved to the BASIC section.) |
m (→{{header|PL/M}}: tweak - Q must be odd) |
||
| (10 intermediate revisions by 7 users not shown) | |||
Line 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}}==
Line 374 ⟶ 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>
Line 531 ⟶ 609:
=={{header|J}}==
<syntaxhighlight lang=
3 5 7
5 7 11
Line 544 ⟶ 622:
61 67 127
67 71 137
73 79 151</syntaxhighlight>
=={{header|jq}}==
{{works with|jq}}
Line 790 ⟶ 868:
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>
Line 958 ⟶ 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>
Line 1,016 ⟶ 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
var max = 1e7 - 1
| |||