Concatenate two primes is also prime: Difference between revisions

{{trans|Nim}}

I a == 2

R 1B

print(‘Found ’concatPrimes.len‘ primes which are a concatenation of two primes below 100:’)

L(n) sorted(Array(concatPrimes))

{{out}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Sieve of Eratosthenes}}

INCLUDE "H6:SIEVE.ACT"

OD

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

{{out}}

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

=={{header|Ada}}==

with Ada.Integer_Text_Io;

with Ada.Strings.Fixed;

Put (" concat primes.");

New_Line;

{{out}}

<pre>

=={{header|ALGOL 68}}==

{{libheader|ALGOL 68-primes}}

INT max low prime = 99; # for the task, only need component primes up to 99 #

INT max prime = max low prime * max low prime;

OD;

print( ( newline, newline, "Found ", whole( c count, 0 ), " concat primes", newline ) )

{{out}}

<pre>

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

The Algol W for loop allows the loop counter values to be specified as a list - as there are only 25 primes below 100, this feature is used here to save looking through the sieve for the low primes.

integer MAX_PRIME;

MAX_PRIME := 99 * 99;

write();write( i_w := 1, s_w := 0, "Found ", cCount, " concat primes" )

end

{{out}}

<pre>

</pre>

=={{header|AWK}}==

# syntax: GAWK -f CONCATENATE_TWO_PRIMES_IS_ALSO_PRIME.AWK

#

return(1)

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

for p1 = 2 to 99

if not isPrime(p1) then continue for

end while

return True

==={{header|FreeBASIC}}===

This solution focuses more on the primes p1, p2 than on the concatenated prime. Thus, there can be multiple solutions. For example, 373 can be formed from 37 and 3 or from 3 and 73 and will be listed twice.

dim as integer p1, p2, cat, c = 0

next p2

next p1

{{out}}<pre>

2| 3 2|11 2|23 2|29 2|41 2|71 2|83 3| 7 3|11 3|13

==={{header|Yabasic}}===

for p1 = 2 to 99

if not isPrime(p1) then continue : fi

wend

return True

=={{header|Factor}}==

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

present prettyprint sequences sets sorting ;

99 primes-upto [ present ] map dup [ append dec> ] cartesian-map

concat [ prime? ] filter members natural-sort [ length ] keep

{{out}}

<pre>

=={{header|Go}}==

{{libheader|Go-rcu}}

import (

}

fmt.Println("\n\nFound", len(results), "such concatenated primes.")

{{out}}

=={{header|Haskell}}==

import Data.List ( sort )

import Data.List.Split ( chunksOf )

main :: IO ( )

main = do

{{out}}

<pre>

'''Preliminaries'''

. as $n

| if ($n < 2) then false

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

'''The task'''

def concatenative_primes:

primes

[100 | concatenative_primes | join("||")]

{{out}}

<pre>

</pre>

=={{header|Julia}}==

function catprimes()

foreach(p -> print(lpad(last(p), 5), first(p) % 16 == 0 ? "\n" : ""),

catprimes() |> enumerate)

<pre>

23 37 53 73 113 137 173 193 197 211 223 229 233 241 271 283

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

{{out}}

<pre>{23, 37, 53, 73, 113, 137, 173, 193, 197, 211, 223, 229, 233, 241, 271, 283, 293, 311, 313, 317, 331, 337, 347, 353, 359, 367, 373, 379, 383, 389, 397, 433, 523, 541, 547, 571, 593, 613, 617, 673, 677, 719, 733, 743, 761, 773, 797, 977, 1117, 1123, 1129, 1153, 1171, 1319, 1361, 1367, 1373, 1723, 1741, 1747, 1753, 1759, 1783, 1789, 1913, 1931, 1973, 1979, 1997, 2311, 2341, 2347, 2371, 2383, 2389, 2917, 2953, 2971, 3119, 3137, 3167, 3719, 3761, 3767, 3779, 3797, 4111, 4129, 4153, 4159, 4337, 4373, 4397, 4723, 4729, 4759, 4783, 4789, 5323, 5347, 5923, 5953, 6113, 6131, 6143, 6173, 6197, 6719, 6737, 6761, 6779, 7129, 7159, 7331, 7919, 7937, 8311, 8317, 8329, 8353, 8389, 8923, 8929, 8941, 8971, 9719, 9743, 9767}</pre>

=={{header|Nim}}==

func isPrime(n: Positive): bool =

for n in concatPrimes:

stdout.write ($n).align(4), if i mod 16 == 0: '\n' else: ' '

{{out}}

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Concatenate_two_primes_is_also_prime

my @valid = uniq sort { $a <=> $b } grep is_prime($_),

map { my $prefix = $_; map "$prefix$_", @primes } @primes;

{{out}}

<pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">),</span>

<span style="color: #000000;">result</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">deep_copy</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- (see note)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Found %d such primes: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)})</span>

<small>Note: The deep_copy() [for pwa/p2js] on such calls to unique() would be unnecessary were result routine-local, due to automatic pbr, but here that variable is file-level.<br>

While the (human-readable) error message (without it) is deep within sort(), the call stack makes it clear where that call should best go.</small>

=={{header|Raku}}==

Inefficient, but for a limit of 100, who cares?

say display ( @p X~ @p ).grep( *.is-prime ).unique.sort( +* );

cache $list;

$title ~ $list.batch($cols)».fmt($fmt).join: "\n"

{{out}}

<pre>128 matching:

=={{header|REXX}}==

parse arg hip cols . /*obtain optional arguments from the CL*/

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

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

if j<hip then ##= # /*find a shortcut for the 1st DO loop. */

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

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see "working..." + nl

see nl + "Found " + row + " prime numbers" + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Ruby}}==

concats = Prime.each(100).to_a.repeated_permutation(2).filter_map do |pair|

concats = concats.sort.uniq

{{out}}

<pre>23 37 53 73 113 137 173 193 197 211

</pre>

=={{header|Sidef}}==

var arr = upto.primes

var base = 10

})

{{out}}

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-seq}}

import "/fmt" for Fmt

import "/seq" for Lst

System.print("Two primes under 100 concatenated together to form another prime:")

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

{{out}}

=={{header|XPL0}}==

int N, I;

[if N <= 1 then return false;

Text(0, " such concatenated primes found.

");

{{out}}