Find prime n such that reversed n is also prime: Difference between revisions

=={{header|11l}}==

I a == 2

R 1B

L(n) 1..499

I is_prime(n) & is_prime(Int(reversed(String(n))))

{{out}}

=={{header|Action!}}==

{{libheader|Action! Sieve of Eratosthenes}}

BYTE FUNC IsPrimeAndItsReverse(INT i BYTE ARRAY primes)

OD

PrintF("%E%EThere are %I primes",count)

{{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]

=={{header|Ada}}==

procedure Reverse_Prime is

New_Line;

Put_Line (Count'Image & " primes.");

{{out}}

<pre> 2 3 5 7 11 13 17 31

=={{header|ALGOL W}}==

% sets p( 1 :: n ) to a sieve of primes up to n %

procedure Eratosthenes ( logical array p( * ) ; integer value n ) ;

write( i_w := 1, s_w := 0, "Found ", pCount, " reversable primes below ", MAX_NUMBER )

end

{{out}}

<pre>

=={{header|Arturo}}==

select 1..499 'x ->

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f FIND_PRIME_N_FOR_THAT_REVERSED_N_IS_ALSO_PRIME.AWK

BEGIN {

return( substr(str,start,1) revstr(str,start-1) )

}

{{out}}

<pre>

=={{header|BASIC}}==

15 MP=10^FIX(LOG(MX)/LOG(10)+1)

20 DIM C(MP): C(0)=-1: C(1)=-1

80 IF V>0 THEN R=10*R+V MOD 10: V=V\10: GOTO 80

90 IF NOT C(R) THEN PRINT N,

{{out}}

<pre> 2 3 5 7 11

=={{header|BCPL}}==

let sieve(prime, n) be

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>

printf("\nCount = %u\n", count);

return 0;

{{out}}

=={{header|CLU}}==

prime: array[bool] := array[bool]$fill(0,max+1,true)

prime[0] := false

end

end

{{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;

n := n + 1;

end loop;

{{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>

{{libheader| PrimTrial}}

{{Trans|Ring}}

program Find_prime_n_for_that_reversed_n_is_also_prime;

Writeln('done...');

readln;

{{out}}

<pre>working...

=={{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 ""

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

: reverse-digits ( 123 -- 321 )

499 primes-upto [ reverse-digits prime? ] filter

dup length "Found %d reverse primes < 500.\n\n" printf

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth}}

: not-prime! ( n -- ) here + 1 swap c! ;

main

{{out}}

=={{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

if isbackprime(n) then print n;" ";

next 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|Frink}}==

{{out}}

<pre>

=={{header|Go}}==

import "fmt"

}

fmt.Printf("\n\n%d such primes found.\n", len(reversedPrimes))

{{out}}

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import Data.Numbers.Primes (isPrime, primes)

widths

)

{{Out}}

<pre>Reversible primes below 500:

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.

"Primes under 500 which are also primes when the digits are reversed:",

{{out}}

<pre>

=={{header|Julia}}==

let

println("Total found: $pcount")

end

<pre>

Reversible primes between 0 and 500:

=={{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|MAD}}==

BOOLEAN PRIME

DIMENSION PRIME(1000)

PRINT FORMAT FMT,N

TEST CONTINUE

{{out}}

<pre style='height:50ex;'> 2

=={{header|Modula-2}}==

FROM InOut IMPORT WriteCard, WriteLn;

END;

WriteLn();

{{out}}

<pre> 2 3 5 7 11 13 17 31

=={{header|Nim}}==

const

stdout.write ($n).align(3)

stdout.write if (i + 1) mod 10 == 0: '\n' else: ' '

{{out}}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use List::Util 'max';

my($limit, @rp) = 500;

is_prime($_) and is_prime(reverse $_) and push @rp, $_ for 1..$limit;

{{out}}

<pre>34 reversible primes < 500:

=={{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>

<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>

=={{header|Python}}==

def isPrime(n):

for n in range(2, 499):

if isBackPrime(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|PILOT}}==

*number

C :p=n

J (i<p/2):*div

C :pr=1

{{out}}

<pre style='height:50ex;'>2

=={{header|PL/I}}==

declare prime(1:999) bit;

put skip list('Reverse primes found:',found);

{{out}}

<pre> 2 3 5 7 11 13 17 31 37 71 73 79 97 101 107 113 131 149 151 157

<code>eratosthenes</code> and <code>isprime</code> are defined at [[Sieve of Eratosthenes#Quackery]].

[ number$ reverse $->n drop ] is revnum ( n --> n )

[ i^ join ] ]

witheach [ number$ nested join ]

{{out}}

=={{header|Raku}}==

say "{+$_} reversible primes < $limit:\n{$_».fmt("%" ~ $limit.chars ~ "d").batch(10).join("\n")}",

{{out}}

<pre>34 reversible primes < 500:

=={{header|REXX}}==

parse arg n cols . /*get optional number of primes to find*/

if n=='' | n=="," then n= 500 /*Not specified? Then assume default.*/

#= # + 1; @.#= j; !.j= 1 /*bump prime count; assign prime & flag*/

end /*j*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see nl + "found " + num + " primes" + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Seed7}}==

const func boolean: isPrime (in integer: number) is func

writeln;

writeln("Found " <& count <& " reverse primes < 500.");

{{out}}

<pre>

=={{header|Sidef}}==

{{out}}

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-seq}}

import "/fmt" for Fmt

import "/seq" for Lst

System.print("Primes under 500 which are also primes when the digits are reversed:")

for (chunk in Lst.chunks(reversedPrimes, 17)) Fmt.print("$3d", chunk)

{{out}}

=={{header|XPL0}}==

int N, I;

[if N <= 1 then return false;

IntOut(0, Count);

Text(0, " reversible primes found.");

{{out}}