Find prime n such that reversed n is also prime: Difference between revisions
Content deleted Content added
Alextretyak (talk | contribs) Added 11l |
|||
(26 intermediate revisions by 16 users not shown) | |||
Line 3:
;Task
Find prime '''n''' for '''0 < n < 500''' which are also primes when the (decimal) digits are reversed.
<br>Nearly [https://rosettacode.org/wiki/Emirp_primes Emirp Primes], which don't count palindromatic primes like 101.
<br><br>
=={{header|11l}}==
<
I a == 2
R 1B
Line 18:
L(n) 1..499
I is_prime(n) & is_prime(Int(reversed(String(n))))
print(n, end' ‘ ’)</
{{out}}
Line 27:
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<
BYTE FUNC IsPrimeAndItsReverse(INT i BYTE ARRAY primes)
Line 61:
OD
PrintF("%E%EThere are %I primes",count)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Find_prime_n_such_that_reversed_n_is_also_prime.png Screenshot from Atari 8-bit computer]
Line 71:
=={{header|Ada}}==
<
procedure Reverse_Prime is
Line 125:
New_Line;
Put_Line (Count'Image & " primes.");
end Reverse_Prime;</
{{out}}
<pre> 2 3 5 7 11 13 17 31
Line 133:
383 389
34 primes.</pre>
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">
BEGIN # find primes whose reversed digits are also prime #
INT max number = 500; # largest prime we will reverse #
INT max prime = 1 000; # enough primes to handle reversing #
# max number #
[ 1 : max prime ]BOOL p; FOR n TO UPB p DO p[ n ] := ODD n OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( UPB p ) DO
IF p[ i ] THEN
FOR s FROM i * i BY i + i TO UPB p DO p[ s ] := FALSE OD
FI
OD;
p[ 1 ] := FALSE; p[ 2 ] := TRUE;
OP FMT = ( INT n )STRING: whole( n, 0 );
INT count := 0;
FOR n TO max number DO
IF p[ n ] THEN
INT r := n MOD 10;
INT v := n;
WHILE ( v OVERAB 10 ) > 0 DO
r *:= 10 +:= v MOD 10
OD;
IF p[ r ] THEN
print( ( " ", whole( n, -3 ) ) );
IF ( count +:= 1 ) MOD 10 = 0 THEN print( ( newline ) ) FI
FI
FI
OD;
print( ( newline, "Found ", whole( count, 0 )
, " reversable primes up to ", whole( max number, 0 )
)
)
END
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71
73 79 97 101 107 113 131 149 151 157
167 179 181 191 199 311 313 337 347 353
359 373 383 389
Found 34 reversable primes up to 500</pre>
=={{header|ALGOL W}}==
<
% sets p( 1 :: n ) to a sieve of primes up to n %
procedure Eratosthenes ( logical array p( * ) ; integer value n ) ;
Line 184 ⟶ 226:
write( i_w := 1, s_w := 0, "Found ", pCount, " reversable primes below ", MAX_NUMBER )
end
end.</
{{out}}
<pre>
Line 191 ⟶ 233:
Found 34 reversable primes below 500
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print
select 1..499 'x ->
and? [prime? x][prime? to :integer reverse to :string x]</syntaxhighlight>
{{out}}
<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f FIND_PRIME_N_FOR_THAT_REVERSED_N_IS_ALSO_PRIME.AWK
BEGIN {
Line 222 ⟶ 275:
return( substr(str,start,1) revstr(str,start-1) )
}
</syntaxhighlight>
{{out}}
<pre>
Line 233 ⟶ 286:
=={{header|BASIC}}==
<
15 MP=10^FIX(LOG(MX)/LOG(10)+1)
20 DIM C(MP): C(0)=-1: C(1)=-1
Line 243 ⟶ 296:
80 IF V>0 THEN R=10*R+V MOD 10: V=V\10: GOTO 80
90 IF NOT C(R) THEN PRINT N,
100 NEXT</
{{out}}
<pre> 2 3 5 7 11
Line 252 ⟶ 305:
311 313 337 347 353
359 373 383 389</pre>
=={{header|bc}}==
<syntaxhighlight lang="bc">define t(n) {
auto i, p
if (n == 2) return(1)
for (i = 0; n % (p = a[i]) != 0; ++i) if (p * p > n) return(1)
return(0)
}
define r(n) {
auto m
for (m = 0; n > 9; n /= 10) m = (n % 10 + m) * 10
return(m + n)
}
for (n = 2; n != 500; ++n) if (t(n) != 0) a[o++] = n
for (i = 0; i != o; ++i) if (t(r(n = a[i])) != 0) n</syntaxhighlight>
=={{header|BCPL}}==
<
let sieve(prime, n) be
Line 285 ⟶ 356:
writef("%N ",i)
wrch('*N')
$)</
{{out}}
<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
=={{header|C}}==
<
#include <stdio.h>
Line 325 ⟶ 396:
printf("\nCount = %u\n", count);
return 0;
}</
{{out}}
Line 337 ⟶ 408:
=={{header|CLU}}==
<
prime: array[bool] := array[bool]$fill(0,max+1,true)
prime[0] := false
Line 368 ⟶ 439:
end
end
end start_up</
{{out}}
<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
=={{header|Cowgol}}==
<
const PRIME_LIMIT := 999;
Line 414 ⟶ 485:
n := n + 1;
end loop;
print_nl();</
{{out}}
<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
Line 421 ⟶ 492:
{{libheader| PrimTrial}}
{{Trans|Ring}}
<syntaxhighlight lang="delphi">
program Find_prime_n_for_that_reversed_n_is_also_prime;
Line 469 ⟶ 540:
Writeln('done...');
readln;
end.</
{{out}}
<pre>working...
Line 480 ⟶ 551:
found 34 primes
done...</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=text>
fastfunc reverse n .
while n > 0
r = r * 10 + n mod 10
n = n div 10
.
return r
.
fastfunc isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
fastfunc nextprim prim .
repeat
prim += 1
until isprim prim = 1
.
return prim
.
prim = 2
while prim < 500
if isprim reverse prim = 1
write prim & " "
.
prim = nextprim prim
.
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389
</pre>
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<
// Reversible Primes. Nigel Galloway: March 22nd., 2021
let emirp2=let rec fN g=function |0->g |n->fN(g*10+n%10)(n/10) in primes32()|>Seq.filter(fN 0>>isPrime)
emirp2|>Seq.takeWhile((>)500)|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389
</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<
: reverse-digits ( 123 -- 321 )
Line 501 ⟶ 612:
499 primes-upto [ reverse-digits prime? ] filter
dup length "Found %d reverse primes < 500.\n\n" printf
10 group [ [ "%4d" printf ] each nl ] each nl</
{{out}}
<pre>
Line 514 ⟶ 625:
=={{header|Forth}}==
{{works with|Gforth}}
<
: not-prime! ( n -- ) here + 1 swap c! ;
Line 555 ⟶ 666:
main
bye</
{{out}}
Line 568 ⟶ 679:
=={{header|FreeBASIC}}==
Use one of the primality testing algorithms as an include as I can't be bothered putting these in all the time.
<
function isbackprime( byval n as integer ) as boolean
Line 584 ⟶ 695:
if isbackprime(n) then print n;" ";
next n
print</
{{out}}<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
=={{header|Frink}}==
<syntaxhighlight lang="frink">select[primes[2,500], {|n| isPrime[parseInt[join["", reverse[integerDigits[n]]]]]}]</syntaxhighlight>
{{out}}
<pre>
[2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97, 101, 107, 113, 131, 149, 151, 157, 167, 179, 181, 191, 199, 311, 313, 337, 347, 353, 359, 373, 383, 389]
</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 PrimeWhenReversed( n as NSUInteger ) as BOOL
if fn IsPrime(n) == NO then return NO
NSUInteger m = 0
while n
m *= 10
m += n % 10
n /= 10
wend
return fn IsPrime(m)
end fn = YES
local fn TestForReversablePrimes
NSUInteger i, count = 1
for i = 2 to 499
if fn PrimeWhenReversed( i ) == YES then count++ : printf @"%5u\b", i
if count == 11 then print : count = 1
next
end fn
fn TestForReversablePrimes
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
2 3 5 7 11 13 17 31 37 71
73 79 97 101 107 113 131 149 151 157
167 179 181 191 199 311 313 337 347 353
359 373 383 389
</pre>
=={{header|Go}}==
<
import "fmt"
Line 645 ⟶ 810:
}
fmt.Printf("\n\n%d such primes found.\n", len(reversedPrimes))
}</
{{out}}
Line 659 ⟶ 824:
=={{header|Haskell}}==
<
import Data.List.Split (chunksOf)
import Data.Numbers.Primes (isPrime, primes)
Line 696 ⟶ 861:
widths
)
rows</
{{Out}}
<pre>Reversible primes below 500:
Line 704 ⟶ 869:
359 373 383 389</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> (#~ 1 p: |.&.":"0) i.&.(p:inv) 500
2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</syntaxhighlight>
=={{header|jq}}==
Line 710 ⟶ 878:
Using the definition of is_prime at [[Erd%C5%91s-primes#jq]]:
<
# If . is null the stream is unbounded;
# otherwise only integers less than . are considered.
Line 720 ⟶ 888:
"Primes under 500 which are also primes when the digits are reversed:",
(500 | reversible_primes)</
{{out}}
<pre>
Line 761 ⟶ 929:
=={{header|Julia}}==
<
let
Line 776 ⟶ 944:
println("Total found: $pcount")
end
</
<pre>
Reversible primes between 0 and 500:
Line 785 ⟶ 953:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{{out}}
<pre>{2,3,5,7,11,13,17,31,37,71,73,79,97,101,107,113,131,149,151,157,167,179,181,191,199,311,313,337,347,353,359,373,383,389}</pre>
=={{header|Lua}}==
<syntaxhighlight lang="lua">
do -- find primes whose reversed digits are also prime
local function isPrime( p )
if p <= 1 or p % 2 == 0 then
return p == 2
else
local prime = true
local i = 3
local rootP = math.floor( math.sqrt( p ) )
while i <= rootP and prime do
prime = p % i ~= 0
i = i + 2
end
return prime
end
end
local function reverseDigits( n )
return tonumber( string.reverse( tostring( n ) ) )
end
local count = 0
for n = 1,500 do
if isPrime( n ) then
if isPrime( reverseDigits( n ) ) then
count = count + 1
io.write( string.format( "%3d", n ), count % 10 == 0 and "\n" or " " )
end
end
end
io.write( "\nFound ", count, " reversable primes up to 500" )
end
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71
73 79 97 101 107 113 131 149 151 157
167 179 181 191 199 311 313 337 347 353
359 373 383 389
Found 34 reversable primes up to 500
</pre>
=={{header|MAD}}==
<
BOOLEAN PRIME
DIMENSION PRIME(1000)
Line 817 ⟶ 1,026:
PRINT FORMAT FMT,N
TEST CONTINUE
END OF PROGRAM</
{{out}}
<pre style='height:50ex;'> 2
Line 855 ⟶ 1,064:
=={{header|Modula-2}}==
<
FROM InOut IMPORT WriteCard, WriteLn;
Line 905 ⟶ 1,114:
END;
WriteLn();
END ReversePrime.</
{{out}}
<pre> 2 3 5 7 11 13 17 31
Line 915 ⟶ 1,124:
=={{header|Nim}}==
<
const
Line 944 ⟶ 1,153:
stdout.write ($n).align(3)
stdout.write if (i + 1) mod 10 == 0: '\n' else: ' '
echo()</
{{out}}
Line 951 ⟶ 1,160:
167 179 181 191 199 311 313 337 347 353
359 373 383 389 </pre>
=={{header|OCaml}}==
Using the function <code>seq_primes</code> from [[Extensible prime generator#OCaml]]:
<syntaxhighlight lang="ocaml">let int_reverse =
let rec loop m n =
if n < 10 then m + n else loop ((m + n mod 10) * 10) (n / 10)
in loop 0
let is_prime n =
let not_divisible x = n mod x <> 0 in
seq_primes |> Seq.take_while (fun x -> x * x <= n) |> Seq.for_all not_divisible
let () =
seq_primes |> Seq.filter (fun p -> is_prime (int_reverse p))
|> Seq.take_while ((>) 500) |> Seq.iter (Printf.printf " %u") |> print_newline</syntaxhighlight>
{{out}}
<pre> 2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
=={{header|Pascal}}==
==={{header|Free Pascal}}===
<syntaxhighlight lang="pascal">
Type Tboolarr = array Of boolean;
Const MAX = 1000;
Function SieveOfEratosthenes(limit: Integer): Tboolarr;
Var
sieve: Tboolarr;
i, j: Integer;
Begin
SetLength(sieve, limit + 1);
sieve[2] := True;
For i := 3 To limit Do
sieve[i] := (i Mod 2 <> 0);
For i := 3 To Trunc(Sqrt(limit)) Do
Begin
If sieve[i] Then
Begin
j := i * i;
While j <= limit Do
Begin
sieve[j] := False;
Inc(j, 2 * i);
End;
End;
End;
SieveOfEratosthenes := sieve;
End;
Function ReverseNumber(number: Integer): Integer;
Var
reversed: Integer;
Begin
reversed := 0;
While number <> 0 Do
Begin
reversed := reversed * 10 + (number Mod 10);
number := number Div 10;
End;
ReverseNumber := reversed;
End;
Var
primes: Tboolarr;
i: Integer;
Begin
primes := SieveOfEratosthenes(MAX);
For i := 2 To 500 Do
Begin
If primes[i] And Primes[ReverseNumber(i)] Then
Write(i,' ');
End;
End.
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use List::Util 'max';
Line 967 ⟶ 1,253:
my($limit, @rp) = 500;
is_prime($_) and is_prime(reverse $_) and push @rp, $_ for 1..$limit;
print @rp . " reversible primes < $limit:\n" . pp(@rp);</
{{out}}
<pre>34 reversible primes < 500:
Line 975 ⟶ 1,261:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">rp</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;">to_integer</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprint</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;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">args</span><span style="color: #0000FF;">)</span>
Line 984 ⟶ 1,270:
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">500</span><span style="color: #0000FF;">,</span><span style="color: #008000;">":\n%s"</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">,</span><span style="color: #008000;">":\n%s"</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">10000</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"."</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">10_000_000</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"."</span><span style="color: #0000FF;">}},</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 998 ⟶ 1,284:
82,439 reverse primes < 10,000,000 found.
</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 isBackPrime(n):
if not isPrime(n):
return False
m = 0
while n:
m *= 10
m += n % 10
n //= 10
return isPrime(m)
if __name__ == '__main__':
for n in range(2, 499):
if isBackPrime(n):
print(n, end=' ');</syntaxhighlight>
{{out}}
<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389</pre>
=={{header|PILOT}}==
<
*number
C :p=n
Line 1,036 ⟶ 1,350:
J (i<p/2):*div
C :pr=1
E :</
{{out}}
<pre style='height:50ex;'>2
Line 1,074 ⟶ 1,388:
=={{header|PL/I}}==
<
declare prime(1:999) bit;
Line 1,108 ⟶ 1,422:
put skip list('Reverse primes found:',found);
end reversePrimes;</
{{out}}
<pre> 2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157
167 179 181 191 199 311 313 337 347 353 359 373 383 389
Reverse primes found: 34</pre>
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
<syntaxhighlight lang="plm">
100H: /* FIND PRIMES THAT ARE STILL PRIME WHEN THEIR DIGITS ARE REVERSED */
/* CP/M BDOS SYSTEM CALL */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
/* I/O ROUTINES */
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$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */
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;
/* RETURNS TRUE IF N IS PRIME, FALSE OTHERWISE, USES TRIAL DIVISION */
IS$PRIME: PROCEDURE( N )BYTE;
DECLARE N ADDRESS;
DECLARE PRIME BYTE;
IF N < 3 THEN PRIME = N = 2;
ELSE IF N MOD 3 = 0 THEN PRIME = N = 3;
ELSE IF N MOD 2 = 0 THEN PRIME = 0;
ELSE DO;
DECLARE ( F, F2, TO$NEXT ) ADDRESS;
PRIME = 1;
F = 5;
F2 = 25;
TO$NEXT = 24; /* NOTE: ( 2N + 1 )^2 - ( 2N - 1 )^2 = 8N */
DO WHILE F2 <= N AND PRIME;
PRIME = N MOD F <> 0;
F = F + 2;
F2 = F2 + TO$NEXT;
TO$NEXT = TO$NEXT + 8;
END;
END;
RETURN PRIME;
END IS$PRIME;
REVERSE: PROCEDURE( N )ADDRESS; /* RETURNS THE REVERSED DIGITS OF N */
DECLARE N ADDRESS;
DECLARE ( R, V ) ADDRESS;
V = N;
R = V MOD 10;
DO WHILE( ( V := V / 10 ) > 0 );
R = ( R * 10 ) + ( V MOD 10 );
END;
RETURN R;
END REVERSE ;
/* FIND THE NUMBERS UP TO 500 */
DECLARE ( I, COUNT ) ADDRESS;
COUNT = 0;
DO I = 1 TO 500;
IF IS$PRIME( I ) THEN DO;
IF IS$PRIME( REVERSE( I ) ) THEN DO;
IF I < 10 THEN CALL PR$CHAR( ' ' );
IF I < 100 THEN CALL PR$CHAR( ' ' );
CALL PR$NUMBER( I );
IF ( COUNT := COUNT + 1 ) MOD 20 = 0 THEN CALL PR$NL;
ELSE CALL PR$CHAR( ' ' );
END;
END;
END;
EOF
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157
167 179 181 191 199 311 313 337 347 353 359 373 383 389
</pre>
=={{header|Quackery}}==
Line 1,118 ⟶ 1,515:
<code>eratosthenes</code> and <code>isprime</code> are defined at [[Sieve of Eratosthenes#Quackery]].
<
[ number$ reverse $->n drop ] is revnum ( n --> n )
Line 1,130 ⟶ 1,527:
[ i^ join ] ]
witheach [ number$ nested join ]
60 wrap$</
{{out}}
Line 1,136 ⟶ 1,533:
<pre>2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151
157 167 179 181 191 199 311 313 337 347 353 359 373 383 389
</pre>
=={{header|R}}==
<syntaxhighlight lang="R">
library(schoolmath) #to get prime numbers and to know if number is prime or not
n<- 500
all_primes_n <- primes(end=n)
reversed_primes_n = as.numeric(sapply(strsplit(as.character(all_primes_n),""),\(x){paste(rev(x),collapse="")}))
cat(all_primes_n[is.prim(reversed_primes_n)])
</syntaxhighlight>
'''Output'''
<pre>
1 2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 133 149 151 157 167 179 181 191 199 301 311 313 337 347 353 359 373 383 389
</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
say "{+$_} reversible primes < $limit:\n{$_».fmt("%" ~ $limit.chars ~ "d").batch(10).join("\n")}",
with ^$limit .grep: { .is-prime and .flip.is-prime }</
{{out}}
<pre>34 reversible primes < 500:
Line 1,150 ⟶ 1,563:
=={{header|REXX}}==
<
parse arg n cols . /*get optional number of primes to find*/
if n=='' | n=="," then n= 500 /*Not specified? Then assume default.*/
Line 1,189 ⟶ 1,602:
#= # + 1; @.#= j; !.j= 1 /*bump prime count; assign prime & flag*/
end /*j*/
return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,208 ⟶ 1,621:
=={{header|Ring}}==
<
load "stdlib.ring"
Line 1,236 ⟶ 1,649:
see nl + "found " + num + " primes" + nl
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
Line 1,246 ⟶ 1,659:
found 34 primes
done...
</pre>
=={{header|RPL}}==
This program uses the words <code>RVSTR</code> and <code>BPRIM?</code>, respectively made to [[Reverse_a_string#RPL|revert a string]] and to [[Primality_by_trial_division#RPL|test primality by trial division]]
≪ { } 1 499 '''FOR''' n
'''IF''' n R→B '<span style="color:blue">BPRIM?</span> THEN'''
'''IF''' n →STR <span style="color:blue">RVSTR</span> STR→ R→B <span style="color:blue">BPRIM?</span> '''THEN''' n + '''END'''
'''END'''
'''NEXT'''
≫ '<span style="color:blue">TASK</span>' STO
====Straightforward approach====
Numbers are here reversed without any string conversion.
{{works with|HP|49}}
« { }
1 499 '''FOR''' n
'''IF''' n ISPRIME? '''THEN'''
n 0
'''WHILE''' OVER '''REPEAT'''
SWAP 10 IDIV2 ROT 10 * +
'''END''' NIP
'''IF''' ISPRIME? '''THEN''' n + '''END'''
'''END'''
'''NEXT'''
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389 }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="Ruby">p Prime.each(500).select{|pr| pr.digits.join.to_i.prime? }
</syntaxhighlight>
{{out}}
<pre>
[2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97, 101, 107, 113, 131, 149, 151, 157, 167, 179, 181, 191, 199, 311, 313, 337, 347, 353, 359, 373, 383, 389]
</pre>
=={{header|Rust}}==
<syntaxhighlight lang="Rust">
use prime_tools ;
fn myreverse( n : u32 ) -> u32 {
let forward : String = n.to_string( ) ;
let numberstring = &forward[..] ;
let mut reversed : String = String::new( ) ;
for c in numberstring.chars( ).rev( ) {
reversed.push( c ) ;
}
*&reversed[..].parse::<u32>( ).unwrap( )
}
fn main() {
let mut reversible_primes : Vec<u32> = Vec::new( ) ;
for num in 2..=500 {
if prime_tools::is_u32_prime( num ) && prime_tools::is_u32_prime(
myreverse( num )) {
reversible_primes.push( num ) ;
}
}
println!("{:?}" , reversible_primes ) ;
}</syntaxhighlight>
{{out}}
<pre>
[2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97, 101, 107, 113, 131, 149, 151, 157, 167, 179, 181, 191, 199, 311, 313, 337, 347, 353, 359, 373, 383, 389]
</pre>
=={{header|Seed7}}==
<
const func boolean: isPrime (in integer: number) is func
Line 1,296 ⟶ 1,773:
writeln;
writeln("Found " <& count <& " reverse primes < 500.");
end func;</
{{out}}
<pre>
2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157 167 179 181 191 199 311 313 337 347 353 359 373 383 389
Found 34 reverse primes < 500.
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">say primes(500).grep { .reverse.is_prime }</syntaxhighlight>
{{out}}
<pre>
[2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97, 101, 107, 113, 131, 149, 151, 157, 167, 179, 181, 191, 199, 311, 313, 337, 347, 353, 359, 373, 383, 389]
</pre>
Line 1,306 ⟶ 1,790:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./math" for Int
var reversed = Fn.new { |n|
Line 1,326 ⟶ 1,808:
}
System.print("Primes under 500 which are also primes when the digits are reversed:")
Fmt.tprint("$3d", reversedPrimes, 17)
System.print("\n%(reversedPrimes.count) such primes found.")</
{{out}}
Line 1,339 ⟶ 1,821:
=={{header|XPL0}}==
<
int N, I;
[if N <= 1 then return false;
Line 1,369 ⟶ 1,851:
IntOut(0, Count);
Text(0, " reversible primes found.");
]</
{{out}}
|