Rosetta Code

Semiprime: Difference between revisions

Page Discussion

Semiprime (view source)

Revision as of 08:47, 2 April 2024

32,670 bytes added ,  2 months ago
m
→‎{{header|EasyLang}}
 
(94 intermediate revisions by 40 users not shown)
Line 19:
 
 
;Task;:
Write a function determining whether a given number is semiprime.
 
 
;See also:
* The Wikipedia article:   [http[wp://mathworld.wolfram.com/Semiprime.html |semiprime]].
* The Wikipedia article:   [http[wp://mathworld.wolfram.com/AlmostPrime.html Almost_prime|almost prime]].
* The OEIS articlesequence:   [http://[oeis.org/:A001358|A001358: semiprimes] ]  which has a shorter definition: ''the product of two primes''.
<br><br>
 
=={{header|11l}}==
{{trans|C++}}
 
<syntaxhighlight lang="11l">F is_semiprime(=c)
V a = 2
V b = 0
L b < 3 & c != 1
I c % a == 0
c /= a
b++
E
a++
R b == 2
 
print((1..100).filter(n -> is_semiprime(n)))</syntaxhighlight>
 
{{out}}
<pre>
[4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95]
</pre>
 
=={{header|360 Assembly}}==
{{trans|C}}
<langsyntaxhighlight lang="360asm">* Semiprime 14/03/2017
SEMIPRIM CSECT
USING SEMIPRIM,R13 base register
Line 101 ⟶ 122:
XDEC DS CL12 temp
YREGS
END SEMIPRIM</langsyntaxhighlight>
{{out}}
<pre>
Line 110 ⟶ 131:
</pre>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">BYTE FUNC IsSemiPrime(INT n)
INT a,b
 
a=2 b=0
WHILE b<3 AND n#1
DO
IF n MOD a=0 THEN
n==/a b==+1
ELSE
a==+1
FI
OD
IF b=2 THEN
RETURN(1)
FI
RETURN(0)
 
PROC Main()
INT i
 
PrintE("Semiprimes:")
FOR i=1 TO 500
DO
IF IsSemiPrime(i) THEN
PrintI(i) Put(32)
FI
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Semiprime.png Screenshot from Atari 8-bit computer]
<pre>
Semiprimes:
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95 106 111 115 118
119 121 122 123 129 133 134 141 142 143 145 146 155 158 159 161 166 169 177 178 183 185 187 194 201 202 203 205 206
209 213 214 215 217 218 219 221 226 235 237 247 249 253 254 259 262 265 267 274 278 287 289 291 295 298 299 301 302
303 305 309 314 319 321 323 326 327 329 334 335 339 341 346 355 358 361 362 365 371 377 381 382 386 391 393 394 395
398 403 407 411 413 415 417 422 427 437 445 446 447 451 453 454 458 466 469 471 473 478 481 482 485 489 493 497
</pre>
 
=={{header|Ada}}==
Line 115 ⟶ 175:
This imports the package '''Prime_Numbers''' from [[Prime decomposition#Ada]].
 
<langsyntaxhighlight lang="ada">with Prime_Numbers, Ada.Text_IO;
procedure Test_Semiprime is
Line 135 ⟶ 195:
end if;
end loop;
end Test_Semiprime;</langsyntaxhighlight>
 
It outputs all semiprimes below 100 and all semiprimes between 1675 and 1680:
Line 152 ⟶ 212:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68"># returns TRUE if n is semi-prime, FALSE otherwise #
# n is semi prime if it has exactly two prime factors #
PROC is semiprime = ( INT n )BOOL:
Line 190 ⟶ 250:
OD;
print( ( newline ) )
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 196 ⟶ 256:
semi primes below between 1670 and 1690: 1671 1673 1678 1679 1681 1685 1687 1689
</pre>
 
=={{header|ALGOL W}}==
{{Trans|C++}}
<syntaxhighlight lang="algolw">
begin % find some semi-primes - numbers with exactly 2 prime factors %
logical procedure isSemiPrime( integer value v ) ;
begin
integer a, b, c;
a := 2; b := 0; c := v;
while b < 3 and c > 1 do begin
if c rem a = 0 then begin
c := c div a;
b := b + 1
end
else a := a + 1;
end while_b_lt_3_and_c_ne_1 ;
b = 2
end isSemiPrime ;
 
for x := 2 until 99 do begin
if isSemiPrime( x ) then writeon( i_w := 1, s_w := 0, x, " " )
end for_x
end.
</syntaxhighlight>
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">semiPrime?: function [x][
2 = size factors.prime x
]
 
print select 1..100 => semiPrime?</syntaxhighlight>
 
{{out}}
 
<pre>4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95</pre>
 
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">SetBatchLines -1
k := 1
loop, 100
Line 253 ⟶ 353:
}
;=================================================================================================================================================
esc::Exitapp</langsyntaxhighlight>
{{output}}
<Pre>
Line 262 ⟶ 362:
yes- 1678 - 2*839
yes- 1679 - 23*73</Pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SEMIPRIME.AWK
BEGIN {
main(0,100)
main(1675,1680)
exit(0)
}
function main(lo,hi, i) {
printf("%d-%d:",lo,hi)
for (i=lo; i<=hi; i++) {
if (is_semiprime(i)) {
printf(" %d",i)
}
}
printf("\n")
}
function is_semiprime(n, i,nf) {
nf = 0
for (i=2; i<=n; i++) {
while (n % i == 0) {
if (nf == 2) {
return(0)
}
nf++
n /= i
}
}
return(nf == 2)
}
</syntaxhighlight>
{{out}}
<pre>
0-100: 4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
1675-1680: 1678 1679
</pre>
 
 
=={{header|BASIC}}==
==={{header|ASIC}}===
{{trans|Tiny BASIC}}
<syntaxhighlight lang="basic">
REM Semiprime
PRINT "Enter an integer ";
INPUT N
N = ABS(N)
 
Count = 0
IF N >= 2 THEN
FOR Factor = 2 TO N
NModFactor = N MOD Factor
WHILE NModFactor = 0
Count = Count + 1
N = N / Factor
NModFactor = N MOD Factor
WEND
NEXT Factor
ENDIF
 
IF Count = 2 THEN
PRINT "It is a semiprime."
ELSE
PRINT "It is not a semiprime."
ENDIF
END
</syntaxhighlight>
{{out}}
<pre>
Enter an integer ?60
It is not a semiprime.
</pre>
<pre>
Enter an integer ?33
It is a semiprime.
</pre>
 
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">function semiprime$ (n)
a = 2
c = 0
while c < 3 and n > 1
if (n mod a) = 0 then
n = n / a
c = c + 1
else
a = a + 1
end if
end while
if c = 2 then return "True"
return "False"
end function
 
for i = 0 to 64
print i, semiprime$(i)
next i
end</syntaxhighlight>
 
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{trans|BASIC256}}
<syntaxhighlight lang="qbasic">100 rem Semiprime
110 cls
120 for i = 0 to 64
130 print using "## ";i semiprime$(i)
140 next i
150 end
160 sub semiprime$(n)
170 a = 2
180 c = 0
190 do while c < 3 and n > 1
200 if n mod a = 0 then n = n/a : c = c+1 else a = a+1
210 loop
220 if c = 2 then semiprime$ = "True" else semiprime$ = "False"
230 end sub</syntaxhighlight>
 
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">function semiprime( n as uinteger ) as boolean
dim as uinteger a = 2, c = 0
while c < 3 andalso n > 1
if n mod a = 0 then
n /= a
c += 1
else
a += 1
end if
wend
if c = 2 then return true
return false
end function
for i as uinteger = 0 to 64
print i, semiprime(i)
next i</syntaxhighlight>
 
==={{header|GW-BASIC}}===
<syntaxhighlight lang="gwbasic">10 INPUT "Enter a number: ", N
20 N=ABS(N)
30 C = 0
40 IF N < 3 THEN GOTO 80
50 F = 2
60 IF N MOD F = 0 THEN C = C + 1 : N = N / F ELSE F = F + 1
70 IF N > 1 THEN GOTO 60
80 IF C=2 THEN PRINT "It's a semiprime." ELSE PRINT "It is not a semiprime."</syntaxhighlight>
 
==={{header|Minimal BASIC}}===
{{trans|Tiny BASIC}}
{{works with|Commodore BASIC|3.5}}
{{works with|Nascom ROM BASIC|4.7}}
<syntaxhighlight lang="gwbasic">
10 REM Semiprime
20 PRINT "Enter an integer";
30 INPUT N
40 LET N = ABS(N)
50 LET C = 0
60 IF N < 2 THEN 130
70 FOR F = 2 TO N
80 IF INT(N/F)*F <> N THEN 120
90 LET C = C+1
100 LET N = N/F
110 GOTO 80
120 NEXT F
130 IF C <> 2 THEN 160
140 PRINT "It is a semiprime."
150 GOTO 170
160 PRINT "It is not a semiprime."
170 END
</syntaxhighlight>
 
==={{header|Palo Alto Tiny BASIC}}===
{{trans|Tiny BASIC}}
<syntaxhighlight lang="basic">
10 REM SEMIPRIME
20 INPUT "ENTER AN INTEGER"N
30 LET N=ABS(N)
40 LET C=0
50 IF N<2 GOTO 90
60 FOR F=2 TO N
70 IF (N/F)*F=N LET C=C+1,N=N/F;GOTO 70
80 NEXT F
90 IF C=2 PRINT "IT IS A SEMIPRIME.";STOP
100 PRINT "IT IS NOT A SEMIPRIME.";STOP
</syntaxhighlight>
{{out}} 2 runs.
<pre>
ENTER AN INTEGER:60
IT IS NOT A SEMIPRIME.
</pre>
<pre>
ENTER AN INTEGER:33
IT IS A SEMIPRIME.
</pre>
 
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure.s semiprime(n.i)
a.i = 2
c.i = 0
While c < 3 And n > 1
If (n % a) = 0
n / a
c + 1
Else
a + 1
EndIf
Wend
If c = 2
ProcedureReturn "True" ;#True
EndIf
ProcedureReturn "False" ;#False
EndProcedure
OpenConsole()
For i.i = 0 To 64
PrintN(Str(i) + #TAB$ + semiprime(i))
Next i
 
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input()
CloseConsole()
End</syntaxhighlight>
 
==={{header|Run BASIC}}===
<syntaxhighlight lang="vbnet">function semiprime$(n)
a = 2
c = 0
while c < 3 and n > 1
if n mod a = 0 then
n = n / a
c = c + 1
else
a = a + 1
end if
wend
if c = 2 then semiprime$ = "True" else semiprime$ = "False"
end function
 
for i = 0 to 64
print i; chr$(9); semiprime$(i)
next i</syntaxhighlight>
 
==={{header|Tiny BASIC}}===
{{works with|TinyBasic}}
<syntaxhighlight lang="basic">10 REM Semiprime
20 PRINT "Enter an integer"
30 INPUT N
40 IF N < 0 THEN LET N = -N
50 IF N < 2 THEN GOTO 120
60 LET C = 0
70 LET F = 2
80 IF (N / F) * F = N THEN GOTO 150
90 LET F = F + 1
100 IF F > N THEN GOTO 120
110 GOTO 80
120 IF C = 2 THEN PRINT "It is a semiprime."
130 IF C <> 2 THEN PRINT "It is not a semiprime."
140 END
150 LET C = C + 1
160 LET N = N / F
170 GOTO 80</syntaxhighlight>
{{out}}2 runs.
<pre>
Enter an integer
? 60
It is not a semiprime.
</pre>
<pre>
Enter an integer
? 33
It is a semiprime.
</pre>
 
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION semiprime$ (n)
LET a = 2
LET c = 0
DO WHILE c < 3 AND n > 1
IF REMAINDER(n, a) = 0 THEN
LET n = n / a
LET c = c + 1
ELSE
LET a = a + 1
END IF
LOOP
IF c = 2 THEN LET semiprime$ = "True" ELSE LET semiprime$ = "False"
END FUNCTION
 
FOR i = 0 TO 64
PRINT i, semiprime$(i)
NEXT i
END</syntaxhighlight>
 
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">sub semiprime$ (n)
a = 2
c = 0
while c < 3 and n > 1
if mod(n, a) = 0 then
n = n / a
c = c + 1
else
a = a + 1
end if
wend
if c = 2 then return "True" : fi
return "False"
end sub
 
for i = 0 to 64
print i, chr$(9), semiprime$(i)
next i
end</syntaxhighlight>
 
=={{header|Bracmat}}==
When Bracmat is asked to take the square (or any other) root of a number, it does so by first finding the number's prime factors. It can do that for numbers up to 2^32 or 2^64 (depending on compiler and processor).
<langsyntaxhighlight lang="bracmat">semiprime=
m n a b
. 2^-64:?m
Line 271 ⟶ 681:
& !arg^!m
: (#%?a^!m*#%?b^!m|#%?a^!n&!a:?b)
& (!a.!b);</langsyntaxhighlight>
 
Test with numbers < 2^63:
<langsyntaxhighlight lang="bracmat"> 2^63:?u
& whl
' ( -1+!u:>2:?u
Line 280 ⟶ 690:
|
)
);</langsyntaxhighlight>
 
Output:
Line 331 ⟶ 741:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int semiprime(int n)
Line 351 ⟶ 761:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95</pre>
 
=={{header|C++ sharp|C#}}==
<syntaxhighlight lang="csharp">
<lang cpp>
#include <iostream>
 
bool isSemiPrime( int c )
{
int a = 2, b = 0;
while( b < 3 && c != 1 )
{
if( !( c % a ) )
{ c /= a; b++; }
else a++;
}
return b == 2;
}
int main( int argc, char* argv[] )
{
for( int x = 2; x < 100; x++ )
if( isSemiPrime( x ) )
std::cout << x << " ";
 
return 0;
}
</lang>
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|C#}}==
<lang c#>
static void Main(string[] args)
{
Line 414 ⟶ 795:
return b == 2;
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 467 ⟶ 848:
48 False
49 True
</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">
#include <iostream>
 
bool isSemiPrime( int c )
{
int a = 2, b = 0;
while( b < 3 && c != 1 )
{
if( !( c % a ) )
{ c /= a; b++; }
else a++;
}
return b == 2;
}
int main( int argc, char* argv[] )
{
for( int x = 2; x < 100; x++ )
if( isSemiPrime( x ) )
std::cout << x << " ";
 
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|Clojure}}==
{{trans|C}}
<langsyntaxhighlight lang="lisp">
(ns example
(:gen-class))
Line 486 ⟶ 896:
 
(println (filter semi-prime? (range 1 100)))
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 493 ⟶ 903:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun semiprimep (n &optional (a 2))
(cond ((> a (isqrt n)) nil)
((zerop (rem n a)) (and (primep a) (primep (/ n a))))
Line 501 ⟶ 911:
(cond ((> a (isqrt n)) t)
((zerop (rem n a)) nil)
(t (primep n (+ a 1)))))</langsyntaxhighlight>
 
Example Usage:
Line 509 ⟶ 919:
CL-USER> (semiprimep 9876543)
NIL</pre>
 
=={{header|Crystal}}==
{{trans|D}}
<syntaxhighlight lang="ruby">def semiprime(n)
nf = 0
(2..n).each do |i|
while n % i == 0
return false if nf == 2
nf += 1
n /= i
end
end
nf == 2
end
 
(1675..1681).each { |n| puts "#{n} -> #{semiprime(n)}" }</syntaxhighlight>
{{out}}
<pre>1675 -> false
1676 -> false
1677 -> false
1678 -> true
1679 -> true
1680 -> false
1681 -> true</pre>
 
Faster version using 'factor' function from [U|Li]nux Core Utilities library.
<syntaxhighlight lang="ruby">def semiprime(n)
`factor #{n}`.split(' ').size == 3
end
n = 0xffffffffffffffff_u64 # 2**64 - 1 = 18446744073709551615
(n-50..n).each { |n| puts "#{n} -> #{semiprime(n)}" }</syntaxhighlight>
{{out}}
<pre>18446744073709551565 -> false
18446744073709551566 -> true
18446744073709551567 -> false
18446744073709551568 -> false
18446744073709551569 -> false
18446744073709551570 -> false
18446744073709551571 -> false
18446744073709551572 -> false
18446744073709551573 -> false
18446744073709551574 -> false
18446744073709551575 -> false
18446744073709551576 -> false
18446744073709551577 -> true
18446744073709551578 -> false
18446744073709551579 -> false
18446744073709551580 -> false
18446744073709551581 -> false
18446744073709551582 -> false
18446744073709551583 -> false
18446744073709551584 -> false
18446744073709551585 -> false
18446744073709551586 -> false
18446744073709551587 -> false
18446744073709551588 -> false
18446744073709551589 -> false
18446744073709551590 -> false
18446744073709551591 -> false
18446744073709551592 -> false
18446744073709551593 -> false
18446744073709551594 -> false
18446744073709551595 -> false
18446744073709551596 -> false
18446744073709551597 -> true
18446744073709551598 -> false
18446744073709551599 -> false
18446744073709551600 -> false
18446744073709551601 -> true
18446744073709551602 -> false
18446744073709551603 -> false
18446744073709551604 -> false
18446744073709551605 -> false
18446744073709551606 -> false
18446744073709551607 -> false
18446744073709551608 -> false
18446744073709551609 -> false
18446744073709551610 -> false
18446744073709551611 -> false
18446744073709551612 -> false
18446744073709551613 -> false
18446744073709551614 -> false
18446744073709551615 -> false</pre>
 
=={{header|D}}==
{{trans|Go}}
<langsyntaxhighlight lang="d">bool semiprime(long n) pure nothrow @safe @nogc {
auto nf = 0;
foreach (immutable i; 2 .. n + 1) {
Line 530 ⟶ 1,023:
foreach (immutable n; 1675 .. 1681)
writeln(n, " -> ", n.semiprime);
}</langsyntaxhighlight>
{{out}}
<pre>1675 -> false
Line 541 ⟶ 1,034:
=={{header|DCL}}==
Given a file primes.txt is the list of primes up to the sqrt(2^31-1), i.e. 46337;
<langsyntaxhighlight DCLlang="dcl">$ p1 = f$integer( p1 )
$ if p1 .lt. 2
$ then
Line 588 ⟶ 1,081:
$
$ clean:
$ close primes</langsyntaxhighlight>
{{out}}
<pre>$ @factor 6
Line 598 ⟶ 1,091:
$ @factor 2147483646
FACTORIZATION = "2*3*3*7*11*31*151*331"</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
{This function would normally be in a library, but it shown here for clarity}
 
procedure GetAllFactors(N: Integer;var IA: TIntegerDynArray);
{Make a list of all irreducible factor of N}
var I: integer;
begin
SetLength(IA,1);
IA[0]:=1;
for I:=2 to N do
while (N mod I)=0 do
begin
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=I;
N:=N div I;
end;
end;
 
 
function IsSemiprime(N: integer): boolean;
{Test if number is semiprime}
var IA: TIntegerDynArray;
begin
{Get all factors of N}
GetAllFactors(N,IA);
Result:=False;
{Since 1 is factor, ignore it}
if Length(IA)<>3 then exit;
Result:=IsPrime(IA[1]) and IsPrime(IA[2]);
end;
 
 
procedure Semiprimes(Memo: TMemo);
var I,Cnt: integer;
var S: string;
begin
Cnt:=0;
S:='';
{Test first 100 number to see if they are semiprime}
for I:=0 to 100-1 do
if IsSemiprime(I) then
begin
Inc(Cnt);
S:=S+Format('%4d',[I]);
if (Cnt mod 10)= 0 then S:=S+CRLF;
end;
Memo.Lines.Add(S);
Memo.Lines.Add('Count='+IntToStr(Cnt));
end;
 
</syntaxhighlight>
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26
33 34 35 38 39 46 49 51 55 57
58 62 65 69 74 77 82 85 86 87
91 93 94 95
Count=34
Elapsed Time: 5.182 ms.
 
</pre>
 
 
=={{header|EasyLang}}==
<syntaxhighlight>
fastfunc factor num .
i = 2
while i <= sqrt num
if num mod i = 0
return i
.
i += 1
.
return 1
.
func semiprime n .
f1 = factor n
if f1 = 1
return 0
.
f2 = n div f1
if factor f1 = 1 and factor f2 = 1
return 1
.
return 0
.
for i = 1 to 1000
if semiprime i = 1
write i & " "
.
.
</syntaxhighlight>
 
=={{header|EchoLisp}}==
<langsyntaxhighlight lang="scheme">
(lib 'math)
(define (semi-prime? n)
Line 621 ⟶ 1,212:
(prime-factors 100000000042)
→ (2 50000000021)
</syntaxhighlight>
</lang>
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="elixir">defmodule Prime do
def semiprime?(n), do: length(decomposition(n)) == 2
Line 637 ⟶ 1,228:
Enum.each(1675..1680, fn n ->
:io.format "~w -> ~w\t~s~n", [n, Prime.semiprime?(n), Prime.decomposition(n)|>Enum.join(" x ")]
end)</langsyntaxhighlight>
 
{{out}}
Line 654 ⟶ 1,245:
Another using prime factors from [[Prime_decomposition#Erlang]] :
 
<langsyntaxhighlight lang="erlang">
-module(factors).
-export([factors/1,kthfactor/2]).
Line 674 ⟶ 1,265:
_ ->
false end.
</syntaxhighlight>
</lang>
{out}
<pre>
Line 716 ⟶ 1,307:
 
=={{header|ERRE}}==
<syntaxhighlight lang="text">
PROGRAM SEMIPRIME_NUMBER
 
Line 743 ⟶ 1,334:
PRINT
END PROGRAM
</syntaxhighlight>
</lang>
Output is the same of "C" version.
 
=={{header|Euler}}==
{{Trans|C++}}
<!-- syntaxhighlight lang="euler"> -->
'''begin''' '''new''' isSemiPrime; '''new''' x; '''label''' xLoop;
isSemiPrime <-
` '''formal''' v;
'''begin''' '''new''' a; '''new''' b; '''new''' c; '''label''' again;
a <- 2; b <- 0; c <- v;
again: '''if''' b < 3 '''and''' c > 1 '''then''' '''begin'''
'''if''' c '''mod''' a = 0 '''then''' '''begin'''
c <- c % a;
b <- b + 1
'''end'''
'''else''' a <- a + 1;
'''goto''' again
'''end''' '''else''' 0;
b = 2
'''end'''
'
;
x <- 1;
xLoop: '''if''' [ x <- x + 1 ] < 100 '''then''' '''begin'''
'''if''' isSemiPrime( x ) '''then''' '''out''' x '''else''' 0;
'''goto''' xLoop
'''end''' '''else''' 0
'''end''' $
<!-- </syntaxhighlight> -->
{{out}}
<pre>
NUMBER 4
NUMBER 6
NUMBER 9
NUMBER 10
...
NUMBER 91
NUMBER 93
NUMBER 94
NUMBER 95
</pre>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">let isSemiprime (n: int) =
let rec loop currentN candidateFactor numberOfFactors =
if numberOfFactors > 2 then numberOfFactors
Line 761 ⟶ 1,392:
|> Seq.choose (fun n -> if isSemiprime n then Some(n) else None)
|> Seq.toList
|> printfn "%A"</langsyntaxhighlight>
{{out}}
<pre>[4; 6; 9; 10; 14; 15; 21; 22; 25; 26; 33; 34; 35; 38; 39; 46; 49; 51; 55; 57; 58; 62; 65; 69; 74; 77; 82; 85; 86; 87; 91; 93; 94; 95]
Line 767 ⟶ 1,398:
</pre>
 
=={{Headerheader|ForthFactor}}==
{{works with|Factor|0.98}}
<lang forth>: semiprime?
<syntaxhighlight lang="text">USING: io kernel math.primes.factors prettyprint sequences ;
 
: semiprime? ( n -- ? ) factors length 2 = ;</syntaxhighlight>
 
Displaying the semiprimes under 100:
 
<syntaxhighlight lang="text">100 <iota> [ semiprime? ] filter [ bl ] [ pprint ] interleave nl</syntaxhighlight>
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|Forth}}==
<syntaxhighlight lang="forth">: semiprime?
0 swap dup 2 do
begin dup i mod 0= while i / swap 1+ swap repeat
Line 775 ⟶ 1,420:
;
 
: test 100 2 do i semiprime? if i . then loop cr ;</langsyntaxhighlight>
{{out}}
<pre>
Line 782 ⟶ 1,427:
</pre>
 
=={{Headerheader|GoFrink}}==
<syntaxhighlight lang="frink">isSemiprime[n] := length[factorFlat[n]] == 2</syntaxhighlight>
<lang go>package main
 
=={{header|Go}}==
<syntaxhighlight lang="go">package main
 
import "fmt"
Line 805 ⟶ 1,453:
fmt.Println(v, "->", semiprime(v))
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 818 ⟶ 1,466:
=={{header|Haskell}}==
{{libheader|Data.Numbers.Primes}}
<langsyntaxhighlight Haskelllang="haskell">isSemiprime :: Int -> Bool
isSemiprime n = (length factors) == 2 && (product factors) == n ||
(length factors) == 1 && (head factors) ^ 2 == n
where factors = primeFactors n</langsyntaxhighlight>
 
Alternative (and faster) implementation using pattern matching:
<langsyntaxhighlight Haskelllang="haskell">isSemiprime :: Int -> Bool
isSemiprime n = case (primeFactors n) of
[f1, f2] -> f1 * f2 == n
otherwise -> False</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
 
Works in both languages:
<langsyntaxhighlight lang="unicon">link "factors"
 
procedure main(A)
Line 840 ⟶ 1,488:
procedure semiprime(n) # Succeeds and produces the factors only if n is semiprime.
return (2 = *(nf := factors(n)), nf)
end</langsyntaxhighlight>
 
{{Out}}
Line 854 ⟶ 1,502:
Implementation:
 
<langsyntaxhighlight Jlang="j">isSemiPrime=: 2 = #@q: ::0:"0</langsyntaxhighlight>
 
Example use: find all semiprimes less than 100:
 
<langsyntaxhighlight Jlang="j"> I. isSemiPrime i.100
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95</langsyntaxhighlight>
 
Description: factor the number and count the primes in the factorization, is it 2?
Line 868 ⟶ 1,516:
 
Like the Ada example here, this borrows from [[Prime decomposition#Java|Prime decomposition]] and shows the semiprimes below 100 and from 1675 to 1680.
<langsyntaxhighlight lang="java5">import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
Line 924 ⟶ 1,572:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>4 6 9 10 14 15 21 22 25 26 27 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 81 82 85 86 87 91 93 94 95
1678 1679</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
def is_semiprime:
{i: 2, n: ., nf: 0}
| until( .i > .n or .result;
until(.n % .i != 0 or .result;
if .nf == 2 then .result = 0
else .nf += 1
| .n /= .i
end)
| .i += 1)
| if .result == 0 then false else .nf == 2 end;
</syntaxhighlight>
'''Examples'''
<syntaxhighlight lang="jq">
(1679, 1680) | "\(.) => \(is_semiprime)"
</syntaxhighlight>
{{out}}
<pre>
1679 => true
1680 => false
</pre>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
(Uses the built-in <code>factor</code> function.)
 
<lang julia>semiprime(n) = sum(values(factor(n))) == 2</lang>
<syntaxhighlight lang="julia">using Primes
issemiprime(n::Integer) = sum(values(factor(n))) == 2
@show filter(issemiprime, 1:100)</syntaxhighlight>
 
{{out}}
<pre>filter(issemiprime, 1:100) = [4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95]</pre>
<pre>julia> filter(semiprime, 1:100)
[4,6,9,10,14,15,21,22,25,26,33,34,35,38,39,46,49,51,55,57,58,62,65,69,74,77,82,85,86,87,91,93,94,95]</pre>
 
=={{header|Kotlin}}==
{{trans|Go}}
<langsyntaxhighlight lang="scala">// version 1.1.2
 
fun isSemiPrime(n: Int): Boolean {
Line 955 ⟶ 1,631:
for (v in 1675..1680)
println("$v ${if (isSemiPrime(v)) "is" else "isn't"} semi-prime")
}</langsyntaxhighlight>
 
{{out}}
Line 965 ⟶ 1,641:
1679 is semi-prime
1680 isn't semi-prime
</pre>
 
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
 
# Semiprime - As translated from C
 
# # Variables:
#
 
# # Functions:
#
# Function _issemiprime(p2) - return 1 if p2 semiprime, 0 if not
#
function _issemiprime {
typeset _p2 ; integer _p2=$1
typeset _p _f ; integer _p _f=0
 
for ((_p=2; (_f<2 && _p*_p<=_p2); _p++)); do
while (( _p2 % _p == 0 )); do
(( _p2 /= _p ))
(( _f++ ))
done
done
 
return $(( _f + (_p2 > 1) == 2 ))
}
 
######
# main #
######
 
integer i
for ((i=2; i<100; i++)); do
_issemiprime ${i}
(( $? )) && printf " %d" ${i}
done
echo
</syntaxhighlight>
{{out}}<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
 
{def factors
{def factors.r
{lambda {:n :i}
{if {> :i :n}
then
else {if {= {% :n :i} 0}
then :i {factors.r {/ :n :i} :i}
else {factors.r :n {+ :i 1}} }}}}
{lambda {:n}
{A.new {factors.r :n 2} }}}
-> factors
 
{factors 491} -> [491] // prime
{factors 492} -> [2,2,3,41]
{factors 493} -> [17,29] // semiprime
{factors 494} -> [2,13,19]
{factors 495} -> [3,3,5,11]
{factors 496} -> [2,2,2,2,31]
{factors 497} -> [7,71] // semiprime
{factors 498} -> [2,3,83]
{factors 499} -> [499] // prime
{factors 500} -> [2,2,5,5,5]
 
{S.replace \s by space in
{S.map {lambda {:i}
{let { {:i :i} {:f {factors :i}}
} {if {= {A.length :f} 2}
then :i={A.first :f}*{A.last :f}
else}} }
{S.serie 1 100}}}
->
4 = 2*2
6 = 2*3
9 = 3*3
10 = 2*5
14 = 2*7
15 = 3*5
21 = 3*7
22 = 2*11
25 = 5*5
26 = 2*13
33 = 3*11
34 = 2*17
35 = 5*7
38 = 2*19
39 = 3*13
46 = 2*23
49 = 7*7
51 = 3*17
55 = 5*11
57 = 3*19
58 = 2*29
62 = 2*31
65 = 5*13
69 = 3*23
74 = 2*37
77 = 7*11
82 = 2*41
85 = 5*17
86 = 2*43
87 = 3*29
91 = 7*13
93 = 3*31
94 = 2*47
95 = 5*19
</syntaxhighlight>
 
=={{header|Lingo}}==
<syntaxhighlight lang="lingo">on isSemiPrime (n)
div = 2
cnt = 0
repeat while cnt < 3 and n <> 1
if n mod div = 0 then
n = n / div
cnt = cnt + 1
else
div = div + 1
end if
end repeat
return cnt=2
end</syntaxhighlight>
 
<syntaxhighlight lang="lingo">res = []
repeat with i = 1 to 100
if isSemiPrime(i) then res.add(i)
end repeat
put res</syntaxhighlight>
 
{{out}}
<pre>
-- [4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95]
</pre>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">
<lang Lua>
function semiprime (n)
local divisor, count = 2, 0
Line 985 ⟶ 1,799:
print(n, semiprime(n))
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 997 ⟶ 1,811:
 
=={{header|Maple}}==
<langsyntaxhighlight Maplelang="maple">SemiPrimes := proc( n )
local fact;
fact := NumberTheory:-Divisors( n ) minus {1, n};
Line 1,006 ⟶ 1,820:
end if;
end proc:
{ seq( SemiPrimes( i ), i = 1..100 ) };</langsyntaxhighlight>
Output:
<syntaxhighlight lang="maple">
<lang Maple>
{ 4,6,9,10,14,15,21,22,25,26,33,34,35,38,39,46,49,51,55,57,58,62,65,69,74,77,82,85,86,87,91,93,94,95 }
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">semiPrimeQ[n_Integer] := Module[{factors, numfactors},
factors = FactorInteger[n] // Transpose;
numfactors = factors[[2]] // Total ;
numfactors == 2
]</syntaxhighlight>
]
</lang>
Example use: find all semiprimes less than 100:
<langsyntaxhighlight Mathematicalang="mathematica">semiPrimeQ[#] & /@ Range[100];
Position[%, True] // Flatten</langsyntaxhighlight>
{{outputout}}
<pre>{4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51,
55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95}</pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
/* The first part consider the cases of squares of primes, the second part the remaining cases */
semiprimep(n):=if integerp(sqrt(n)) and primep(sqrt(n)) then true else lambda([x],length(ifactors(x))=2 and unique(map(second,ifactors(x)))=[1])(n)$
 
/* Example */
sublist(makelist(i,i,100),semiprimep);
</syntaxhighlight>
{{out}}
<pre>
[4,6,9,10,14,15,21,22,25,26,33,34,35,38,39,46,49,51,55,57,58,62,65,69,74,77,82,85,86,87,91,93,94,95]
</pre>
 
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">isSemiprime = function(num)
divisor = 2
primes = 0
while primes < 3 and num != 1
if num % divisor == 0 then
num = num / divisor;
primes = primes + 1
else
divisor = divisor + 1
end if
end while
return primes == 2
end function
 
print "Semiprimes up to 100:"
results = []
for i in range(2, 100)
if isSemiprime(i) then results.push i
end for
print results</syntaxhighlight>
 
{{output}}
<pre>Semiprimes up to 100:
[4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51,
55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95]</pre>
 
=={{header|NewLisp}}==
<syntaxhighlight lang="newlisp">
;;; Practically identical to the EchoLisp solution
(define (semiprime? n)
(= (length (factor n)) 2))
;
;;; Example (sadly factor doesn't accept bigints)
(println (filter semiprime? (sequence 2 100)))
(setq x 9223372036854775807)
(while (not (semiprime? x)) (-- x))
(println "Biggest semiprime reachable: " x " = " ((factor x) 0) " x " ((factor x) 1))
</syntaxhighlight>
{{output}}
<pre>
(4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95)
Biggest semiprime reachable: 9223372036854775797 = 3 x 3074457345618258599
</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">proc isSemiPrime(k: int): stringbool =
var
i: int = 2
compte: intcount = 0
x: int = k
while i <= x and comptecount < 3:
if (x mod i) == 0:
x = x div i
compteinc += 1count
else:
inc i += 1
result = count == 2
if compte==2:
result = "is semi-prime"
else:
result = "isn't semi-prime"
for k in 1675..1680:
echo k, (if k.isSemiPrime(): " is" else: " isn’t"), " semi-prime"</syntaxhighlight>
echo k," ",isSemiPrime(k)</lang>
 
{{output}}
<pre>1675 isn't semi-prime
Line 1,056 ⟶ 1,925:
=={{header|Objeck}}==
{{trans|Go}}
<langsyntaxhighlight lang="objeck">
class SemiPrime {
function : Main(args : String[]) ~ Nil {
Line 1,081 ⟶ 1,950:
return nf = 2;
}
}</langsyntaxhighlight>
 
Output:
Line 1,088 ⟶ 1,957:
=={{header|Oforth}}==
 
<langsyntaxhighlight Oforthlang="oforth">func: semiprime(n)
| i |
0 2 n sqrt asInteger for: i [ while(n i /mod swap 0 &=) [ ->n 1+ ] drop ]
n 1 > ifTrue: [ 1+ ] 2 == ; </langsyntaxhighlight>
 
{{out}}
Line 1,100 ⟶ 1,969:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">issemi(n)=bigomega(n)==2</langsyntaxhighlight>
 
A faster version might use trial division and primality testing:
<langsyntaxhighlight lang="parigp">issemi(n)={
forprime(p=2,97,if(n%p==0, return(isprime(n/p))));
if(isprime(n), return(0));
bigomega(n)==2
};</langsyntaxhighlight>
 
To get faster, partial factorization can be used. At this time GP does not have access to meaningful partial factorization (though it can get it to some extent through flags on <code>factorint</code>), so this version is in PARI:
<langsyntaxhighlight lang="c">long
issemiprime(GEN n)
{
Line 1,186 ⟶ 2,055:
avma = ltop;
return 0; /* never used */
}</langsyntaxhighlight>
 
=={{header|Pascal}}==
{{libheader|primTrial}}{{works with|Free Pascal}}
 
<langsyntaxhighlight lang="pascal">program SemiPrime;
{$IFDEF FPC}
{$Mode objfpc}// compiler switch to use result
Line 1,231 ⟶ 2,100:
inc(i);
until i> k;
END.</langsyntaxhighlight>
;output:
<pre>
Line 1,252 ⟶ 2,121:
{{libheader|ntheory}}
With late versions of the ntheory module, we can use <tt>is_semiprime</tt> to get answers for 64-bit numbers in single microseconds.
<langsyntaxhighlight lang="perl">use ntheory "is_semiprime";
for ([1..100], [1675..1681], [2,4,99,100,1679,5030,32768,1234567,9876543,900660121]) {
print join(" ",grep { is_semiprime($_) } @$_),"\n";
}</langsyntaxhighlight>
{{out}}
<pre>4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
Line 1,262 ⟶ 2,131:
 
One can also use <tt>factor</tt> in scalar context, which gives the number of factors (like <tt>bigomega</tt> in Pari/GP and <tt>PrimeOmega</tt> in Mathematica). This skips some optimizations but at these small sizes it doesn't matter.
<langsyntaxhighlight lang="perl">use ntheory "factor";
print join(" ", grep { scalar factor($_) == 2 } 1..100),"\n";</langsyntaxhighlight>
 
While <tt>is_semiprime</tt> is the fastest way, we can do some of its pre-tests by hand, such as:
<langsyntaxhighlight lang="perl">use ntheory qw/factor is_prime trial_factor/;
sub issemi {
my $n = shift;
Line 1,274 ⟶ 2,143:
}
2 == factor($n);
}</langsyntaxhighlight>
 
=={{header|Perl 6Phix}}==
<!--<syntaxhighlight lang="phix">-->
Here is a naive, grossly inefficient implementation.
<span style="color: #008080;">function</span> <span style="color: #000000;">semiprime</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<lang perl6>sub is-semiprime (Int $n --> Bool) {
<span style="color: #008080;">return</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">))==</span><span style="color: #000000;">2</span>
not $n.is-prime and
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
.is-prime given
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)&</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1680</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1675</span><span style="color: #0000FF;">),</span><span style="color: #000000;">semiprime</span><span style="color: #0000FF;">),{</span><span style="color: #004600;">pp_IntCh</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">})</span>
$n div first $n %% *,
<!--</syntaxhighlight>-->
grep &is-prime, 2 .. *;
}
 
use Test;
my @primes = grep &is-prime, 2 .. 100;
for ^5 {
nok is-semiprime([*] my @f1 = @primes.roll(1)), ~@f1;
ok is-semiprime([*] my @f2 = @primes.roll(2)), ~@f2;
nok is-semiprime([*] my @f3 = @primes.roll(3)), ~@f3;
nok is-semiprime([*] my @f4 = @primes.roll(4)), ~@f4;
}</lang>
{{out}}
<pre>ok 1 - 17
{4,6,9,10,14,15,21,22,25,26,33,34,35,38,39,46,49,51,55,57,58,62,65,69,74,77,
ok 2 - 47 23
82,85,86,87,91,93,94,95,1678,1679}
ok 3 - 23 37 41
</pre>
ok 4 - 53 37 67 47
ok 5 - 5
ok 6 - 73 43
ok 7 - 13 53 71
ok 8 - 7 79 37 71
ok 9 - 41
ok 10 - 71 37
ok 11 - 37 53 43
ok 12 - 3 2 47 67
ok 13 - 17
ok 14 - 41 61
ok 15 - 71 31 79
ok 16 - 97 17 73 17
ok 17 - 61
ok 18 - 73 47
ok 19 - 13 19 5
ok 20 - 37 97 11 31</pre>
 
=={{header|PHP}}==
===More efficient example===
{{trans|TypeScript}}
Here is a more verbose, but MUCH more efficient implementation. Demonstrating using it to find an infinite list of semiprimes and to check a range of integers to find the semiprimes.
<syntaxhighlight lang="php">
{{works with|Rakudo|2017.02}}
<?php
// Semiprime
 
function primeFactorsCount($n)
<lang perl6>sub is-semiprime ( Int $n where * > 0 ) {
{
return False if $n.is-prime;
my $factorn = find-factorabs( $n );
$count = 0; // Result
return True if $factor.is-prime && ( $n div $factor ).is-prime;
False;if ($n >= 2)
for ($factor = 2; $factor <= $n; $factor++)
while ($n % $factor == 0) {
$count++;
$n /= $factor;
}
return $count;
}
 
echo "Enter an integer: ",
sub find-factor ( Int $n, $constant = 1 ) {
$n = (int)fgets(STDIN);
my $x = 2;
echo (primeFactorsCount($n) == 2 ?
my $rho = 1;
"It is a semiprime.\n" : "It is not a semiprime.\n");
my $factor = 1;
?>
while $factor == 1 {
</syntaxhighlight>
$rho *= 2;
my $fixed = $x;
for ^$rho {
$x = ( $x * $x + $constant ) % $n;
$factor = ( $x - $fixed ) gcd $n;
last if 1 < $factor;
}
}
$factor = find-factor( $n, $constant + 1 ) if $n == $factor;
$factor;
}
 
INIT my $start = now;
 
# Infinite list of semiprimes
constant @semiprimes = 4, 6, 9, -> $p { ($p + 1 ... &is-semiprime).tail } ... *;
 
# Show the semiprimes < 100
say 'Semiprimes less than 100:';
say @semiprimes[^ @semiprimes.first: * > 100, :k ], "\n";
 
# Check individual integers, or in this case, a range
my $s = 2⁹⁷ - 1;
say "Is $_ semiprime?: ", is-semiprime( $_ ) for $s .. $s + 30;
 
say 'elapsed seconds: ', now - $start;
</lang>
{{out}}
<pre>Semiprimes less than 100:
(4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95)
 
Is 158456325028528675187087900671 semiprime?: True
Is 158456325028528675187087900672 semiprime?: False
Is 158456325028528675187087900673 semiprime?: False
Is 158456325028528675187087900674 semiprime?: False
Is 158456325028528675187087900675 semiprime?: False
Is 158456325028528675187087900676 semiprime?: False
Is 158456325028528675187087900677 semiprime?: False
Is 158456325028528675187087900678 semiprime?: False
Is 158456325028528675187087900679 semiprime?: False
Is 158456325028528675187087900680 semiprime?: False
Is 158456325028528675187087900681 semiprime?: False
Is 158456325028528675187087900682 semiprime?: False
Is 158456325028528675187087900683 semiprime?: False
Is 158456325028528675187087900684 semiprime?: False
Is 158456325028528675187087900685 semiprime?: False
Is 158456325028528675187087900686 semiprime?: False
Is 158456325028528675187087900687 semiprime?: False
Is 158456325028528675187087900688 semiprime?: False
Is 158456325028528675187087900689 semiprime?: False
Is 158456325028528675187087900690 semiprime?: False
Is 158456325028528675187087900691 semiprime?: False
Is 158456325028528675187087900692 semiprime?: False
Is 158456325028528675187087900693 semiprime?: False
Is 158456325028528675187087900694 semiprime?: False
Is 158456325028528675187087900695 semiprime?: False
Is 158456325028528675187087900696 semiprime?: False
Is 158456325028528675187087900697 semiprime?: False
Is 158456325028528675187087900698 semiprime?: False
Is 158456325028528675187087900699 semiprime?: False
Is 158456325028528675187087900700 semiprime?: False
Is 158456325028528675187087900701 semiprime?: True
elapsed seconds: 0.0574433</pre>
 
=={{header|Phix}}==
<lang Phix>function semiprime(integer n)
sequence f = prime_factors(n)
integer l = length(f)
return (l=2 and n=f[1]*f[2]) or (l=1 and n=power(f[1],2))
end function
 
procedure test(integer start, integer stop)
sequence s = {}
for i=start to stop do
if semiprime(i) then
s &= i
end if
end for
?s
?length(s)
end procedure
test(1,100)
test(1675,1680)</lang>
<pre>
Enter an integer: 60
{4,6,9,10,14,15,21,22,25,26,33,34,35,38,39,46,49,51,55,57,58,62,65,69,74,77,82,85,86,87,91,93,94,95}
It is not a semiprime.
34
</pre>
{1678,1679}
<pre>
2
Enter an integer: 33
It is a semiprime.
</pre>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de factor (N)
(make
(let
Line 1,442 ⟶ 2,214:
(conc (range 1 100) (range 1675 1680)) ) )
(bye)</langsyntaxhighlight>
{{out}}
<pre>(4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95 1678 1679)</pre>
 
=={{header|PL/0}}==
{{trans|Tiny BASIC}}
PL/0 does not handle strings. So, the program waits for entering a number, and then displays 1 if the number is a semiprime, 0 otherwise.
<syntaxhighlight lang="pascal">
var n, count, factor;
begin
? n;
if n < 0 then n := -n;
count := 0;
if n >= 2 then
begin
factor := 2;
while factor <= n do
begin
while (n / factor) * factor = n do
begin
count := count + 1; n := n / factor
end;
factor := factor + 1
end;
end;
if count = 2 then ! 1;
if count <> 2 then ! 0
end.
</syntaxhighlight>
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">*process source attributes xref nest or(!);
/*--------------------------------------------------------------------
* 22.02.2014 Walter Pachl using the is_prime code from
Line 1,536 ⟶ 2,334:
 
End spb;
</syntaxhighlight>
</lang>
'''Output:'''
<pre> 900660121 1 is semiprime 30011*30011
Line 1,548 ⟶ 2,346:
100 0 is NOT semiprime 2*2*25
5040 0 is NOT semiprime 2*2*1260</pre>
 
=={{header|PL/M}}==
{{Trans|C++}}
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
<syntaxhighlight lang="plm">
100H: /* FIND SOME SEMI-PRIMES - NUMBERS WITH EXACTLY 2 PRIME FACTORS */
 
/* 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$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */
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 */
 
/* RETURNS TRUE IF V IS SEMI-PRIME, FALSE OTHERWISE */
IS$SEMI$PRIME: PROCEDURE( V )BYTE;
DECLARE V ADDRESS;
DECLARE ( A, B, C ) ADDRESS;
A = 2; B = 0; C = V;
DO WHILE B < 3 AND C > 1;
IF C MOD A = 0 THEN DO;
C = C / A;
B = B + 1;
END;
ELSE A = A + 1;
END;
RETURN B = 2;
END IS$SEMI$PRIME;
 
DECLARE X ADDRESS;
DO X = 2 TO 99;
IF IS$SEMI$PRIME( X ) THEN DO;
CALL PR$NUMBER( X );
CALL PR$CHAR( ' ' );
END;
END;
 
EOF
</syntaxhighlight>
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
<lang PowerShell>
function isPrime ($n) {
if ($n -le 1) {$false}
Line 1,576 ⟶ 2,430:
"6: $(semiprime 6)"
$OFS = " "
"semiprime formfrom 1 to 100: $(1..100 | where {semiprime $_})"
</syntaxhighlight>
</lang>
<b>Output:</b>
<pre>
Line 1,585 ⟶ 2,439:
12:
6: 2 x 3
semiprime formfrom 1 to 100: 4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|Prolog}}==
works with swi-prolog
<syntaxhighlight lang="prolog">
factors(N, FList):-
factors(N, 2, 0, FList).
 
factors(1, _, _Count, []).
factors(_, _, Count, []):- Count > 1. % break on 2 factors reached
factors(N, Start, Count, [Fac|FList]):-
N1 is floor(sqrt(N)),
between(Start, N1, Fac),
N mod Fac =:= 0,!,
N2 is N div Fac,
Count1 is Count + 1,
factors(N2, Fac, Count1, FList).
factors(N, _, _, [N]):- N >= 2.
 
semiPrimeList(Limit, List):-
findall(N, semiPrimes(2, Limit, N), List).
 
semiPrimes(Start, Limit, N):-
between(Start, Limit, N),
factors(N, [F1, F2]),
N =:= F1 * F2. % correct factors break
 
do:- semiPrimeList(100, SemiPrimes),
writeln(SemiPrimes),
findall(N, semiPrimes(1675, 1685, N), SemiPrimes2),
writeln(SemiPrimes2).
</syntaxhighlight>
{{out}}
<pre>
?- do.
[4,6,9,10,14,15,21,22,25,26,33,34,35,38,39,46,49,51,55,57,58,62,65,69,74,77,82,85,86,87,91,93,94,95]
[1678,1679,1681,1685]
true.
</pre>
 
=={{header|PROMAL}}==
<syntaxhighlight lang="promal">
;;; find some semiprimes - numbers with two prime factors
 
PROGRAM semiPrimes
INCLUDE library
 
FUNC BYTE isSemiPrime
ARG WORD n
WORD f
WORD factorCount
BYTE result
BEGIN
f = 2
factorCount = 0
WHILE factorCount < 3 AND n > 1
WHILE n % f = 0
factorCount = factorCount + 1
n = n / f
f = f + 1
IF factorCOunt = 2
result = 1
ELSE
result = 0
RETURN result
END
 
WORD n
BEGIN
OUTPUT "Semiprimes under 100:#C "
FOR n = 1 TO 99
IF isSemiPrime( n )
OUTPUT " #W", n
OUTPUT "#CSemiprimes between 1670 and 1690:#C "
FOR n = 1670 TO 1690
IF isSemiPrime( n )
OUTPUT " #W", n
END
</syntaxhighlight>
{{out}}
<pre>
Semiprimes under 100:
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
Semiprimes between 1670 and 1690:
1671 1673 1678 1679 1681 1685 1687 1689
</pre>
 
=={{header|Python}}==
This imports [[Prime decomposition#Python]]
<langsyntaxhighlight lang="python">from prime_decomposition import decompose
 
def semiprime(n):
Line 1,596 ⟶ 2,535:
try:
return next(d) * next(d) == n
except StopIteration:
return False</langsyntaxhighlight>
 
{{out}}
From Idle:
<langsyntaxhighlight lang="python">>>> semiprime(1679)
True
>>> [n for n in range(1,101) if semiprime(n)]
[4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95]
>>> </langsyntaxhighlight>
 
=={{header|Quackery}}==
 
<code>primefactors</code> is defined at [http://rosettacode.org/wiki/Prime_decomposition#Quackery Prime decomposition].
 
<syntaxhighlight lang="quackery"> [ primefactors size 2 = ] is semiprime ( n --> b )
 
say "Semiprimes less than 100:" cr
100 times [ i^ semiprime if [ i^ echo sp ] ]</syntaxhighlight>
 
{{out}}
 
<pre>Semiprimes less than 100:
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95</pre>
 
=={{header|Racket}}==
The first implementation considers all pairs of factors multiplying up to the given number and determines if any of them is a pair of primes.
<langsyntaxhighlight Racketlang="racket">#lang racket
(require math)
 
Line 1,623 ⟶ 2,576:
(for/or ((pair (pair-factorize n)))
(for/and ((el pair))
(prime? el))))</langsyntaxhighlight>
 
The alternative implementation operates directly on the list of prime factors and their multiplicities. It is approximately 1.6 times faster than the first one (according to some simple tests of mine).
<langsyntaxhighlight Racketlang="racket">#lang racket
(require math)
 
Line 1,637 ⟶ 2,590:
(= (expt (caar prime-factors) (cadar prime-factors)) n))
(and (= (length prime-factors) 2)
(= (foldl (λ (x y) (* (car x) y)) 1 prime-factors) n)))))</langsyntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
Here is a naive, grossly inefficient implementation.
<syntaxhighlight lang="raku" line>sub is-semiprime (Int $n --> Bool) {
not $n.is-prime and
.is-prime given
$n div first $n %% *, flat grep &is-prime, 2 .. *;
}
 
use Test;
my @primes = flat grep &is-prime, 2 .. 100;
for ^5 {
nok is-semiprime([*] my @f1 = @primes.roll(1)), ~@f1;
ok is-semiprime([*] my @f2 = @primes.roll(2)), ~@f2;
nok is-semiprime([*] my @f3 = @primes.roll(3)), ~@f3;
nok is-semiprime([*] my @f4 = @primes.roll(4)), ~@f4;
}</syntaxhighlight>
{{out}}
<pre>ok 1 - 17
ok 2 - 47 23
ok 3 - 23 37 41
ok 4 - 53 37 67 47
ok 5 - 5
ok 6 - 73 43
ok 7 - 13 53 71
ok 8 - 7 79 37 71
ok 9 - 41
ok 10 - 71 37
ok 11 - 37 53 43
ok 12 - 3 2 47 67
ok 13 - 17
ok 14 - 41 61
ok 15 - 71 31 79
ok 16 - 97 17 73 17
ok 17 - 61
ok 18 - 73 47
ok 19 - 13 19 5
ok 20 - 37 97 11 31</pre>
 
===More efficient example===
Here is a more verbose, but MUCH more efficient implementation. Demonstrating using it to find an infinite list of semiprimes and to check a range of integers to find the semiprimes.
{{works with|Rakudo|2017.02}}
 
<syntaxhighlight lang="raku" line>sub is-semiprime ( Int $n where * > 0 ) {
return False if $n.is-prime;
my $factor = find-factor( $n );
return True if $factor.is-prime && ( $n div $factor ).is-prime;
False;
}
 
sub find-factor ( Int $n, $constant = 1 ) {
my $x = 2;
my $rho = 1;
my $factor = 1;
while $factor == 1 {
$rho *= 2;
my $fixed = $x;
for ^$rho {
$x = ( $x * $x + $constant ) % $n;
$factor = ( $x - $fixed ) gcd $n;
last if 1 < $factor;
}
}
$factor = find-factor( $n, $constant + 1 ) if $n == $factor;
$factor;
}
 
INIT my $start = now;
 
# Infinite list of semiprimes
constant @semiprimes = lazy gather for 4 .. * { .take if .&is-semiprime };
 
# Show the semiprimes < 100
say 'Semiprimes less than 100:';
say @semiprimes[^ @semiprimes.first: * > 100, :k ], "\n";
 
# Check individual integers, or in this case, a range
my $s = 2⁹⁷ - 1;
say "Is $_ semiprime?: ", .&is-semiprime for $s .. $s + 30;
 
say 'elapsed seconds: ', now - $start;
</syntaxhighlight>
{{out}}
<pre>Semiprimes less than 100:
(4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95)
 
Is 158456325028528675187087900671 semiprime?: True
Is 158456325028528675187087900672 semiprime?: False
Is 158456325028528675187087900673 semiprime?: False
Is 158456325028528675187087900674 semiprime?: False
Is 158456325028528675187087900675 semiprime?: False
Is 158456325028528675187087900676 semiprime?: False
Is 158456325028528675187087900677 semiprime?: False
Is 158456325028528675187087900678 semiprime?: False
Is 158456325028528675187087900679 semiprime?: False
Is 158456325028528675187087900680 semiprime?: False
Is 158456325028528675187087900681 semiprime?: False
Is 158456325028528675187087900682 semiprime?: False
Is 158456325028528675187087900683 semiprime?: False
Is 158456325028528675187087900684 semiprime?: False
Is 158456325028528675187087900685 semiprime?: False
Is 158456325028528675187087900686 semiprime?: False
Is 158456325028528675187087900687 semiprime?: False
Is 158456325028528675187087900688 semiprime?: False
Is 158456325028528675187087900689 semiprime?: False
Is 158456325028528675187087900690 semiprime?: False
Is 158456325028528675187087900691 semiprime?: False
Is 158456325028528675187087900692 semiprime?: False
Is 158456325028528675187087900693 semiprime?: False
Is 158456325028528675187087900694 semiprime?: False
Is 158456325028528675187087900695 semiprime?: False
Is 158456325028528675187087900696 semiprime?: False
Is 158456325028528675187087900697 semiprime?: False
Is 158456325028528675187087900698 semiprime?: False
Is 158456325028528675187087900699 semiprime?: False
Is 158456325028528675187087900700 semiprime?: False
Is 158456325028528675187087900701 semiprime?: True
elapsed seconds: 0.0574433</pre>
 
=={{header|REXX}}==
===version 1===
<langsyntaxhighlight lang="rexx">/* REXX ---------------------------------------------------------------
* 20.02.2014 Walter Pachl relying on 'prime decomposition'
* 21.02.2014 WP Clarification: I copied the algorithm created by
Line 1,696 ⟶ 2,768:
z=z%j /*% (percent) is integer divide.*/
end /*while z··· */ /* // ?---remainder integer ÷.*/
return /*finished, now return to invoker*/</langsyntaxhighlight>
'''Output'''
<pre>4 is semiprime 2 2
Line 1,710 ⟶ 2,782:
 
The &nbsp; '''isPrime''' &nbsp; function could be optimized by utilizing an integer square root function instead of testing if &nbsp; '''j*j>x''' &nbsp; for every divisor.
<langsyntaxhighlight lang="rexx">/*REXX program determines if any integer (or a range of integers) is/are semiprime. */
parse arg bot top . /*obtain optional arguments from the CL*/
if bot=='' | bot=="," then bot=random() /*None given? User wants us to guess.*/
Line 1,744 ⟶ 2,816:
else return 0
end /*k*/ /* [↑] see if 2nd factor is prime or ¬*/
end /*j*/ /* [↑] J is never a multiple of three.*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the input of: &nbsp; <tt> -1 &nbsp; 106 </tt>}}
 
<br>(Shown at three-quarter size.)
(Shown at &nbsp; <big> '''<sup>5</sup>/<sub>6</sub>''' </big> &nbsp; size.)
<pre style="font-size:75%;height:100ex">
<pre style="font-size:84%;height:100ex">
-1 isn't semiprime.
0 isn't semiprime.
Line 1,860 ⟶ 2,933:
</pre>
{{out|output|text=&nbsp; when using the input of: &nbsp; <tt> 99888111555 &nbsp; 99888111600 </tt>}}
 
<br>(Shown at three-quarter size.)
(Shown at &nbsp; <big> '''<sup>5</sup>/<sub>6</sub>''' </big> &nbsp; size.)
<pre style="font-size:75%;height:100ex">
<pre style="font-size:84%;height:100ex">
99888111555 isn't semiprime.
99888111556 isn't semiprime.
Line 1,915 ⟶ 2,989:
This REXX version is overt 20% faster than version 2 &nbsp; (when in the &nbsp; ''millions'' &nbsp; range).
 
If the 2<sup>nd</sup> argument &nbsp; ('''top''') &nbsp; is negative &nbsp; (it's absolute value is used), &nbsp; individual numbers in the range aren't shown, but the &nbsp; ''count'' &nbsp; of semiprimes found is shown.
 
It gets its speed increase by the use of memoization of the prime numbers found, an unrolled primality (division) check, and other speed improvements.
<langsyntaxhighlight lang="rexx">/*REXX program determines if any integer (or a range of integers) is/are semiprime. */
parse arg bot top . /*obtain optional arguments from the CL*/
if bot=='' | bot=="," then bot=random() /*None given? User wants us to guess.*/
Line 1,958 ⟶ 3,032:
end /*k*/ /* [↑] see if 2nd factor is prime or ¬*/
end /*j*/ /* [↑] J is never a multiple of three.*/
return 0</langsyntaxhighlight>
{{out|output|text=&nbsp; is identical to the previous REXX version.}} <br><br>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
prime = 1679
decomp(prime)
Line 1,982 ⟶ 3,056:
if n < 2 return false ok
if n < 4 return true ok
if n % 2 = 0 and n != 2 return false ok
for d = 3 to sqrt(n) step 2
if n % d = 0 return false ok
next
return true
</syntaxhighlight>
</lang>
 
=={{header|RPL}}==
<code>PDIV</code> is defined at [[Prime decomposition#RPL|Prime decomposition]]
≪ <span style="color:blue">'''PDIV'''</span> SIZE 2 == ≫ '<span style="color:blue">'''SPR1?'''</span>' STO
≪ { } 1 100 '''FOR''' n '''IF''' n <span style="color:blue">'''SPR1?'''</span> '''THEN''' n + '''END NEXT''' ≫ EVAL
{{out}}
<pre>
1: { 4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95 }
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'prime'
# 75.prime_division # Returns the factorization.75 divides by 3 once and by 5 twice => [[3, 1], [5, 2]]
 
class Integer
def semi_prime?
prime_division.mapsum( &:last ).inject( &:+ ) == 2
end
end
Line 2,002 ⟶ 3,086:
p ( 1..100 ).select( &:semi_prime? )
# [4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95]
</syntaxhighlight>
</lang>
 
Faster version using 'factor' function from [U|Li]nux Core Utilities library.
<syntaxhighlight lang="ruby">def semiprime(n)
`factor #{n}`.split.size == 3
end
n = 2**72 - 1 #4722366482869645213695
(n-50..n).each { |n| puts "#{n} -> #{semiprime(n)}" }</syntaxhighlight>
{{out}}
<pre>4722366482869645213645 -> false
4722366482869645213646 -> false
4722366482869645213647 -> false
4722366482869645213648 -> false
4722366482869645213649 -> false
4722366482869645213650 -> false
4722366482869645213651 -> true
4722366482869645213652 -> false
4722366482869645213653 -> false
4722366482869645213654 -> false
4722366482869645213655 -> false
4722366482869645213656 -> false
4722366482869645213657 -> false
4722366482869645213658 -> false
4722366482869645213659 -> false
4722366482869645213660 -> false
4722366482869645213661 -> false
4722366482869645213662 -> false
4722366482869645213663 -> true
4722366482869645213664 -> false
4722366482869645213665 -> false
4722366482869645213666 -> false
4722366482869645213667 -> false
4722366482869645213668 -> false
4722366482869645213669 -> false
4722366482869645213670 -> false
4722366482869645213671 -> false
4722366482869645213672 -> false
4722366482869645213673 -> true
4722366482869645213674 -> false
4722366482869645213675 -> false
4722366482869645213676 -> false
4722366482869645213677 -> false
4722366482869645213678 -> false
4722366482869645213679 -> false
4722366482869645213680 -> false
4722366482869645213681 -> false
4722366482869645213682 -> false
4722366482869645213683 -> false
4722366482869645213684 -> false
4722366482869645213685 -> false
4722366482869645213686 -> false
4722366482869645213687 -> false
4722366482869645213688 -> false
4722366482869645213689 -> true
4722366482869645213690 -> false
4722366482869645213691 -> false
4722366482869645213692 -> false
4722366482869645213693 -> false
4722366482869645213694 -> false
4722366482869645213695 -> false</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">extern crate primal;
<lang>
extern crate primal;
 
fn isqrt(n: usize) -> usize {
(n as f64).sqrt() as usize
//from https://en.wikipedia.org/wiki/Integer_square_root
let mut shift = 2;
let mut n_shifted = n >> shift;
while n_shifted != 0 && n_shifted != n {
shift += 2;
n_shifted = n >> shift;
}
shift -= 2;
let mut result = 0;
while shift >= 0 {
result = result << 1;
let candidate_result = result + 1;
if candidate_result*candidate_result <= n >> shift {
result = candidate_result;
}
shift -= 2;
}
result
}
 
fn is_semiprime (mut n : usize) -> bool {
let root = isqrt(n) + 1;
let primes1 = primal::Sieve::new(root);
let mut count = 0;
 
for i in primes1.primes_from(2).take_while(|x| *x < root) {
for i in primes1.primes_from(2).take_while(|&x| x < root) {
while n % i == 0 {
n = n /= i;
count += 1;
}
if n == 1 { break; }
} break;
if n != 1 { count += 1; }
count == 2 }
}
 
if n != 1 {
#[test]
count += 1;
fn test1 () {
}
assert_eq!((2..10).filter(|n| is_semiprime(*n)).count(),3);
count == 2
}
 
#[test]
fn test2 test1() {
assert_eq!((2..10010).filter(|&n| is_semiprime(*n)).count(),34 3);
}
 
#[test]
fn test3 test2() {
assert_eq!((2..1_000100).filter(|&n| is_semiprime(*n)).count(),299 34);
}
 
#[test]
fn test4 test3() {
assert_eq!((2..10_0001_000).filter(|&n| is_semiprime(*n)).count(),2_625 299);
}
 
#[test]
fn test5 test4() {
assert_eq!((2..100_00010_000).filter(|&n| is_semiprime(*n)).count(),23_378 2_625);
}
 
#[test]
fn test6 test5() {
assert_eq!((2..1_000_000100_000).filter(|&n| is_semiprime(*n)).count(),210_035 23_378);
}
</lang>
 
#[test]
fn test6() {
assert_eq!((2..1_000_000).filter(|&n| is_semiprime(n)).count(), 210_035);
}</syntaxhighlight>
functional version of is_semiprime:
<syntaxhighlight lang="rust">fn is_semiprime(n: usize) -> bool {
fn iter(x: usize, start: usize, count: usize) -> usize {
if count > 2 {return count} // break for semi_prime
let limit = (x as f64).sqrt().ceil() as usize;
match (start..=limit).skip_while(|i| x % i > 0).next() {
Some(v) => iter(x / v, v, count + 1),
None => if x < 2 { count }
else { count + 1 }
}
}
iter(n, 2, 0) == 2
}</syntaxhighlight>
{{out}}
<pre>
Line 2,090 ⟶ 3,232:
=={{header|Scala}}==
{{works with|Scala 2.9.1}}
<langsyntaxhighlight Scalalang="scala">object Semiprime extends App {
 
def isSP(n: Int): Boolean = {
Line 2,109 ⟶ 3,251:
1675 to 1681 foreach {i => println(i+" -> "+isSP(i))}
}</langsyntaxhighlight>
{{out}}
<pre>4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
Line 2,121 ⟶ 3,263:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func boolean: semiPrime (in var integer: n) is func
Line 2,147 ⟶ 3,289:
writeln(v <& " -> " <& semiPrime(v));
end for;
end func;</langsyntaxhighlight>
 
{{out}}
Line 2,160 ⟶ 3,302:
 
=={{header|Sidef}}==
Built-in:
<lang ruby>require('ntheory');
<syntaxhighlight lang="ruby">say is_semiprime(2**128 + 1) #=> true
say is_semiprime(2**256 - 1) #=> false</syntaxhighlight>
 
User-defined function, with trial division up to a given bound '''B''':
func is_semiprime(n) {
<syntaxhighlight lang="ruby">func is_semiprime(n, B=1e4) {
static nt = %S'ntheory';
if (var p = [nt.trial_factor(n, 500)]) {
return false if (p.len > 2);
return !!nt.is_prime(p[1]) if (p.len == 2);
}
[nt.factor(n)].len == 2;
}
 
with (n.trial_factor(B)) { |f|
say [2,4,99,100,1679,32768,1234567,9876543,900660121].grep{ is_semiprime(_) }</lang>
return false if (f.len > 2)
return f.all { .is_prime } if (f.len == 2)
}
 
n.factor.len == 2
}
 
say [2,4,99,100,1679,32768,1234567,9876543,900660121].grep(is_semiprime)</syntaxhighlight>
{{out}}
<pre>
Line 2,180 ⟶ 3,325:
=={{header|Swift}}==
 
<langsyntaxhighlight lang="swift">import Foundation
 
func primes(n: Int) -> AnyGenerator<Int> {
Line 2,216 ⟶ 3,361:
}
return false
}</langsyntaxhighlight>
 
=={{header|Tcl}}==
{{tcllib|math::numtheory}}
<langsyntaxhighlight lang="tcl">package require math::numtheory
 
proc isSemiprime n {
Line 2,243 ⟶ 3,388:
puts "NOT a semiprime"
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 2,252 ⟶ 3,397:
1679 is ... a semiprime
1680 is ... NOT a semiprime
</pre>
 
== {{header|TypeScript}} ==
{{trans|ASIC}}
<syntaxhighlight lang="javascript">
// Semiprime
 
function primeFactorsCount(n: number): number {
n = Math.abs(n);
var count = 0; // Result
if (n >= 2)
for (factor = 2; factor <= n; factor++)
while n % factor == 0) {
count++;
n /= factor;
}
return count;
}
 
const readline = require('readline').createInterface({
input: process.stdin, output: process.stdout
});
 
readline.question('Enter an integer: ', sn => {
var n = parseInt(sn);
console.log(primeFactorsCount(n) == 2 ?
"It is a semiprime." : "It is not a semiprime.");
readline.close();
});
</syntaxhighlight>
{{out}}
<pre>
Enter an integer: 33
It is a semiprime.
</pre>
<pre>
Enter an integer: 60
It is not a semiprime.
</pre>
 
=={{header|Wren}}==
{{trans|Go}}
<syntaxhighlight lang="wren">var semiprime = Fn.new { |n|
if (n < 3) return false
var nf = 0
for (i in 2..n) {
while (n%i == 0) {
if (nf == 2) return false
nf = nf + 1
n = (n/i).floor
}
}
return nf == 2
}
 
for (v in 1675..1680) {
System.print("%(v) -> %(semiprime.call(v) ? "is" : "is not") semi-prime")
}</syntaxhighlight>
 
{{out}}
<pre>
1675 -> isn't semi-prime
1676 -> isn't semi-prime
1677 -> isn't semi-prime
1678 -> is semi-prime
1679 -> is semi-prime
1680 -> isn't semi-prime
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func Semiprime(N); \Return 'true' if N is semiprime
int N, F, C;
[C:= 0; F:= 2;
repeat if rem(N/F) = 0 then
[C:= C+1;
N:= N/F;
]
else F:= F+1;
until F > N;
return C = 2;
];
 
int N;
[for N:= 1 to 100 do
if Semiprime(N) then
[IntOut(0, N); ChOut(0, ^ )];
]</syntaxhighlight>
 
{{out}}
<pre>
4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95
</pre>
 
=={{header|zkl}}==
{{trans|C}}
<langsyntaxhighlight lang="zkl">fcn semiprime(n){
reg f = 0;
p:=2; while(f < 2 and p*p <= n){
Line 2,263 ⟶ 3,499:
}
return(f + (n > 1) == 2);
}</langsyntaxhighlight>
{{out}}
<pre>
Chkas
2,054

edits

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