Palindromic primes: Difference between revisions

Line 7:

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

<~~lang~~ 11l>F is_prime(a)

<syntaxhighlight lang="11l">F is_prime(a)

I a == 2

R 1B

Line 22:

I s == reversed(s)

print(n, end' ‘ ’)

print()</~~lang~~>

print()</syntaxhighlight>

Line 31:

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

<~~lang~~ ~~Action~~!>INCLUDE "H6:SIEVE.ACT"

<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"

BYTE Func IsPalindromicPrime(INT i BYTE ARRAY primes)

Line 68:

OD

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

RETURN</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Palindromic_primes.png Screenshot from Atari 8-bit computer]

Line 80:

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.

<~~lang~~ algol68>BEGIN # find primes that are palendromic in base 10 #

<syntaxhighlight lang="algol68">BEGIN # find primes that are palendromic in base 10 #

INT max prime = 999;

# sieve the primes to max prime #

Line 105:

OD;

print( ( newline ) )

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 113:

=={{header|Arturo}}==

<~~lang~~ rebol>loop split.every: 10 select 2..1000 'x [

<syntaxhighlight lang="rebol">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]</~~lang~~>

] 'a -> print map a => [pad to :string & 4]</syntaxhighlight>

Line 124:

=={{header|AWK}}==

# syntax: GAWK -f PALINDROMIC_PRIMES.AWK

BEGIN {

Line 155:

return(rts)

}

</syntaxhighlight>

</lang>

<pre>

Line 164:

=={{header|C++}}==

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

<~~lang~~ cpp>#include <algorithm>

<syntaxhighlight lang="cpp">#include <algorithm>

#include <cmath>

#include <iomanip>

Line 272:

std::cout << '\n';

print_palindromic_primes(16, 500);

}</~~lang~~>

}</syntaxhighlight>

Line 303:

A simple solution that suffices for the task:

<~~lang~~ factor>USING: kernel math.primes present prettyprint sequences ;

<syntaxhighlight lang="factor">USING: kernel math.primes present prettyprint sequences ;

1000 primes-upto [ present dup reverse = ] filter stack.</~~lang~~>

1000 primes-upto [ present dup reverse = ] filter stack.</syntaxhighlight>

Line 332:

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

<~~lang~~ factor>USING: io kernel lists lists.lazy math math.functions

<syntaxhighlight lang="factor">USING: io kernel lists lists.lazy math math.functions

math.primes math.ranges prettyprint sequences

tools.memory.private ;

Line 357:

"Palindromic primes less than 1,000:" print

lpalindrome-primes [ 1000 < ] lwhile [ . ] leach</~~lang~~>

lpalindrome-primes [ 1000 < ] lwhile [ . ] leach</syntaxhighlight>

Line 387:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>#include "isprime.bas"

<syntaxhighlight lang="freebasic">#include "isprime.bas"

function is_pal( s as string ) as boolean

Line 399:

for i as uinteger = 2 to 999

if is_pal( str(i) ) andalso isprime(i) then print i;" ";

next i : print</~~lang~~>

next i : print</syntaxhighlight>

{{out}}<pre>

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

Line 406:

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 447:

fmt.Println()

fmt.Println(len(bigPals), "such primes found,", len(pals), "in all.")

}</~~lang~~>

}</syntaxhighlight>

Line 455:

=={{header|Haskell}}==

<~~lang~~ haskell>import Data.Numbers.Primes

<syntaxhighlight lang="haskell">import Data.Numbers.Primes

palindromicPrimes :: [Integer]

Line 466:

takeWhile

(1000 >)

palindromicPrimes</~~lang~~>

palindromicPrimes</syntaxhighlight>

<pre>2

Line 500:

'''Preliminaries'''

<~~lang~~ jq>def count(s): reduce s as $x (null; .+1);

<syntaxhighlight lang="jq">def count(s): reduce s as $x (null; .+1);

def emit_until(cond; stream): label $out | stream | if cond then break $out else . end;</~~lang~~>

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

'''Naive version'''

def primes:

2, (range(3;infinite;2) | select(is_prime));

Line 510:

def palindromic_primes_slowly:

primes | select( tostring|explode | (. == reverse));

</syntaxhighlight>

</lang>

'''Less naive version'''

<~~lang~~ jq># Output: an unbounded stream of palindromic primes

<syntaxhighlight lang="jq"># Output: an unbounded stream of palindromic primes

def palindromic_primes:

Line 543:

2, 3, 5, 7, 11,

(palindromic_candidates | tonumber | select(is_prime));</~~lang~~>

(palindromic_candidates | tonumber | select(is_prime));</syntaxhighlight>

'''Demonstrations'''

<~~lang~~ jq>"Palindromic primes < 1000:",

<syntaxhighlight lang="jq">"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)))" )</~~lang~~>

| "\nNumber of palindromic primes <= \($n): \(count(emit_until(. >= $n; palindromic_primes)))" )</syntaxhighlight>

<pre>

Line 589:

=={{header|Julia}}==

Generator method.

<~~lang~~ julia>using Primes

<syntaxhighlight lang="julia">using Primes

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

Line 596:

println(results)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>Select[Range[999], PrimeQ[#] \[And] PalindromeQ[#] &]</~~lang~~>

<syntaxhighlight lang="mathematica">Select[Range[999], PrimeQ[#] \[And] PalindromeQ[#] &]</syntaxhighlight>

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import strutils

<syntaxhighlight lang="nim">import strutils

const N = 999

Line 633:

for i, n in result:

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

stdout.write if (i + 1) mod 10 == 0: '\n' else: ' '</~~lang~~>

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

Line 641:

=={{header|PARI/GP}}==

'''naive'''

<~~lang~~ parigp>forprime(i = 2, 1000,

<syntaxhighlight lang="parigp">forprime(i = 2, 1000,

if( i == fromdigits( Vecrev( digits( i ) )) ,

print1( i, " " ) ) );</~~lang~~>

print1( i, " " ) ) );</syntaxhighlight>

<pre>

Line 650:

=={{header|Perl}}==

<~~lang~~ ~~Perl~~>#!/usr/bin/perl

<syntaxhighlight lang="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;</~~lang~~>

$_ == reverse and (1 x $_ ) !~ /^(11+)\1+$/ and print "$_ " for 2 .. 1e3;</syntaxhighlight>

Line 661:

=={{header|Phix}}==

===filter primes for palindromicness===

function palindrome(string s) return s=reverse(s) end function

for l=3 to 5 by 2 do

Line 671:

printf(1,"found %d < %,d: %s\n",{length(res),limit,s})

end for

<pre>

Line 678:

</pre>

===filter palindromes for primality===

sequence r = {}

for l=2 to 3 do

Line 692:

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.

=={{header|Python}}==

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

<~~lang~~ python>'''Palindromic primes'''

<syntaxhighlight lang="python">'''Palindromic primes'''

from itertools import takewhile

Line 744:

if __name__ == '__main__':

main()

</syntaxhighlight>

</lang>

<pre>2

Line 771:

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

<~~lang~~ ~~Quackery~~> [ [] swap

<syntaxhighlight lang="quackery"> [ [] swap

[ base share /mod

rot swap join swap

Line 784:

[ i^ isprime if

[ i^ digits palindromic if

[ i^ echo sp ] ] ]</~~lang~~>

[ i^ echo sp ] ] ]</syntaxhighlight>

Line 792:

=={{header|Raku}}==

<lang ~~perl6~~>say "{+$_} matching numbers:\n{.batch(10)».fmt('%3d').join: "\n"}"

<syntaxhighlight lang="raku" line>say "{+$_} matching numbers:\n{.batch(10)».fmt('%3d').join: "\n"}"

given (^1000).grep: { .is-prime and $_ eq .flip };</~~lang~~>

given (^1000).grep: { .is-prime and $_ eq .flip };</syntaxhighlight>

<pre>20 matching numbers:

Line 800:

=={{header|REXX}}==

<~~lang~~ rexx>/*REXX program finds and displays palindromic primes in base ten for all N < 1,000.*/

<syntaxhighlight lang="rexx">/*REXX program finds and displays palindromic primes in base ten for all N < 1,000.*/

parse arg hi cols . /*obtain optional argument from the CL.*/

if hi=='' | hi=="," then hi= 1000 /*Not specified? Then use the default.*/

Line 841:

end /*k*/ /* [↑] only process numbers ≤ √ J */

#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */

end /*j*/; return</~~lang~~>

end /*j*/; return</syntaxhighlight>

<pre>

Line 875:

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

Line 906:

ok

</syntaxhighlight>

</lang>

<pre>

Line 947:

=={{header|Rust}}==

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

<~~lang~~ rust>// [dependencies]

<syntaxhighlight lang="rust">// [dependencies]

// primal = "0.3"

// radix_fmt = "1.0"

Line 1,028:

println!();

print_palindromic_primes(16, 500);

}</~~lang~~>

}</syntaxhighlight>

Line 1,056:

=={{header|Sidef}}==

<~~lang~~ ruby>func palindromic_primes(upto, base = 10) {

<syntaxhighlight lang="ruby">func palindromic_primes(upto, base = 10) {

var list = []

for (var p = 2; p <= upto; p = p.next_palindrome(base)) {

Line 1,069:

var count = palindromic_primes(10**n).len

say "There are #{count} palindromic primes <= 10^#{n}"

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 1,089:

<~~lang~~ ecmascript>import "/math" for Int

<syntaxhighlight lang="ecmascript">import "/math" for Int

import "/fmt" for Fmt

import "/seq" for Lst

Line 1,115:

var bigPals = pals.where { |p| p >= 1000 }.toList

for (chunk in Lst.chunks(bigPals, 10)) Fmt.print("$,6d", chunk)

System.print("\n%(bigPals.count) such primes found, %(pals.count) in all.")</~~lang~~>

System.print("\n%(bigPals.count) such primes found, %(pals.count) in all.")</syntaxhighlight>

Line 1,141:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func IsPrime(N); \Return 'true' if N is a prime number

<syntaxhighlight lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number

int N, I;

[if N <= 1 then return false;

Line 1,166:

if rem(Count/10) = 0 then CrLf(0) else ChOut(0, 9\tab\);

];

]</~~lang~~>

]</syntaxhighlight>