Jump to content

Palindromic primes

From Rosetta Code
Palindromic primes is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

Find and show all palindromic primes   n,     where   n   <   1000

11l 

F is_prime(a)
   I a == 2
      R 1B
   I a < 2 | a % 2 == 0
      R 0B
   L(i) (3 .. Int(sqrt(a))).step(2)
      I a % i == 0
         R 0B
   R 1B

L(n) 1000
   I is_prime(n)
      V s = String(n)
      I s == reversed(s)
         print(n, end' ‘ ’)
print()
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

Action!

Library: Action! Sieve of Eratosthenes
INCLUDE "H6:SIEVE.ACT"

BYTE Func IsPalindromicPrime(INT i BYTE ARRAY primes)
  BYTE d
  INT rev,tmp

  IF primes(i)=0 THEN
    RETURN (0)
  FI
  rev=0 tmp=i
  WHILE tmp#0
  DO
    d=tmp MOD 10
    rev==*10
    rev==+d
    tmp==/10
  OD
  IF rev#i THEN
    RETURN (0)
  FI
RETURN (1)

PROC Main()
  DEFINE MAX="999"
  BYTE ARRAY primes(MAX+1)
  INT i,count=[0]

  Put(125) PutE() ;clear the screen
  Sieve(primes,MAX+1)
  FOR i=2 TO MAX
  DO
    IF IsPalindromicPrime(i,primes) THEN
      PrintI(i) Put(32)
      count==+1
    FI
  OD
  PrintF("%E%EThere are %I palindromic primes",count)
RETURN
Output:

Screenshot from Atari 8-bit computer 

2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

There are 20 palindromic primes

ALGOL 60

Works with: A60
begin

boolean procedure ispalindrome(n);
  value n; integer n;
begin
  integer i, j, q;
  integer array d[1:10];
  comment - decompose n into its digits;
  j := 0;
  for j := j while n > 0 do
    begin
      j := j + 1;
      q := entier(n / 10);
      d[j] := n - q * 10;
      n := q;
    end;
  comment - move from outside in checking for equality;
  i := 1;
  for i := i while (i < j) and (d[i] = d[j]) do
    begin
      i := i + 1;
      j := j - 1;
    end;
  ispalindrome := d[i] = d[j];
end;

boolean procedure isprime(n);
value n; integer n;
begin
    comment - local procedure tests whether n is even;
    boolean procedure even(n);
    value n; integer n;
    even := entier(n / 2) * 2 = n;

    if n < 2 then 
        isprime := false
    else if even(n) then 
        isprime := (n = 2)
    else
        begin
           comment - check odd divisors up to sqrt(n);
           integer i, limit;
           boolean divisible;
           i := 3;
           limit := entier(sqrt(n));
           divisible := false;
           for i := i while i <= limit and not divisible do 
              begin
                 if entier(n / i) * i = n then
                     divisible := true;
                 i := i + 2
              end;          
           isprime := not divisible;
        end;
end;

comment - main code begins here;

integer i, count;
count := 0;
for i := 2 step 1 until 999 do
  if isprime(i) then
     begin
        if ispalindrome(i) then
           begin
              outinteger(1,i);
              count := count + 1;
           end;
     end;
outstring(1,"\n");
outinteger(1,count);
outstring(1,"palindromic primes were found below 1000");

end
Output:
 2  3  5  7  11  101  131  151  181  191  313  353  373  383  727  757  787  797  919  929 
 20 palindromic primes were found below 1000

ALGOL 68

Generates the palindrmic 3 digit numbers and uses the observations that all 1 digit primes are palindromic and that for 2 digit numbers, only multiples of 11 are palindromic and hence 11 is the only two digit palindromic prime.

Library: ALGOL 68-primes
BEGIN  # find primes that are palindromic in base 10                         #
    INT max prime = 999;
    # sieve the primes to max prime                                          #
    PR read "primes.incl.a68" PR
    []BOOL prime = PRIMESIEVE max prime;
    # print the palendromic primes in the base 10                            #
    # all 1 digit primes are palindromic                                     #
    # the only palindromic 2 digit numbers are multiples of 11               #
    # so 11 is the only possible 2 digit palindromic prime                   #
    FOR n TO 11 DO IF prime[ n ] THEN print( ( " ", whole( n, 0 ) ) ) FI OD;
    # three digit numbers, the first and last digits must be odd             #
    # and cannot be 5 (as the number would be divisible by 5)                #
    FOR fl BY 2 TO 9 DO
        IF fl /= 5 THEN
            FOR m FROM 0 TO 9 DO
                INT n = ( ( ( fl * 10 ) + m ) * 10 ) + fl;
                IF prime[ n ] THEN
                    # have a palindromic prime #
                    print( ( " ", whole( n, 0 ) ) )
                FI
            OD
        FI
    OD;
    print( ( newline ) )
END
Output:
 2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

ALGOL-M

Generating primes using the venerable Sieve of Erathosthenes is marginally faster on ancient hardware systems than applying an isprime() function across the equivalent range of values. The strategy for determining whether the candidate is a palindrome is borrowed from a 1974 paper by Niklaus Wirth, "On the Composition of Well-Structured Programs." 

begin

% return 1 if n is a palindrome, otherwise 0 %
integer function ispalindrome(n);
   integer n;
begin
   integer i, j, q;
   integer array d[1:10];
   j := 0;
   while n > 0 do   % decompose n into its digits %
     begin
       j := j + 1;
       q := n / 10;
       d[j] := n - q * 10;
       n := q;
     end;
   i := 1;  
   % j already points at last digit %
   while i < j and d[i] = d[j] do
     begin   
       i := i + 1;
       j := j - 1;
     end;
  ispalindrome := if d[i] = d[j] then 1 else 0;
end;

integer limit, i, j, false, true, count;
integer array primes[1:999];

limit := 999;
false := 0;
true := 1;

% every number above 1 is potentially prime %
primes[1] := 0;
for i := 2 step 1 until limit do
  primes[i] := true;

% sieve by striking out multiples of each prime found %
for i := 2 step 1 until limit do
  begin
    if primes[i] = true then
       for j := (i + i) step i until limit do
         primes[j] := false;
  end;

% display those that are palindromes %
count := 0;
for i := 2 step 1 until limit do
  begin
    if primes[i] = true and ispalindrome(i) = true then
      begin
        writeon(i, "  ");  % wraps nicely on 80 col screen % 
        count := count + 1;
      end;
  end;

write(count, " palindromic primes were found");

end
Output:
     2       3       5       7      11     101     131     151     181     191
   313     353     373     383     727     757     787     797     919     929

    20 palindromic primes were found

Arturo 

loop split.every: 10 select 2..1000 'x [
    and? prime? x
         x = to :integer reverse to :string x
] 'a -> print map a => [pad to :string & 4]
Output:
   2    3    5    7   11  101  131  151  181  191 
 313  353  373  383  727  757  787  797  919  929

AWK 

# syntax: GAWK -f PALINDROMIC_PRIMES.AWK
BEGIN {
    start = 1
    stop = 999
    for (i=start; i<=stop; i++) {
      if (is_prime(i) && reverse(i) == i) {
        printf("%d ",i)
        count++
      }
    }
    printf("\nPalindromic primes %d-%d: %d\n",start,stop,count)
    exit(0)
}
function is_prime(x,  i) {
    if (x <= 1) {
      return(0)
    }
    for (i=2; i<=int(sqrt(x)); i++) {
      if (x % i == 0) {
        return(0)
      }
    }
    return(1)
}
function reverse(str,  i,rts) {
    for (i=length(str); i>=1; i--) {
      rts = rts substr(str,i,1)
    }
    return(rts)
}
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929
Palindromic primes 1-999: 20

BASIC 

10 DEFINT A-Z
20 FOR N=2 TO 1000
30 I=N: J=0
40 J=J*10+I MOD 10: I=I\10: IF I>0 THEN 40
50 IF J<>N THEN 80
60 FOR I=2 TO SQR(N): IF N MOD I=0 THEN 80 ELSE NEXT I
70 PRINT N,
80 NEXT N
Output:
 2             3             5             7             11
 101           131           151           181           191
 313           353           373           383           727
 757           787           797           919           929

BCPL 

get "libhdr"

let prime(n) = 
    n<2 -> false,
    (n & 1) = 0 -> n = 2,
    valof
$(  let d = 3
    while d*d <= n
    $(  if n rem d=0 resultis false
        d := d+2
    $)
    resultis true
$)

let reverse(n) = valof
$(  let r = 0
    until n=0
    $(  r := r*10 + n rem 10
        n := n/10
    $)
    resultis r
$)

let start() be
$(  for i = 1 to 1000
        if reverse(i)=i & prime(i) do writef("%N ",i)
    wrch('*N')
$)
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

C 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool ispalindromic(int n) {
    int i, j;
	char s[20];
	itoa(n, s, 10);
	i = 0;
	j = strlen(s) - 1;
	while (i < j) {
		if (s[i] != s[j]) return false;
		i++;
		j--;
	}
	return true;
}

bool isprime(int n) {
	int i;
	if (n < 2) return false;
	if (n % 2 == 0) return (n == 2);
	for (i = 3; i * i <= n; i += 2) {
		if (n % i == 0) return false;
	}
	return true;
}

int main(void) {
	int i, count;
	count = 0;
	for (i = 2; i <= 1000; i++) {
		if (isprime(i) && ispalindromic(i)) {
			printf("%d ", i);
			count++;
		}
	}
	printf("\nFound %d palindromic primes\n", count);
	return EXIT_SUCCESS;
}
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929
Found 20 palindromic primes

C++

This includes a solution for the similar task Palindromic primes in base 16. 

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>

unsigned int reverse(unsigned int base, unsigned int n) {
    unsigned int rev = 0;
    for (; n > 0; n /= base)
        rev = rev * base + (n % base);
    return rev;
}

class palindrome_generator {
public:
    explicit palindrome_generator(unsigned int base)
        : base_(base), upper_(base) {}
    unsigned int next_palindrome();

private:
    unsigned int base_;
    unsigned int lower_ = 1;
    unsigned int upper_;
    unsigned int next_ = 0;
    bool even_ = false;
};

unsigned int palindrome_generator::next_palindrome() {
    ++next_;
    if (next_ == upper_) {
        if (even_) {
            lower_ = upper_;
            upper_ *= base_;
        }
        next_ = lower_;
        even_ = !even_;
    }
    return even_ ? next_ * upper_ + reverse(base_, next_)
                 : next_ * lower_ + reverse(base_, next_ / base_);
}

bool is_prime(unsigned int n) {
    if (n < 2)
        return false;
    if (n % 2 == 0)
        return n == 2;
    if (n % 3 == 0)
        return n == 3;
    for (unsigned int p = 5; p * p <= n; p += 4) {
        if (n % p == 0)
            return false;
        p += 2;
        if (n % p == 0)
            return false;
    }
    return true;
}

std::string to_string(unsigned int base, unsigned int n) {
    assert(base <= 36);
    static constexpr char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    std::string str;
    for (; n != 0; n /= base)
        str += digits[n % base];
    std::reverse(str.begin(), str.end());
    return str;
}

void print_palindromic_primes(unsigned int base, unsigned int limit) {
    auto width =
        static_cast<unsigned int>(std::ceil(std::log(limit) / std::log(base)));
    unsigned int count = 0;
    auto columns = 80 / (width + 1);
    std::cout << "Base " << base << " palindromic primes less than " << limit
              << ":\n";
    palindrome_generator pgen(base);
    unsigned int palindrome;
    while ((palindrome = pgen.next_palindrome()) < limit) {
        if (is_prime(palindrome)) {
            ++count;
            std::cout << std::setw(width) << to_string(base, palindrome)
                      << (count % columns == 0 ? '\n' : ' ');
        }
    }
    if (count % columns != 0)
        std::cout << '\n';
    std::cout << "Count: " << count << '\n';
}

void count_palindromic_primes(unsigned int base, unsigned int limit) {
    unsigned int count = 0;
    palindrome_generator pgen(base);
    unsigned int palindrome;
    while ((palindrome = pgen.next_palindrome()) < limit)
        if (is_prime(palindrome))
            ++count;
    std::cout << "Number of base " << base << " palindromic primes less than "
              << limit << ": " << count << '\n';
}

int main() {
    print_palindromic_primes(10, 1000);
    std::cout << '\n';
    print_palindromic_primes(10, 100000);
    std::cout << '\n';
    count_palindromic_primes(10, 1000000000);
    std::cout << '\n';
    print_palindromic_primes(16, 500);
}
Output:
Base 10 palindromic primes less than 1000:
  2   3   5   7  11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929
Count: 20

Base 10 palindromic primes less than 100000:
    2     3     5     7    11   101   131   151   181   191   313   353   373
  383   727   757   787   797   919   929 10301 10501 10601 11311 11411 12421
12721 12821 13331 13831 13931 14341 14741 15451 15551 16061 16361 16561 16661
17471 17971 18181 18481 19391 19891 19991 30103 30203 30403 30703 30803 31013
31513 32323 32423 33533 34543 34843 35053 35153 35353 35753 36263 36563 37273
37573 38083 38183 38783 39293 70207 70507 70607 71317 71917 72227 72727 73037
73237 73637 74047 74747 75557 76367 76667 77377 77477 77977 78487 78787 78887
79397 79697 79997 90709 91019 93139 93239 93739 94049 94349 94649 94849 94949
95959 96269 96469 96769 97379 97579 97879 98389 98689 
Count: 113

Number of base 10 palindromic primes less than 1000000000: 5953

Base 16 palindromic primes less than 500:
  2   3   5   7   B   D  11 101 151 161 191 1B1 1C1 
Count: 13

Cowgol 

sub prime(n: uint16): (r: uint8) is
    r := 0;
    if n<2 then return; end if;
    var d: uint16 := 2;
    while d*d <= n loop
        if n%d==0 then return; end if;
        d := d+1;
    end loop;
    r := 1;
end sub;

sub reverse(n: uint16): (r: uint16) is
    r := 0;
    while n>0 loop
        r := r*10 + n%10;
        n := n/10;
    end loop;
end sub;

var n: uint16 := 1;
while n<1000 loop
    if reverse(n) == n and prime(n) != 0 then
        print_i16(n);
        print_char(' ');
    end if;
    n := n+1;
end loop;
print_nl();
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929


Delphi

Works with: Delphi version 6.0
Library: SysUtils,StdCtrls


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 IsPalindrome(N, Base: integer): boolean;
{Test if number is the same forward or backward}
{For a specific Radix}
var S1,S2: string;
begin
S1:=GetRadixString(N,Base);
S2:=ReverseString(S1);
Result:=S1=S2;
end;


procedure ShowPalindromePrimes(Memo: TMemo);
var I: integer;
var Cnt: integer;
var S: string;
begin
Cnt:=0;
for I:=1 to 1000-1 do
 if IsPrime(I) then
  if IsPalindrome(I,10) then
	begin
	Inc(Cnt);
	S:=S+Format('%4D',[I]);
	If (Cnt mod 5)=0 then S:=S+CRLF;
	end;
Memo.Lines.Add(S);
Memo.Lines.Add('Count='+IntToStr(Cnt));
end;
Output:
   2   3   5   7  11
 101 131 151 181 191
 313 353 373 383 727
 757 787 797 919 929

Count=20
Elapsed Time: 2.117 ms.

Draco 

proc prime(word n) bool:
    word d;
    bool p;
    if n<2 then false
    elif (n&1) = 0 then n=2
    else
        d := 3;
        p := true;
        while p and d*d <= n do
            p := n % d /= 0;
            d := d+2
        od;
        p
    fi
corp

proc reverse(word n) word:
    word r;
    r := 0;
    while n>0 do
        r := r*10 + n%10;
        n := n/10
    od;
    r
corp

proc main() void:
    word i;
    for i from 1 upto 1000 do
        if reverse(i) = i and prime(i) then
            write(i);
            write(' ')
        fi
    od
corp
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

EasyLang 

fastfunc isprim num .
   i = 2
   while i <= sqrt num
      if num mod i = 0
         return 0
      .
      i += 1
   .
   return 1
.
func reverse s .
   while s > 0
      e = e * 10 + s mod 10
      s = s div 10
   .
   return e
.
for i = 2 to 999
   if isprim i = 1
      if reverse i = i
         write i & " "
      .
   .
.
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

Factor

Simple

A simple solution that suffices for the task:

Works with: Factor version 0.99 2021-02-05
USING: kernel math.primes present prettyprint sequences ;

1000 primes-upto [ present dup reverse = ] filter stack.
Output:
2
3
5
7
11
101
131
151
181
191
313
353
373
383
727
757
787
797
919
929

Fast

A much more efficient solution that generates palindromic numbers directly and filters primes from them:

Works with: Factor version 0.99 2021-02-05
USING: io kernel lists lists.lazy math math.functions
math.primes math.ranges prettyprint sequences
tools.memory.private ;

! Create a palindrome from its base natural number.
: create-palindrome ( n odd? -- m )
    dupd [ 10 /i ] when swap [ over 0 > ]
    [ 10 * [ 10 /mod ] [ + ] bi* ] while nip ;
 
! Create an ordered infinite lazy list of palindromic numbers.
: lpalindromes ( -- l )
    0 lfrom [
        10 swap ^ dup 10 * [a,b)
        [ [ t create-palindrome ] map ]
        [ [ f create-palindrome ] map ] bi
        [ sequence>list ] bi@ lappend
    ] lmap-lazy lconcat ;

: lpalindrome-primes ( -- list )
    lpalindromes [ prime? ] lfilter ;

"10,000th palindromic prime:" print
9999 lpalindrome-primes lnth commas print nl

"Palindromic primes less than 1,000:" print
lpalindrome-primes [ 1000 < ] lwhile [ . ] leach
Output:
10,000th palindromic prime:
13,649,694,631

Palindromic primes less than 1,000:
2
3
5
7
11
101
131
151
181
191
313
353
373
383
727
757
787
797
919
929

FreeBASIC 

#include "isprime.bas"

function is_pal( s as string ) as boolean
    dim as integer i, n = len(s)
    for i = 1 to n\2
        if mid(s,i,1)<>mid(s,n-i+1,1) then return false
    next i
    return true
end function

for i as uinteger = 2 to 999
    if is_pal( str(i) ) andalso isprime(i) then  print i;" ";
next i : print
Output:

2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

Go

Translation of: Wren
Library: Go-rcu
package main

import (
    "fmt"
    "rcu"
)

func reversed(n int) int {
    rev := 0
    for n > 0 {
        rev = rev*10 + n%10
        n /= 10
    }
    return rev
}

func main() {
    primes := rcu.Primes(99999)
    var pals []int
    for _, p := range primes {
        if p == reversed(p) {
            pals = append(pals, p)
        }
    }
    fmt.Println("Palindromic primes under 1,000:")
    var smallPals, bigPals []int
    for _, p := range pals {
        if p < 1000 {
            smallPals = append(smallPals, p)
        } else {
            bigPals = append(bigPals, p)
        }
    }
    rcu.PrintTable(smallPals, 10, 3, false)
    fmt.Println()
    fmt.Println(len(smallPals), "such primes found.")

    fmt.Println("\nAdditional palindromic primes under 100,000:")
    rcu.PrintTable(bigPals, 10, 6, true)
    fmt.Println()
    fmt.Println(len(bigPals), "such primes found,", len(pals), "in all.")
}
Output:
Same as Wren entry.

Haskell 

import Data.Numbers.Primes

palindromicPrimes :: [Integer]
palindromicPrimes =
  filter (((==) <*> reverse) . show) primes

main :: IO ()
main =
  mapM_ print $
    takeWhile
      (1000 >)
      palindromicPrimes
Output:
2
3
5
7
11
101
131
151
181
191
313
353
373
383
727
757
787
797
919
929

J 

   palindromic=: (-: |.)@":@>
   (#~ palindromic) p: i. p:inv 1000
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

Java 

 
import java.util.stream.IntStream;

public final class PalindromicPrimes {

	public static void main(String[] args) {	
		IntStream.range(2, 1_000)
			.filter( i -> IntStream.range(2, i).noneMatch( p -> i % p == 0 ) )
			.mapToObj(Integer::toString)
			.filter( s -> s.equals( new StringBuilder(s).reverse().toString() ) )
			.forEach( s -> System.out.print(s + " ") );
	}	

}
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

jq

Works with: jq

Works with gojq, the Go implementation of jq

In this entry, we define both a naive generate-and-test generator of the palindromic primes, and a more sophisticated one that is well-suited for generating very large numbers of such primes, as illustrated by counting the number less than 10^10.

For a suitable implementation of `is_prime` as used here, see Erdős-primes#jq.

Preliminaries 

def count(s): reduce s as $x (null; .+1);

def emit_until(cond; stream): label $out | stream | if cond then break $out else . end;

Naive version 

def primes:
  2, (range(3;infinite;2) | select(is_prime));

def palindromic_primes_slowly:
  primes | select( tostring|explode | (. == reverse));

Less naive version 

# Output: an unbounded stream of palindromic primes
def palindromic_primes:

  # Output: a naively constructed stream of palindromic strings of length >= 2
  def palindromic_candidates:
    def rev: # reverse a string
      explode|reverse|implode;
    def unconstrained($length):
      if $length==1 then range(0;10) | tostring
      else (range(0;10)|tostring)
      | . + unconstrained($length -1 )
      end;
    def middle($length):  # $length > 0
      if $length==1 then range(0;10) | tostring
      elif $length % 2 == 1
      then (($length -1) / 2) as $len
      | unconstrained($len) as $left
      | (range(0;10) | tostring) as $mid
      | $left + $mid + ($left|rev)
      else ($length / 2) as $len
      | unconstrained($len) as $left
      | $left + ($left|rev)
      end;
  
  # palindromes with an even number of digits are divisible by 11

    range(1;infinite;2) as $mid
    | ("1", "3", "7", "9") as $start
    | $start + middle($mid) + $start ;
  
  2, 3, 5, 7, 11,
  (palindromic_candidates | tonumber | select(is_prime));

Demonstrations 

"Palindromic primes < 1000:",
emit_until(. >= 1000;  palindromic_primes),

((range(5;11) | pow(10;.)) as $n
 | "\nNumber of palindromic primes <= \($n): \(count(emit_until(. >= $n; palindromic_primes)))" )
Output:
Palindromic primes <= 1000:
2
3
5
7
11
101
131
151
181
191
313
353
373
383
727
757
787
797
919
929

Number of palindromic primes <= 100000: 113

Number of palindromic primes <= 1000000: 113

Number of palindromic primes <= 10000000: 781

Number of palindromic primes <= 100000000: 781

Number of palindromic primes <= 1000000000: 5953

Number of palindromic primes <= 10000000000: 5953

Julia

Generator method. 

using Primes

parray = [2, 3, 5, 7, 9, 11]

results = vcat(parray, filter(isprime, [100j + 10i + j for i in 0:9, j in 1:9]))

println(results)
Output:
[2, 3, 5, 7, 9, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787, 797, 919, 929]

Mathematica /Wolfram Language 

Select[Range[999], PrimeQ[#] \[And] PalindromeQ[#] &]
Output:
{2, 3, 5, 7, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787, 797, 919, 929}

Nim 

import strutils

const N = 999

func isPrime(n: Positive): bool =
  if (n and 1) == 0: return n == 2
  var m = 3
  while m * m <= n:
    if n mod m == 0: return false
    inc m, 2
  result = true

func reversed(n: Positive): int =
  var n = n.int
  while n != 0:
    result = 10 * result + n mod 10
    n = n div 10

func isPalindromic(n: Positive): bool =
  n == reversed(n)

var result: seq[int]
for n in 2..N:
  if n.isPrime and n.isPalindromic:
    result.add n

for i, n in result:
  stdout.write ($n).align(3)
  stdout.write if (i + 1) mod 10 == 0: '\n' else: ' '
Output:
  2   3   5   7  11 101 131 151 181 191
313 353 373 383 727 757 787 797 919 929

Oberon-07

Based on the Algol 68 sample with the Sieve routine from the Additive Primes task. 

MODULE PalindromicPrimes; (* find primes that are palendromic in base 10    *)
IMPORT
  Out;

CONST
  Max = 999;

VAR
  fl, m, n :INTEGER;
  Prime    :ARRAY Max + 1 OF BOOLEAN;

PROCEDURE Sieve;
  VAR     i, j    :INTEGER;
  BEGIN
    Prime[ 0 ] := FALSE; Prime[ 1 ] := FALSE;
    FOR i := 2 TO Max DO Prime[ i ] := TRUE END;
    FOR i := 2 TO Max DIV 2 DO
      IF Prime[ i ] THEN
        j := i * 2;
        WHILE j <= Max DO
          Prime[ j ] := FALSE;
          INC( j, i )
        END
      END
    END
  END Sieve;

PROCEDURE OutN;
  BEGIN
    Out.String( " " );Out.Int( n, 0 )
  END OutN;

BEGIN
  Sieve;
  (* print the palendromic primes in the base 10                            *)
  (* all 1 digit primes are palindromic                                     *)
  (* the only palindromic 2 digit numbers are multiples of 11               *)
  (* so 11 is the only possible 2 digit palindromic prime                   *)
  FOR n := 1 TO 11 DO IF Prime[ n ] THEN OutN END END;

  (* three digit numbers, the first and last digits must be odd             *)
  (* and cannot be 5 (as the number would be divisible by 5)                *)
  FOR fl := 1 TO 9 BY 2 DO
    IF fl # 5 THEN
      FOR m := 0 TO 9 DO
        n := ( ( ( fl * 10 ) + m ) * 10 ) + fl;
        IF Prime[ n ] THEN
          (* have a palindromic prime                                       *)
          OutN
        END
      END
    END
  END;
  Out.Ln
END PalindromicPrimes.
Output:
 2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

PARI/GP

naive 

forprime(i = 2, 1000,
    if(  i == fromdigits( Vecrev( digits( i ) )) ,
        print1( i, " " ) ) );
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

faster 

p10( n ) = 10^n;
 
rew( m, c ) = {
    local( t, n );
    t = 0; n = m;
    for(i=1, c,
        t = t*10 + n%10;
        n \= 10 );
    return( t ) }
 
range( p, w, disp = 0 ) = {
    local( w10, mi, mj, z, pal, q ,k = -1);
    w10 = p * p10( w ) + p;
    mi  = p10( w \ 2 + 1 );
    mj  = p10( w \ 2     );
    z   = p10( w \ 2 - 1 ) - 1;
    for( i = 0, z,
        pal = rew( i, w\2 );
        q = w10  + i * mi + pal;
        for( j = 0, 9,
            if( isprime(q + j * mj ),
                k++;
                if( disp,
                   if((k % 8)==0,print());
                   print1( q + j * mj, "\t") ) ) ) );
    return( [ k+1, q + 9*mj ]); }

gener( disp=0 ) = {
    local( t=[ 1, 3, 7, 9], s=5, x,start );
    start = getabstime();
    for( w = 1, 8,
        for( i = 1, 20 - 2*w, print1(" "));
        print1( p10(w*2));
        for( i = 1, 4,
            print1(".");
            x=range(t[i], w*2, disp);
            s+=x[1]; );
    printf( "\t   # %8d   %8.3g [sec]\n", 
                ,  s,  (getabstime()-start)/1000.0) )
}
Output:
                 100....          #       20     0.e-19 [sec]
               10000....          #      113     0.e-19 [sec]
             1000000....          #      781     0.e-19 [sec]
           100000000....          #     5953     0.0620 [sec]
         10000000000....          #    47995      0.718 [sec]
       1000000000000....          #   401696       7.72 [sec]
     100000000000000....          #  3438339       86.2 [sec]

Perl 

#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Palindromic_primes
use warnings;

$_ == reverse and (1 x $_ ) !~ /^(11+)\1+$/ and print "$_ " for 2 .. 1e3;
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

Phix

filter primes for palindromicness

function palindrome(string s) return s=reverse(s) end function
for l=3 to 5 by 2 do
    integer limit = power(10,l) -- 1000 then 100000
    sequence res = get_primes_le(limit)
    res = apply(true,sprintf,{{"%d"},res})
    res = filter(res,palindrome)
    string s = join(shorten(res,"",5))
    printf(1,"found %d < %,d: %s\n",{length(res),limit,s})
end for
Output:
found 20 < 1,000: 2 3 5 7 11 ... 757 787 797 919 929
found 113 < 100,000: 2 3 5 7 11 ... 97379 97579 97879 98389 98689

filter palindromes for primality

sequence r = {}
for l=2 to 3 do
    for i=1 to power(10,l) do
        string s = sprintf("%d",i)
        integer t = to_number(s&reverse(s[1..$-1])),
                u = to_number(s&reverse(s))
        if is_prime(t) then r &= t end if
        if is_prime(u) then r &= u end if
    end for
    r = unique(r)
    string s = join(shorten(apply(true,sprintf,{{"%d"},r}),"",5))
    printf(1,"found %d < %,d: %s\n",{length(r),power(10,l*2-1),s})
end for

Same output. Didn't actually test if this way was any faster, but expect it would be.

PL/I-80 

palindromic_primes: procedure options (main);

  %replace
    search_limit by 1000,
    true by '1'b,
    false by '0'b;

  dcl
    (k, count) fixed bin;

  put skip edit('Showing palindromic primes up to ',search_limit) (a,f(4));
  put skip;
  count = 0;
  do k = 2 to search_limit;
    if isprime(k) & ispalindrome(k) then
        do;
          put edit(k) (f(6));
          count = count + 1;
          if mod(count,8) = 0 then put skip;
        end;
  end;
  put skip edit(count, ' were found') (f(4),a);

isprime: proc(n) returns (bit(1));
   dcl
     (n, i, limit) fixed bin;
   /* deal with special cases first */
   if n < 2 then return (false);
   if mod(n, 2) = 0 then return (n = 2);
   /* else search up to sqrt of n for divisors */
   limit = floor(sqrt(n));
   /* aside from 2, only odd numbers can be prime */
   i = 3;
   do while ((i <= limit) & (mod(n, i) ^= 0));
     i = i + 2;
   end;
   return (i > limit);   
end isprime;

ispalindrome: proc(n) returns (bit(1));
   dcl
      (n, nn, q, nd, i, j) fixed bin,
      digits(1:10) fixed bin;
      /* n is passed by reference, and is modified by */
      /* the algorithm, so we work with a local copy */
      nn = n;
      /* strip off digits and store in array */
      nd = 0;  /* digits found so far */
      do while (nn > 0);
         nd = nd + 1;
         q = floor(nn / 10);
         digits(nd) = nn - q * 10;
         nn = q;
      end;
      /* move from outside in looking for equality */
      i = 1;
      j = nd;
      do while ((i < j) & (digits(i) = digits(j)));
         i = i + 1;
         j = j - 1;
      end;
      return (digits(i) = digits(j));
end ispalindrome;

end palindromic_primes;
Output:
Showing palindromic primes up to 1000
     2     3     5     7    11   101   131   151
   181   191   313   353   373   383   727   757
   787   797   919   929
  20 were found



PL/M 

100H:
BDOS: PROCEDURE (FN,ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
PRINT$CHAR: PROCEDURE (C); DECLARE C BYTE; CALL BDOS(2, C); END PRINT$CHAR;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9, S); END PRINT;
DECLARE FALSE LITERALLY '0', TRUE LITERALLY '0FFH';

PRINT$NUM: PROCEDURE (N);
    DECLARE S (6) BYTE INITIAL ('.....$');
    DECLARE (N, P) ADDRESS, DG BASED P BYTE;
    P = .S(5);
DIGIT:
    P = P-1;
    DG = N MOD 10 + '0';
    IF (N := N/10) > 0 THEN GO TO DIGIT;
    CALL PRINT(P);
END PRINT$NUM;

PRIME: PROCEDURE (N) BYTE;
    DECLARE (N, I) ADDRESS;
    IF N<2 THEN RETURN FALSE;
    IF NOT N THEN RETURN N=2;
    I = 3;
    DO WHILE I*I <= N;
        IF N MOD I=0 THEN RETURN FALSE;
        I = I+2;
    END;
    RETURN TRUE;
END PRIME;

REVERSE: PROCEDURE (N) ADDRESS;
    DECLARE (N, R) ADDRESS;
    R = 0;
    DO WHILE N>0;
        R = R*10 + (N MOD 10);
        N = N/10;
    END;
    RETURN R;
END REVERSE;

PALINDROME: PROCEDURE (N) BYTE;
    DECLARE N ADDRESS;
    RETURN REVERSE(N) = N;
END PALINDROME;

DECLARE I ADDRESS;
DO I=1 TO 1000;
    IF PALINDROME(I) AND PRIME(I) THEN DO;
        CALL PRINT$NUM(I);
        CALL PRINT$CHAR(' ');
    END;
END;
CALL EXIT;
EOF
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

Python

A non-finite generator of palindromic primes – one of many approaches to solving this problem in Python. 

'''Palindromic primes'''

from itertools import takewhile


# palindromicPrimes :: Generator [Int]
def palindromicPrimes():
    '''An infinite stream of palindromic primes'''
    def p(n):
        s = str(n)
        return s == s[::-1]
    return (n for n in primes() if p(n))


# ------------------------- TEST -------------------------
def main():
    '''Palindromic primes below 1000'''
    print('\n'.join(
        str(x) for x in takewhile(
            lambda n: 1000 > n,
            palindromicPrimes()
        )
    ))


# ----------------------- GENERIC ------------------------

# primes :: [Int]
def primes():
    ''' Non finite sequence of prime numbers.
    '''
    n = 2
    dct = {}
    while True:
        if n in dct:
            for p in dct[n]:
                dct.setdefault(n + p, []).append(p)
            del dct[n]
        else:
            yield n
            dct[n * n] = [n]
        n = 1 + n


# MAIN ---
if __name__ == '__main__':
    main()
Output:
2
3
5
7
11
101
131
151
181
191
313
353
373
383
727
757
787
797
919
929

Quackery

eratosthenes and isprime are defined at Sieve of Eratosthenes#Quackery 

  [ [] swap 
    [ base share /mod 
      rot swap join swap
      dup 0 = until ]
    drop ]                      is digits       ( n --> [ )
    
  [ dup reverse = ]             is palindromic  ( [ --> b )
 
1000 eratosthenes
 
1000 times
  [ i^ isprime if 
    [ i^ digits palindromic if 
      [ i^ echo sp ] ] ]
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929


Raku 

say "{+$_} matching numbers:\n{.batch(10)».fmt('%3d').join: "\n"}"
    given (^1000).grep: { .is-prime and $_ eq .flip };
Output:
20 matching numbers:
  2   3   5   7  11 101 131 151 181 191
313 353 373 383 727 757 787 797 919 929

Refal 

$ENTRY Go {
    = <Prout <Filter Prime <Filter Palindromic <Iota 1 1000>>>>;
};

Iota {
    s.End s.End = s.End;
    s.Start s.End = s.Start <Iota <+ 1 s.Start> s.End>;
};

Filter {
    s.Filter = ;
    s.Filter s.N e.Ns, <Mu s.Filter s.N>: {
        True = s.N <Filter s.Filter e.Ns>;
        False = <Filter s.Filter e.Ns>;
    };
};

Prime {
    s.N, <Compare s.N 2>: '-' = False;
    s.N = <Prime s.N 2>;
    s.N s.D, <Compare s.N <* s.D s.D>>: '-' = True;
    s.N s.D, <Mod s.N s.D>: 0 = False;
    s.N s.D = <Prime s.N <+ s.D 1>>;
};

Palindromic {
    s.N, <Symb s.N>: e.S, <Reverse e.S>: e.S = True;
    s.N = False;
};

Reverse {
    = ;
    s.C e.X = <Reverse e.X> s.C;
};
Output:
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929

REXX

Modules: How to use
Modules: Source code
After sieving primes (Primes in Sequences, also flags them), primality testing is easy. 

-- 25 Mar 2025
include Settings

say 'PALINDROMIC PRIMES'
say version
say
arg xx
if xx = '' then
   xx = 1000
call GetPrimes xx
call ShowPalindromes xx
exit

GetPrimes:
procedure expose prim. flag.
arg xx
call Time('r')
say 'Get primes up to' xx'...'
call Primes(xx)
say Format(Time('e'),,3) 'seconds'; say
return

ShowPalindromes:
procedure expose prim. flag.
arg xx
call Time('r')
say 'Palindromic primes up to' xx'...'
a = Xpon(xx)+1
n = 0
do i = 1 to prim.0
   p = prim.i
   q = Reverse(p)
   if p <> q then
      iterate
   if flag.q then do
      n = n+1
      if xx <= 1e5 then do
         call Charout ,Right(p,a)
         if n//10 = 0 then
            say
      end
   end
end
say
say n 'such numbers found'
say Format(Time('e'),,3) 'seconds'; say
return

include Sequences
include Functions
include Constants
include Abend
Output:
PALINDROMIC PRIMES
REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024

Get primes up to 1000...
0.000 seconds

Palindromic primes up to 1000...
   2   3   5   7  11 101 131 151 181 191
 313 353 373 383 727 757 787 797 919 929

20 such numbers found
0.000 seconds

Some higher numbers, count only. 

PALINDROMIC PRIMES
REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024

Get primes up to 1E6...
0.275 seconds

Palindromic primes up to 1E6...
113 such numbers found
0.023 seconds

Get primes up to 1E7...
3.139 seconds

Palindromic primes up to 1E7...
781 such numbers found
0.229 seconds

Get primes up to 5E7...
18.004 seconds

Palindromic primes up to 5E7...
781 such numbers found
0.904 seconds

Ring 

load "stdlib.ring"
 
see "working..." + nl
see "Palindromic primes are:" + nl
row = 0
limit1 = 1000
limit2 = 100000

palindromicPrimes(limit1)
 
see "Found " + row + " palindromic primes" + nl + nl
see "palindromic primes that are  <  100,000" + nl

palindromicPrimes(limit2)
 
see nl + "Found " + row + " palindromic primes that are < 100,000" + nl
see "done..." + nl

func palindromicPrimes(limit)
     row = 0 
     for n = 1 to limit
         strn = string(n)
         if ispalindrome(strn) and isprime(n)
            row = row + 1
            see "" + n + " "
            if row%5 = 0
               see nl
            ok
         ok
     next
Output:
working...
Palindromic primes are:
2 3 5 7 11 
101 131 151 181 191 
313 353 373 383 727 
757 787 797 919 929 
Found 20 palindromic primes

palindromic primes that are  <  100,000
2 3 5 7 11 
101 131 151 181 191 
313 353 373 383 727 
757 787 797 919 929 
10301 10501 10601 11311 11411 
12421 12721 12821 13331 13831 
13931 14341 14741 15451 15551 
16061 16361 16561 16661 17471 
17971 18181 18481 19391 19891 
19991 30103 30203 30403 30703 
30803 31013 31513 32323 32423 
33533 34543 34843 35053 35153 
35353 35753 36263 36563 37273 
37573 38083 38183 38783 39293 
70207 70507 70607 71317 71917 
72227 72727 73037 73237 73637 
74047 74747 75557 76367 76667 
77377 77477 77977 78487 78787 
78887 79397 79697 79997 90709 
91019 93139 93239 93739 94049 
94349 94649 94849 94949 95959 
96269 96469 96769 97379 97579 
97879 98389 98689 
Found 113 palindromic primes that are < 100,000
done...

RPL

Works with: HP version 49g
≪ →STR → n
  ≪ ""
     n SIZE 1 FOR j
        n j DUP SUB + 
     -1 STEP STR→
≫ ≫ 'REVN' STO

≪ { } 2
   DO 
      IF DUP DUP REVN == THEN SWAP OVER + SWAP END
      NEXTPRIME
   UNTIL DUP 1000 > END
   DROP
≫ 'TASK' STO

{{out} 

1: {2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929}

Rust

This includes a solution for the similar task Palindromic primes in base 16. 

// [dependencies]
// primal = "0.3"
// radix_fmt = "1.0"

fn reverse(base: u64, mut n: u64) -> u64 {
    let mut rev = 0;
    while n > 0 {
        rev = rev * base + n % base;
        n /= base;
    }
    rev
}

fn palindromes(base: u64) -> impl std::iter::Iterator<Item = u64> {
    let mut lower = 1;
    let mut upper = base;
    let mut next = 0;
    let mut even = false;
    std::iter::from_fn(move || {
        next += 1;
        if next == upper {
            if even {
                lower = upper;
                upper *= base;
            }
            next = lower;
            even = !even;
        }
        Some(match even {
            true => next * upper + reverse(base, next),
            _ => next * lower + reverse(base, next / base),
        })
    })
}

fn print_palindromic_primes(base: u64, limit: u64) {
    let width = (limit as f64).log(base as f64).ceil() as usize;
    let mut count = 0;
    let columns = 80 / (width + 1);
    println!("Base {} palindromic primes less than {}:", base, limit);
    for p in palindromes(base)
        .take_while(|x| *x < limit)
        .filter(|x| primal::is_prime(*x))
    {
        count += 1;
        print!(
            "{:>w$}",
            radix_fmt::radix(p, base as u8).to_string(),
            w = width
        );
        if count % columns == 0 {
            println!();
        } else {
            print!(" ");
        }
    }
    if count % columns != 0 {
        println!();
    }
    println!("Count: {}", count);
}

fn count_palindromic_primes(base: u64, limit: u64) {
    let c = palindromes(base)
        .take_while(|x| *x < limit)
        .filter(|x| primal::is_prime(*x))
        .count();
    println!(
        "Number of base {} palindromic primes less than {}: {}",
        base, limit, c
    );
}

fn main() {
    print_palindromic_primes(10, 1000);
    println!();
    print_palindromic_primes(10, 100000);
    println!();
    count_palindromic_primes(10, 1000000000);
    println!();
    print_palindromic_primes(16, 500);
}
Output:
Base 10 palindromic primes less than 1000:
  2   3   5   7  11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929
Count: 20

Base 10 palindromic primes less than 100000:
    2     3     5     7    11   101   131   151   181   191   313   353   373
  383   727   757   787   797   919   929 10301 10501 10601 11311 11411 12421
12721 12821 13331 13831 13931 14341 14741 15451 15551 16061 16361 16561 16661
17471 17971 18181 18481 19391 19891 19991 30103 30203 30403 30703 30803 31013
31513 32323 32423 33533 34543 34843 35053 35153 35353 35753 36263 36563 37273
37573 38083 38183 38783 39293 70207 70507 70607 71317 71917 72227 72727 73037
73237 73637 74047 74747 75557 76367 76667 77377 77477 77977 78487 78787 78887
79397 79697 79997 90709 91019 93139 93239 93739 94049 94349 94649 94849 94949
95959 96269 96469 96769 97379 97579 97879 98389 98689 
Count: 113

Number of base 10 palindromic primes less than 1000000000: 5953

Base 16 palindromic primes less than 500:
  2   3   5   7   b   d  11 101 151 161 191 1b1 1c1 
Count: 13

Ruby 

require 'prime'

p Prime.each(1000).select{|pr| pr.digits == pr.digits.reverse}
Output:
[2, 3, 5, 7, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787, 797, 919, 929]

S-BASIC 

$constant FALSE = 0
$constant TRUE = 0FFFFH

rem - return true if n is palindromic, otherwise false
function ispalindromic(n = integer) = integer
   var i, j = integer
   var s = string
   s = str$(n)
   i = 2  rem - skip over leading sign or space
   j = len(s)
   while i < j and (mid(s,i,1)) = (mid(s,j,1)) do
      begin
         i = i + 1
         j = j - 1
      end
end = (mid(s,i,1)) = (mid(s,j,1)) 

rem - return n mod m
function mod(n, m = integer) = integer
end = n - m * (n / m)

rem - return true if n is prime, otherwise false
function isprime(n = integer) = integer
  var i, limit, result = integer
  if n = 2 then
    result = TRUE
  else if (n < 2) or (mod(n,2) = 0) then
    result = FALSE
  else 
    begin
      limit = int(sqr(n))
      i = 3
      while (i <= limit) and (mod(n, i) <> 0) do
        i = i + 2
      result = not (i <= limit)
    end
end = result

rem - main code begins here

var i, count = integer
print "Looking up to 1000 for palindromic primes"
count = 0
for i = 2 to 1000
  if isprime(i) then 
     if ispalindromic(i) then
        begin
           print using "##### ";i;
           count = count + 1
           if mod(count, 6) = 0 then print
        end
next i
print
print count; " were found"

end
Output:
Looking up to 1000 for palindromic primes
     2      3     5     7    11   101
   131    151   181   191   313   353
   373    383   727   757   787   797
   919    929
20 were found

SETL 

program palindromic_primes;
    print([n : n in [1..1000] | palindromic n and prime n]);

    op palindromic(n);
        return str n = reverse str n;
    end op;

    op prime(n);
        return n>=2 and not exists d in [2..floor sqrt n] | n mod d = 0;
    end op;
end program;
Output:
[2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929]

Sidef 

func palindromic_primes(upto, base = 10) {
    var list = []
    for (var p = 2; p <= upto; p = p.next_palindrome(base)) {
        list << p if p.is_prime
    }
    return list
}

say palindromic_primes(1000)

for n in (1..10) {
    var count = palindromic_primes(10**n).len
    say "There are #{count} palindromic primes <= 10^#{n}"
}
Output:
[2, 3, 5, 7, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787, 797, 919, 929]
There are 4 palindromic primes <= 10^1
There are 5 palindromic primes <= 10^2
There are 20 palindromic primes <= 10^3
There are 20 palindromic primes <= 10^4
There are 113 palindromic primes <= 10^5
There are 113 palindromic primes <= 10^6
There are 781 palindromic primes <= 10^7
There are 781 palindromic primes <= 10^8
There are 5953 palindromic primes <= 10^9
There are 5953 palindromic primes <= 10^10

Wren

Library: Wren-math
Library: Wren-fmt
import "./math" for Int
import "./fmt" for Fmt

var reversed = Fn.new { |n|
    var rev = 0
    while (n > 0) {
        rev = rev * 10 + n % 10
        n = (n/10).floor
    }
    return rev
}

var primes = Int.primeSieve(99999)
var pals = []
for (p in primes) {
    if (p == reversed.call(p)) pals.add(p)
}
System.print("Palindromic primes under 1,000:")
var smallPals = pals.where { |p| p < 1000 }.toList
Fmt.tprint("$3d", smallPals, 10)
System.print("\n%(smallPals.count) such primes found.")

System.print("\nAdditional palindromic primes under 100,000:")
var bigPals = pals.where { |p| p >= 1000 }.toList
Fmt.tprint("$,6d", bigPals, 10)
System.print("\n%(bigPals.count) such primes found, %(pals.count) in all.")
Output:
Palindromic primes under 1,000:
  2   3   5   7  11 101 131 151 181 191
313 353 373 383 727 757 787 797 919 929

20 such primes found.

Additional palindromic primes under 100,000:
10,301 10,501 10,601 11,311 11,411 12,421 12,721 12,821 13,331 13,831
13,931 14,341 14,741 15,451 15,551 16,061 16,361 16,561 16,661 17,471
17,971 18,181 18,481 19,391 19,891 19,991 30,103 30,203 30,403 30,703
30,803 31,013 31,513 32,323 32,423 33,533 34,543 34,843 35,053 35,153
35,353 35,753 36,263 36,563 37,273 37,573 38,083 38,183 38,783 39,293
70,207 70,507 70,607 71,317 71,917 72,227 72,727 73,037 73,237 73,637
74,047 74,747 75,557 76,367 76,667 77,377 77,477 77,977 78,487 78,787
78,887 79,397 79,697 79,997 90,709 91,019 93,139 93,239 93,739 94,049
94,349 94,649 94,849 94,949 95,959 96,269 96,469 96,769 97,379 97,579
97,879 98,389 98,689

93 such primes found, 113 in all.

XPL0 

func IsPrime(N);        \Return 'true' if N is a prime number
int  N, I;
[if N <= 1 then return false;
for I:= 2 to sqrt(N) do
    if rem(N/I) = 0 then return false;
return true;
];

func Reverse(N);
int  N, M;
[M:= 0;
repeat  N:= N/10;
        M:= M*10 + rem(0);
until   N=0;
return M;
];

int Count, N;
[Count:= 0;
for N:= 1 to 1000-1 do
    if N=Reverse(N) & IsPrime(N) then
        [IntOut(0, N);
        Count:= Count+1;
        if rem(Count/10) = 0 then CrLf(0) else ChOut(0, 9\tab\);
        ];
]
Output:
2       3       5       7       11      101     131     151     181     191
313     353     373     383     727     757     787     797     919     929
Retrieved from "https://rosettacode.org/wiki/Palindromic_primes?oldid=378604"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information