Rosetta Code

Concatenate two primes is also prime: Difference between revisions

Page Discussion

Concatenate two primes is also prime (view source)

Revision as of 20:39, 26 August 2022

758 bytes added ,  1 year ago
m
syntax highlighting fixup automation
No edit summary
m (syntax highlighting fixup automation)
Line 8:
{{trans|Nim}}
 
<langsyntaxhighlight lang="11l">F is_prime(a)
I a == 2
R 1B
Line 29:
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 ‘ ’)</langsyntaxhighlight>
 
{{out}}
Line 47:
{{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 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 105:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
with Ada.Integer_Text_Io;
with Ada.Strings.Fixed;
Line 164:
Put (" concat primes.");
New_Line;
end Concat_Is_Prime;</langsyntaxhighlight>
{{out}}
<pre>
Line 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 214:
OD;
print( ( newline, newline, "Found ", whole( c count, 0 ), " concat primes", newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 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 274:
write();write( i_w := 1, s_w := 0, "Found ", cCount, " concat primes" )
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 294:
</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f CONCATENATE_TWO_PRIMES_IS_ALSO_PRIME.AWK
#
Line 333:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 354:
=={{header|BASIC}}==
==={{header|BASIC256}}===
<langsyntaxhighlight BASIC256lang="basic256">c = 0
for p1 = 2 to 99
if not isPrime(p1) then continue for
Line 378:
end while
return True
end function</langsyntaxhighlight>
 
==={{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 397:
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 416:
 
==={{header|Yabasic}}===
<langsyntaxhighlight lang="yabasic">c = 0
for p1 = 2 to 99
if not isPrime(p1) then continue : fi
Line 443:
wend
return True
end sub</langsyntaxhighlight>
 
 
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: formatting grouping io kernel math.parser math.primes
present prettyprint sequences sets sorting ;
 
Line 454:
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</langsyntaxhighlight>
{{out}}
<pre>
Line 481:
=={{header|Go}}==
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 521:
}
fmt.Println("\n\nFound", len(results), "such concatenated primes.")
}</langsyntaxhighlight>
 
{{out}}
Line 544:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Control.Applicative
import Data.List ( sort )
import Data.List.Split ( chunksOf )
Line 565:
main :: IO ( )
main = do
mapM_ print $ chunksOf 15 solution</langsyntaxhighlight>
{{out}}
<pre>
Line 584:
 
'''Preliminaries'''
<langsyntaxhighlight lang="jq">def is_prime:
. as $n
| if ($n < 2) then false
Line 613:
 
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 624:
 
[100 | concatenative_primes | join("||")]
| (nwise(10) | map(lpad(6)) | join(" "))</langsyntaxhighlight>
{{out}}
<pre>
Line 642:
</pre>
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function catprimes()
Line 655:
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 668:
 
=={{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|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils, sugar
 
func isPrime(n: Positive): bool =
Line 700:
for n in concatPrimes:
stdout.write ($n).align(4), if i mod 16 == 0: '\n' else: ' '
inc i</langsyntaxhighlight>
 
{{out}}
Line 714:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Concatenate_two_primes_is_also_prime
Line 724:
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 740:
 
=={{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 754:
<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 764:
=={{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 771:
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</langsyntaxhighlight>
{{out}}
<pre>128 matching:
Line 789:
 
=={{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 836:
#= #+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 860:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 903:
see nl + "Found " + row + " prime numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 926:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require "prime"
 
concats = Prime.each(100).to_a.repeated_permutation(2).filter_map do |pair|
Line 934:
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 951:
</pre>
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var upto = 100
var arr = upto.primes
var base = 10
Line 966:
})
 
say "\nFound #{arr.len} such concatenated primes."</langsyntaxhighlight>
{{out}}
<pre>
Line 991:
{{libheader|Wren-fmt}}
{{libheader|Wren-seq}}
<langsyntaxhighlight lang="ecmascript">import "/math" for Int
import "/fmt" for Fmt
import "/seq" for Lst
Line 1,008:
System.print("Two primes under 100 concatenated together to form another prime:")
for (chunk in Lst.chunks(results, 10)) Fmt.print("$,6d", chunk)
System.print("\nFound %(results.count) such concatenated primes.")</langsyntaxhighlight>
 
{{out}}
Line 1,031:
 
=={{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 1,062:
Text(0, " such concatenated primes found.
");
]</langsyntaxhighlight>
 
{{out}}
Thundergnat
10,327

edits

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