Rosetta Code

Concatenate two primes is also prime: Difference between revisions

Page Discussion

Concatenate two primes is also prime (view source)

Revision as of 16:28, 20 November 2023

22,295 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Minor tidy
(Ada version)
m (→‎{{header|Wren}}: Minor tidy)
 
(16 intermediate revisions by 12 users not shown)
Line 4:
Find and show here when the concatenation of two primes &nbsp; ('''p<sub>1</sub>''', &nbsp;'''p<sub>2</sub>''') &nbsp; shown in base ten is also prime, &nbsp; where &nbsp; '''p<sub>1</sub>, &nbsp; p<sub>2</sub> &nbsp;&lt;&nbsp; 100'''.
<br><br>
 
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="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
 
V primes = (2..99).filter(n -> is_prime(n))
 
Set[Int] concatPrimes
L(p1) primes
L(p2) primes
V n = p2 + p1 * (I p2 < 10 {10} E 100)
I is_prime(n)
concatPrimes.add(n)
 
print(‘Found ’concatPrimes.len‘ primes which are a concatenation of two primes below 100:’)
L(n) sorted(Array(concatPrimes))
print(‘#4’.format(n), end' I (L.index + 1) % 16 == 0 {"\n"} E ‘ ’)</syntaxhighlight>
 
{{out}}
<pre>
Found 128 primes which are a concatenation of two primes below 100:
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|Action!}}==
{{libheader|Action! Tool Kit}}
{{libheader|Action! Sieve of Eratosthenes}}
<langsyntaxhighlight Actionlang="action!">INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit
INCLUDE "H6:SIEVE.ACT"
 
Line 49 ⟶ 88:
OD
PrintF("%E%EThere are %I primes",count)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Concatenate_two_primes_is_also_prime.png Screenshot from Atari 8-bit computer]
Line 66 ⟶ 105:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
with Ada.Integer_Text_Io;
with Ada.Strings.Fixed;
Line 125 ⟶ 164:
Put (" concat primes.");
New_Line;
end Concat_Is_Prime;</langsyntaxhighlight>
{{out}}
<pre>
Line 146 ⟶ 185:
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<langsyntaxhighlight lang="algol68">BEGIN # find primes whose decimal representation is the concatenation of 2 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;
Line 175 ⟶ 214:
OD;
print( ( newline, newline, "Found ", whole( c count, 0 ), " concat primes", newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 197 ⟶ 236:
=={{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.
<langsyntaxhighlight lang="algolw">begin % find primes whose decimal representation is the concatenation of 2 primes %
integer MAX_PRIME;
MAX_PRIME := 99 * 99;
Line 235 ⟶ 274:
write();write( i_w := 1, s_w := 0, "Found ", cCount, " concat primes" )
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 254 ⟶ 293:
Found 128 concat primes
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">primesBelow100: select 1..100 => prime?
allPossibleConcats: permutate.repeat.by:2 primesBelow100
 
concatPrimes: allPossibleConcats | map 'x -> to :integer (to :string x\[0]) ++ (to :string x\[1])
| select => prime?
| sort
| unique
 
print ["Found" size concatPrimes "concatenations of primes below 100:"]
loop split.every: 16 concatPrimes 'x ->
print map x 's -> pad to :string s 4
</syntaxhighlight>
 
{{out}}
 
<pre>Found 128 concatenations of primes below 100:
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|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f CONCATENATE_TWO_PRIMES_IS_ALSO_PRIME.AWK
#
Line 294 ⟶ 359:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 313 ⟶ 378:
</pre>
 
=={{header|FactorBASIC}}==
==={{header|BASIC256}}===
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="basic256">c = 0
<lang factor>USING: formatting grouping io kernel math.parser math.primes
for p1 = 2 to 99
present prettyprint sequences sets sorting ;
if not isPrime(p1) then continue for
for p2 = 2 to 99
if not isPrime(p2) then continue for
cat = rjust(string(p1),2) + rjust(string(p2),2)
if isPrime(cat) then
c += 1
print p1; "|"; p2; " ";
if c mod 10 = 0 then print
end if
next p2
next p1
end
 
function isPrime(v)
"Concatenated-pair primes from primes < 100:" print nl
if v < 2 then return False
99 primes-upto [ present ] map dup [ append dec> ] cartesian-map
if v mod 2 = 0 then return v = 2
concat [ prime? ] filter members natural-sort [ length ] keep
if v mod 3 = 0 then return v = 3
8 group simple-table. "\nFound %d concatenated primes.\n" printf</lang>
d = 5
{{out}}
while d * d <= v
<pre>
if v mod d = 0 then return False else d += 2
Concatenated-pair primes from primes < 100:
end while
return True
end function</syntaxhighlight>
 
==={{header|FreeBASIC}}===
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
 
Found 128 concatenated primes.
</pre>
 
=={{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.
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
dim as integer p1, p2, cat, c = 0
 
Line 363 ⟶ 423:
next p2
next p1
</syntaxhighlight>
</lang>
{{out}}<pre>
2| 3 2|11 2|23 2|29 2|41 2|71 2|83 3| 7 3|11 3|13
Line 379 ⟶ 439:
83|17 83|29 83|53 83|89 89|23 89|29 89|41 89|71 97| 7 97|19
97|43 97|67
</pre>
 
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">c = 0
for p1 = 2 to 99
if not isPrime(p1) then continue : fi
for p2 = 2 to 99
if not isPrime(p2) then continue : fi
cat = val(str$(p1) + str$(p2))
if isPrime(cat) then
c = c + 1
a$ = str$(p1,"##")
b$ = str$(p2,"##")
print a$, "|", b$, " ";
if mod(c, 10) = 0 then print : fi
end if
next p2
next p1
print
end
 
sub isPrime(v)
if v < 2 then return False : fi
if mod(v, 2) = 0 then return v = 2 : fi
if mod(v, 3) = 0 then return v = 3 : fi
d = 5
while d * d <= v
if mod(v, d) = 0 then return False else d = d + 2 : fi
wend
return True
end sub</syntaxhighlight>
 
 
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <locale.h>
 
bool isPrime(int n) {
if (n < 2) return false;
if (n%2 == 0) return n == 2;
if (n%3 == 0) return n == 3;
int d = 5;
while (d*d <= n) {
if (n%d == 0) return false;
d += 2;
if (n%d == 0) return false;
d += 4;
}
return true;
}
 
int compare(const void* a, const void* b) {
int arg1 = *(const int*)a;
int arg2 = *(const int*)b;
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
}
 
int main() {
int primes[30] = {2}, results[200];
int i, j, p, q, pq, limit = 100, pc = 1, rc = 0;
for (i = 3; i < limit; i += 2) {
if (isPrime(i)) primes[pc++] = i;
}
for (i = 0; i < pc; ++i) {
p = primes[i];
for (j = 0; j < pc; ++j) {
q = primes[j];
pq = (q < 10) ? p * 10 + q : p * 100 + q;
if (isPrime(pq)) results[rc++] = pq;
}
}
qsort(results, rc, sizeof(int), compare);
setlocale(LC_NUMERIC, "");
printf("Two primes under 100 concatenated together to form another prime:\n");
for (i = 0, j = 0; i < rc; ++i) {
if (i > 0 && results[i] == results[i-1]) continue;
printf("%'6d ", results[i]);
if (++j % 10 == 0) printf("\n");
}
printf("\n\nFound %d such concatenated primes.\n", j);
return 0;
}</syntaxhighlight>
 
{{out}}
<pre>
Two primes under 100 concatenated together to form another prime:
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 1,117 1,123
1,129 1,153 1,171 1,319 1,361 1,367 1,373 1,723 1,741 1,747
1,753 1,759 1,783 1,789 1,913 1,931 1,973 1,979 1,997 2,311
2,341 2,347 2,371 2,383 2,389 2,917 2,953 2,971 3,119 3,137
3,167 3,719 3,761 3,767 3,779 3,797 4,111 4,129 4,153 4,159
4,337 4,373 4,397 4,723 4,729 4,759 4,783 4,789 5,323 5,347
5,923 5,953 6,113 6,131 6,143 6,173 6,197 6,719 6,737 6,761
6,779 7,129 7,159 7,331 7,919 7,937 8,311 8,317 8,329 8,353
8,389 8,923 8,929 8,941 8,971 9,719 9,743 9,767
 
Found 128 such concatenated primes.
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
function Compare(P1,P2: pointer): integer;
{Compare for quick sort}
begin
Result:=Integer(P1)-Integer(P2);
end;
 
procedure ConcatonatePrimes(Memo: TMemo);
{Show concatonated pairs of primes that are also prime}
var List: TList;
var I,P1,P2,ConCat: integer;
var Sieve: TPrimeSieve;
const Max =100;
var S: string;
 
function ConcatNums(I1,I2: integer): integer;
begin
Result:=StrToInt(IntToStr(I1)+IntToStr(I2));
end;
 
begin
{Create sieve to for fast prime generation}
Sieve:=TPrimeSieve.Create;
try
List:=TList.Create;
try
{Sieve first 1,000 primes}
Sieve.Intialize(1000);
 
{Generate all combinations of primes}
{ P1 and P2, from 2 to 100}
P1:=2;
while P1<Max do
begin
P2:=2;
while P2<Max do
begin
{Concatonates the two primes}
ConCat:=ConcatNums(P1,P2);
{Test if it is prime and only store unique primes}
if IsPrime(ConCat) then
if List.IndexOf(Pointer(ConCat))<0 then
List.Add(Pointer(ConCat));
P2:=Sieve.NextPrime(P2);
end;
P1:=Sieve.NextPrime(P1);
end;
{Sort list in numerical order}
List.Sort(Compare);
{Display the result}
Memo.Lines.Add('Concatonated Primes Found: '+IntToStr(List.Count));
for I:=0 to List.Count-1 do
begin
S:=S+Format('%5d',[integer(List[I])]);
if (I mod 10)=9 then S:=S+CRLF;
end;
Memo.Lines.Add(S);
finally List.Free; end;
finally Sieve.Free; end;
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Concatonated Primes Found: 128
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
Elapsed Time: 3.990 ms.
 
</pre>
 
 
=={{header|EasyLang}}==
<syntaxhighlight>
proc sort . d[] .
for i = 1 to len d[] - 1
for j = i + 1 to len d[]
if d[j] < d[i]
swap d[j] d[i]
.
.
.
.
func isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
for i = 2 to 99
if isprim i = 1
prims[] &= i
.
.
for p1 in prims[]
for p2 in prims[]
h$ = p1 & p2
h = number h$
if isprim h = 1
r[] &= h
.
.
.
sort r[]
print r[]
</syntaxhighlight>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: formatting grouping io kernel math.parser math.primes
present prettyprint sequences sets sorting ;
 
"Concatenated-pair primes from primes < 100:" print nl
99 primes-upto [ present ] map dup [ append dec> ] cartesian-map
concat [ prime? ] filter members natural-sort [ length ] keep
8 group simple-table. "\nFound %d concatenated primes.\n" printf</syntaxhighlight>
{{out}}
<pre>
Concatenated-pair primes from primes < 100:
 
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
 
Found 128 concatenated primes.
</pre>
 
=={{header|Go}}==
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 423 ⟶ 750:
}
fmt.Println("\n\nFound", len(results), "such concatenated primes.")
}</langsyntaxhighlight>
 
{{out}}
Line 444 ⟶ 771:
Found 128 such concatenated primes.
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Control.Applicative
import Data.List ( sort )
import Data.List.Split ( chunksOf )
 
isPrime :: Int -> Bool
isPrime n
|n == 2 = True
|n == 1 = False
|otherwise = null $ filter (\i -> mod n i == 0 ) [2 .. root]
where
root :: Int
root = floor $ sqrt $ fromIntegral n
 
solution :: [Int]
solution = sort $ filter isPrime $ map read ( (++) <$> numberlist <*> numberlist )
where
numberlist :: [String]
numberlist = map show $ filter isPrime [1 .. 99]
 
main :: IO ( )
main = do
mapM_ print $ chunksOf 15 solution</syntaxhighlight>
{{out}}
<pre>
[23,37,53,73,113,137,173,193,197,211,223,229,233,241,271]
[283,293,311,313,313,317,317,331,337,347,353,359,367,373,373]
[379,383,389,397,433,523,541,547,571,593,613,617,673,677,719]
[733,743,761,773,797,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|J}}==
<syntaxhighlight lang="j"> concat=. (] + (* 10 ^ #@":))"1 0
 
_12 ]\ /:~ (#~ 1&p:) , concat~ i.&.(p:inv) 100
23 37 53 73 113 137 173 193 197 211 223 229
233 241 271 283 293 311 313 313 317 317 331 337
347 353 359 367 373 373 379 383 389 397 433 523
541 547 571 593 613 617 673 677 719 733 743 761
773 797 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</syntaxhighlight>
 
=={{header|jq}}==
Line 450 ⟶ 829:
 
'''Preliminaries'''
<langsyntaxhighlight lang="jq">def is_prime:
. as $n
| if ($n < 2) then false
Line 479 ⟶ 858:
 
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
</syntaxhighlight>
</lang>
'''The task'''
<langsyntaxhighlight lang="jq"># Emit [p1,p2] where p1 < p2 < . and the concatenation is prime
def concatenative_primes:
primes
Line 490 ⟶ 869:
 
[100 | concatenative_primes | join("||")]
| (nwise(10) | map(lpad(6)) | join(" "))</langsyntaxhighlight>
{{out}}
<pre>
Line 508 ⟶ 887:
</pre>
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function catprimes()
Line 521 ⟶ 900:
foreach(p -> print(lpad(last(p), 5), first(p) % 16 == 0 ? "\n" : ""),
catprimes() |> enumerate)
</langsyntaxhighlight>{{out}}
<pre>
23 37 53 73 113 137 173 193 197 211 223 229 233 241 271 283
Line 534 ⟶ 913:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Select[Catenate /* FromDigits /@ Map[IntegerDigits, Tuples[Prime[Range[PrimePi[100]]], 2], {2}], PrimeQ] // Union</langsyntaxhighlight>
{{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|Lua}}==
Based on the Algol W sample.
<syntaxhighlight lang="lua">
do -- find primes whose decimal representation is the concatenation of 2 primes < 100
local MAX_PRIME = 99 * 99
-- returns true if n is prime, false otherwise, uses trial division
local function isPrime ( n )
if n < 3 then return n == 2
elseif n % 3 == 0 then return n == 3
elseif n % 2 == 0 then return false
else
local prime = true
local f, f2, toNext = 5, 25, 24
while f2 <= n and prime do
prime = n % f ~= 0
f = f + 2
f2 = toNext
toNext = toNext + 8
end
return prime
end
end
local concatPrime = {}
-- tables of small primes, sp2 will be the final digits so does not include 2 or 5
local sp1 = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37
, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
}
local sp2 = { 3, 7, 11, 13, 17, 19, 23, 29, 31, 37
, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
}
-- find the concatenated primes
for i = 1, MAX_PRIME do concatPrime[ i ] = false end
for _, p1 in pairs( sp1 ) do
for _, p2 in pairs( sp2 ) do
local pc = ( p1 * ( p2 < 10 and 10 or 100 ) ) + p2
concatPrime[ pc ] = isPrime( pc )
end
end
-- print the concatenated primes
local cCount = 0
for i = 1, MAX_PRIME do
if concatPrime[ i ] then
io.write( string.format( "%5d", i ) )
cCount = cCount + 1
if cCount % 10 == 0 then io.write( "\n" ) end
end
end
io.write( "\n\nFound ", cCount, " concat primes" )
end
</syntaxhighlight>
{{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
 
Found 128 concat primes
</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils, sugar
 
func isPrime(n: Positive): bool =
Line 566 ⟶ 1,014:
for n in concatPrimes:
stdout.write ($n).align(4), if i mod 16 == 0: '\n' else: ' '
inc i</langsyntaxhighlight>
 
{{out}}
Line 580 ⟶ 1,028:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Concatenate_two_primes_is_also_prime
Line 590 ⟶ 1,038:
my @valid = uniq sort { $a <=> $b } grep is_prime($_),
map { my $prefix = $_; map "$prefix$_", @primes } @primes;
print @valid . " primes found\n\n@valid\n" =~ s/.{79}\K /\n/gr;</langsyntaxhighlight>
{{out}}
<pre>
Line 606 ⟶ 1,054:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
Line 620 ⟶ 1,068:
<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>
<!--</langsyntaxhighlight>-->
<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>
Line 626 ⟶ 1,074:
<pre>
Found 128 such primes: {23,37,53,73,113,"...",8941,8971,9719,9743,9767}
</pre>
 
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
<syntaxhighlight lang="plm">
100H: /* FIND SOME PAIRS OF PRIMES BETWEEN 1 AND 99 SUCH THAT IF THEIR */
/* DIGITS ARE CONCATENATED, THE RESULT IS ALSO A PRIME */
 
/* CP/M BDOS SYSTEM CALL AND I/O ROUTINES */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
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$STRING( .( 0DH, 0AH, '$' ) ); END;
PR$NUMBER: PROCEDURE( N );
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;
 
/* TASK */
 
DECLARE FALSE LITERALLY '0';
DECLARE TRUE LITERALLY '0FFH';
DECLARE CONCAT$PRIME LITERALLY '0FH';
DECLARE MAX$LOW$PRIME LITERALLY '99';
DECLARE PRIME ( 10$000 )BYTE; /* PRIME SIEVE. A BIT LARGER THN NEEDED */
/* THE FIRST NYBBLE WILL BE SET TO 0 IF */
/* IT IS A CONCATENATED PRIME */
/* THE SIZE OF PRIME SHOULD BE AT LEAST MAX$LOW$PRIME SQUARED */
/* SIEVE THE PRIMES TO MAX$PRIME */
DECLARE ( I, J, COUNT ) ADDRESS;
PRIME( 1 ) = FALSE; PRIME( 2 ) = TRUE;
DO I = 3 TO LAST( PRIME ) BY 2; PRIME( I ) = TRUE; END;
DO I = 4 TO LAST( PRIME ) BY 2; PRIME( I ) = FALSE; END;
DO I = 3 TO MAX$LOW$PRIME + 1;
IF PRIME( I ) THEN DO;
DO J = I * I TO LAST( PRIME ) BY I + I; PRIME( J ) = FALSE; END;
END;
END;
/* FIND THE CONCATEDNATED PRIMES */
COUNT = 0;
DO I = 2 TO MAX$LOW$PRIME;
IF PRIME( I ) THEN DO;
DO J = 2 TO MAX$LOW$PRIME;
IF PRIME( J ) THEN DO;
DECLARE CP ADDRESS;
IF J < 10 THEN CP = I * 10;
ELSE CP = I * 100;
CP = CP + J;
IF PRIME( I ) AND PRIME( J ) AND PRIME( CP ) THEN DO;
/* CP IS A CONCATENATED PRIME - FLAG PRIME( CP ) AS SUCH */
PRIME( CP ) = CONCAT$PRIME;
END;
END;
END;
END;
END;
/* SHOW THE CONCATENATED PRIMES */
/* SINGLE DIGIT NUMBERS CAN'T BE CONCATENATED PRIMES, START AT 10 */
DO I = 3 TO LAST( PRIME ) BY 2;
IF PRIME( I ) = CONCAT$PRIME THEN DO;
/* HAVE A CONCATENATED PRIME */
CALL PR$CHAR( ' ' );
IF I < 1000 THEN DO;
CALL PR$CHAR( ' ' );
IF I < 100 THEN CALL PR$CHAR( ' ' );
END;
CALL PR$NUMBER( I );
IF ( COUNT := COUNT + 1 ) MOD 10 = 0 THEN CALL PR$NL;
END;
END;
 
EOF
</syntaxhighlight>
{{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|Python}}==
<syntaxhighlight lang="python">from itertools import takewhile
 
def is_prime(x):
return x > 1 and all(x % d for d in takewhile(lambda n: n * n <= x, primes))
 
def init_primes(n):
global primes
primes = [2]
for x in range(3, n + 1, 2):
if is_prime(x): primes.append(x)
 
def concat(x, y):
return 10 ** len(str(y)) * x + y
 
init_primes(99)
print(*sorted(n for x in primes for y in primes if is_prime(n := concat(x, y))))</syntaxhighlight>
{{out}}
<pre>23 37 53 73 113 137 173 193 197 211 223 229 233 241 271 283 293 311 313 313 317 317 331 337 347 353 359 367 373 373 379 383 389 397 433 523 541 547 571 593 613 617 673 677 719 733 743 761 773 797 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|Quackery}}==
 
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<syntaxhighlight lang="Quackery"> [ [] swap
[ base share /mod
rot join swap
dup 0 = until ]
drop ] is digits ( n --> [ )
 
[ 0 swap witheach
[ swap 10 * + ] ] is digits->n ( [ --> n )
 
[ behead dup dip nested rot
witheach
[ tuck != if
[ dup dip
[ nested join ] ] ]
drop ] is -duplicates ( [ --> [ )
 
[] dup temp put
100 times
[ i^ isprime if
[ i^ digits
nested join ] ]
dup witheach
[ over witheach
[ over join
digits->n
dup isprime iff
[ temp take
join
temp put ]
else drop ]
drop ]
drop
temp take
sort -duplicates
[ dup [] != while
10 split swap
witheach
[ dup 1000 < if sp
dup 100 < if sp
echo sp ]
cr
again ]
drop</syntaxhighlight>
 
{{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|Raku}}==
Inefficient, but for a limit of 100, who cares?
<syntaxhighlight lang="raku" perl6line>my @p = ^1e2 .grep: *.is-prime;
 
say display ( @p X~ @p ).grep( *.is-prime ).unique.sort( +* );
Line 637 ⟶ 1,266:
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</langsyntaxhighlight>
{{out}}
<pre>128 matching:
Line 655 ⟶ 1,284:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm finds base ten neighbor primes P1 & P2, when concatenated, is also a prime.*/
parse arg hip cols . /*obtain optional arguments from the CL*/
if hip=='' | hip=="," then hip= 100 /*Not specified? Then use the default.*/
Line 702 ⟶ 1,331:
#= #+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. */
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 726 ⟶ 1,355:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 769 ⟶ 1,398:
see nl + "Found " + row + " prime numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 789 ⟶ 1,418:
Found 128 prime numbers
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
≪ { } 2
'''DO'''
3
'''DO'''
OVER →STR OVER + STR→
'''IF''' DUP ISPRIME? '''THEN'''
4 ROLL SWAP
'''IF''' DUP2 POS NOT '''THEN''' + '''ELSE''' DROP '''END'''
UNROT
'''ELSE''' DROP '''END'''
NEXTPRIME
'''UNTIL''' DUP 100 > '''END'''
DROP NEXTPRIME
'''UNTIL''' DUP 100 > '''END'''
SORT
≫ '<span style="color:blue">P1P2</span>' STO
 
{{out}}
<pre>
1: { 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|Ruby}}==
<langsyntaxhighlight lang="ruby">require "prime"
 
concats = Prime.each(100).to_a.repeated_permutation(2).filter_map do |pair|
Line 800 ⟶ 1,453:
concats = concats.sort.uniq
 
concats.each_slice(10){|slice|puts slice.map{|el| el.to_s.ljust(6)}.join }</langsyntaxhighlight>
{{out}}
<pre>23 37 53 73 113 137 173 193 197 211
Line 816 ⟶ 1,469:
8389 8923 8929 8941 8971 9719 9743 9767
</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var upto = 100
var arr = upto.primes
var base = 10
Line 832 ⟶ 1,486:
})
 
say "\nFound #{arr.len} such concatenated primes."</langsyntaxhighlight>
{{out}}
<pre>
Line 857 ⟶ 1,511:
{{libheader|Wren-fmt}}
{{libheader|Wren-seq}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./fmt" for Fmt
import "./seq" for Lst
 
var limit = 99
Line 873 ⟶ 1,527:
results.sort()
System.print("Two primes under 100 concatenated together to form another prime:")
Fmt.tprint("$,6d", results, 10)
for (chunk in Lst.chunks(results, 10)) Fmt.print("$,6d", chunk)
System.print("\nFound %(results.count) such concatenated primes.")</langsyntaxhighlight>
 
{{out}}
Line 897 ⟶ 1,551:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 928 ⟶ 1,582:
Text(0, " such concatenated primes found.
");
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/314322...354950"