-1  isn't semiprime.
       0  isn't semiprime.
       1  isn't semiprime.
       2  isn't semiprime.
       3  isn't semiprime.
       4     is semiprime.
       5  isn't semiprime.
       6     is semiprime.
       7  isn't semiprime.
       8  isn't semiprime.
       9     is semiprime.
      10     is semiprime.
      11  isn't semiprime.
      12  isn't semiprime.
      13  isn't semiprime.
      14     is semiprime.
      15     is semiprime.
      16  isn't semiprime.
      17  isn't semiprime.
      18  isn't semiprime.
      19  isn't semiprime.
      20  isn't semiprime.
      21     is semiprime.
      22     is semiprime.
      23  isn't semiprime.
      24  isn't semiprime.
      25     is semiprime.
      26     is semiprime.
      27  isn't semiprime.
      28  isn't semiprime.
      29  isn't semiprime.
      30  isn't semiprime.
      31  isn't semiprime.
      32  isn't semiprime.
      33     is semiprime.
      34     is semiprime.
      35     is semiprime.
      36  isn't semiprime.
      37  isn't semiprime.
      38     is semiprime.
      39     is semiprime.
      40  isn't semiprime.
      41  isn't semiprime.
      42  isn't semiprime.
      43  isn't semiprime.
      44  isn't semiprime.
      45  isn't semiprime.
      46     is semiprime.
      47  isn't semiprime.
      48  isn't semiprime.
      49     is semiprime.
      50  isn't semiprime.
      51     is semiprime.
      52  isn't semiprime.
      53  isn't semiprime.
      54  isn't semiprime.
      55     is semiprime.
      56  isn't semiprime.
      57     is semiprime.
      58     is semiprime.
      59  isn't semiprime.
      60  isn't semiprime.
      61  isn't semiprime.
      62     is semiprime.
      63  isn't semiprime.
      64  isn't semiprime.
      65     is semiprime.
      66  isn't semiprime.
      67  isn't semiprime.
      68  isn't semiprime.
      69     is semiprime.
      70  isn't semiprime.
      71  isn't semiprime.
      72  isn't semiprime.
      73  isn't semiprime.
      74     is semiprime.
      75  isn't semiprime.
      76  isn't semiprime.
      77     is semiprime.
      78  isn't semiprime.
      79  isn't semiprime.
      80  isn't semiprime.
      81  isn't semiprime.
      82     is semiprime.
      83  isn't semiprime.
      84  isn't semiprime.
      85     is semiprime.
      86     is semiprime.
      87     is semiprime.
      88  isn't semiprime.
      89  isn't semiprime.
      90  isn't semiprime.
      91     is semiprime.
      92  isn't semiprime.
      93     is semiprime.
      94     is semiprime.
      95     is semiprime.
      96  isn't semiprime.
      97  isn't semiprime.
      98  isn't semiprime.
      99  isn't semiprime.
     100  isn't semiprime.
     101  isn't semiprime.
     102  isn't semiprime.
     103  isn't semiprime.
     104  isn't semiprime.
     105  isn't semiprime.
     106     is semiprime.

found  35  semiprimes.

```

{{out|output|text=  when using the input of:    99888111555   99888111600 }}

(Shown at    '''5/6'''    size.)
     99888111555  isn't semiprime.
     99888111556  isn't semiprime.
     99888111557  isn't semiprime.
     99888111558  isn't semiprime.
     99888111559  isn't semiprime.
     99888111560  isn't semiprime.
     99888111561  isn't semiprime.
     99888111562  isn't semiprime.
     99888111563     is semiprime.
     99888111564  isn't semiprime.
     99888111565  isn't semiprime.
     99888111566     is semiprime.
     99888111567  isn't semiprime.
     99888111568  isn't semiprime.
     99888111569     is semiprime.
     99888111570  isn't semiprime.
     99888111571  isn't semiprime.
     99888111572  isn't semiprime.
     99888111573  isn't semiprime.
     99888111574     is semiprime.
     99888111575  isn't semiprime.
     99888111576  isn't semiprime.
     99888111577  isn't semiprime.
     99888111578     is semiprime.
     99888111579  isn't semiprime.
     99888111580  isn't semiprime.
     99888111581  isn't semiprime.
     99888111582  isn't semiprime.
     99888111583  isn't semiprime.
     99888111584  isn't semiprime.
     99888111585  isn't semiprime.
     99888111586  isn't semiprime.
     99888111587  isn't semiprime.
     99888111588  isn't semiprime.
     99888111589  isn't semiprime.
     99888111590  isn't semiprime.
     99888111591     is semiprime.
     99888111592  isn't semiprime.
     99888111593     is semiprime.
     99888111594  isn't semiprime.
     99888111595  isn't semiprime.
     99888111596  isn't semiprime.
     99888111597  isn't semiprime.
     99888111598  isn't semiprime.
     99888111599  isn't semiprime.
     99888111600  isn't semiprime.

found  7  semiprimes.

```


===version 3, with memoization===
This REXX version is overt 20% faster than version 2   (when in the   ''millions''   range).

If the 2nd argument   ('''top''')   is negative   (it's absolute value is used),   individual numbers in the range aren't shown, but the   ''count''   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.

```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.*/
if top=='' | top==","  then top=bot              /*maybe define a range of numbers.     */
tell= bot=>0  &  top=>0                          /*should results be shown to the term? */
w=max(length(bot), length(top))                  /*obtain the maximum width of numbers. */
!.=;  !.2=1; !.3=1; !.5=1; !.7=1; !.11=1; !.13=1; !.17=1; !.19=1; !.23=1; !.29=1;  !.31=1
numeric digits max(9, w)                         /*ensure there're enough decimal digits*/
#=0                                              /*initialize number of semiprimes found*/
             do n=abs(bot)  to abs(top)          /*show results for a range of numbers. */
             ?=isSemiPrime(n);      #=#+?        /*Is N a semiprime?; Maybe bump counter*/
             if tell  then say right(n,w)  right(word("isn't" 'is', ?+1), 6)  'semiprime.'
             end   /*n*/
say
if bot\==top  then say 'found '   #   " semiprimes."
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
isPrime: procedure expose !.;  parse arg x;     if x<2  then return 0  /*number too low?*/
         if !.x==1                                      then return 1  /*a known prime. */
         if x// 2==0  then return 0;    if x//3==0      then return 0  /*÷ by  2;÷by  3?*/
         parse var x '' -1 _;           if _==5         then return 0  /*last digit a 5?*/
         if x// 7==0  then return 0;    if x//11==0     then return 0  /*÷ by  7;÷by 11?*/
         if x//13==0  then return 0;    if x//17==0     then return 0  /*÷ by 13;÷by 17?*/
         if x//19==0  then return 0;    if x//23==0     then return 0  /*÷ by 19;÷by 23?*/
           do j=29  by 6  until j*j>x;  if x//j==0      then return 0  /*not a prime.   */
                                        if x//(j+2)==0  then return 0  /* "  "   "      */
           end   /*j*/
         !.x=1;                return 1          /*indicate that  X  is a prime number. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
isSemiPrime: procedure expose !.;  parse arg x;          if x<4  then return 0

                           do i=2  for 2;  if x//i==0  then if isPrime(x%i)  then return 1
                                                                             else return 0
                           end   /*i*/
                                                                             /*    ___  */
               do   j=5  by 6  until j*j>x                                   /* > √ x  ?*/
                 do k=j  by 2  for 2;  if x//k==0  then  if isPrime(x%k)  then return 1
                                                                          else return 0
                 end   /*k*/                     /* [↑]  see if 2nd factor is prime or ¬*/
               end     /*j*/                     /* [↑]  J is never a multiple of three.*/
         return 0
```

{{out|output|text=  is identical to the previous REXX version.}}




## Ring


```ring

prime = 1679
decomp(prime)

func decomp nr
x = ""
sum = 0
for i = 1 to nr
    if isPrime(i) and nr % i = 0
       sum = sum + 1
       x = x + string(i) + " * " ok
    if i = nr and sum = 2
       x2 = substr(x,1,(len(x)-2))
       see string(nr) + " = " + x2 + "is semiprime" + nl
    but i = nr and sum != 2 see string(nr) + " is not semiprime" + nl ok
next

func isPrime n
     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

```



## Ruby


```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.sum(&:last) == 2
  end
end

p 1679.semi_prime? # true
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]

```



## Rust

extern crate primal;

fn isqrt(n: usize) -> usize {
    (n as f64).sqrt() as usize
}

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) {
        while n % i == 0 {
            n /= i;
            count += 1;
        }
        if n == 1 {
            break;
        }
    }

    if n != 1 {
        count += 1;
    }
    count == 2
}

#[test]
fn test1() {
    assert_eq!((2..10).filter(|&n| is_semiprime(n)).count(), 3);
}

#[test]
fn test2() {
    assert_eq!((2..100).filter(|&n| is_semiprime(n)).count(), 34);
}

#[test]
fn test3() {
    assert_eq!((2..1_000).filter(|&n| is_semiprime(n)).count(), 299);
}

#[test]
fn test4() {
    assert_eq!((2..10_000).filter(|&n| is_semiprime(n)).count(), 2_625);
}

#[test]
fn test5() {
    assert_eq!((2..100_000).filter(|&n| is_semiprime(n)).count(), 23_378);
}

#[test]
fn test6() {
    assert_eq!((2..1_000_000).filter(|&n| is_semiprime(n)).count(), 210_035);
}
```


{{out}}

```txt

running 6 tests
test test1 ... ok
test test2 ... ok
test test3 ... ok
test test4 ... ok
test test5 ... ok
test test6 ... ok

test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

```



## Scala

{{works with|Scala 2.9.1}}

```Scala
object Semiprime extends App {

  def isSP(n: Int): Boolean = {
    var nf: Int = 0
    var l = n
    for (i <- 2 to l/2) {
      while (l % i == 0) {
        if (nf == 2) return false
        nf +=1
        l /= i
      }
    }
    nf == 2
  }

  (2 to 100) filter {isSP(_) == true} foreach {i => print("%d ".format(i))}
  println
  1675 to 1681 foreach {i => println(i+" -> "+isSP(i))}

}
```

{{out}}

```txt
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 -> false
1676 -> false
1677 -> false
1678 -> true
1679 -> true
1680 -> false
1681 -> true
```



## Seed7


```seed7
$ include "seed7_05.s7i";

const func boolean: semiPrime (in var integer: n) is func
  result
    var boolean: isSemiPrime is TRUE;
  local
    var integer: p is 2;
    var integer: f is 0;
  begin
    while f < 2 and p**2 <= n do
      while n rem p = 0 do
        n := n div p;
        incr(f);
      end while;
      incr(p);
    end while;
    isSemiPrime := f + ord(n > 1) = 2;
  end func;

const proc: main is func
  local
    var integer: v is 0;
  begin
    for v range 1675 to 1680 do
      writeln(v <& " -> " <& semiPrime(v));
    end for;
  end func;
```


{{out}}

```txt

1675 -> FALSE
1676 -> FALSE
1677 -> FALSE
1678 -> TRUE
1679 -> TRUE
1680 -> FALSE

```



## Sidef

Built-in:

```ruby
say is_semiprime(2**128 + 1)   #=> true
say is_semiprime(2**256 - 1)   #=> false
```


User-defined function, with trial division up to a given bound '''B''':

```ruby
func is_semiprime(n, B=1e4) {

    with (n.trial_factor(B)) { |f|
        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)
```

{{out}}

```txt

[4, 1679, 1234567, 900660121]

```



## Swift



```swift
import Foundation

func primes(n: Int) -> AnyGenerator {

  var (seive, i) = ([Int](0.. Bool {
  let g = primes(n)
  while let first = g.next() {
    if n % first == 0 {
      if first * first == n {
        return true
      } else {
        while let second = g.next() {
          if first * second == n { return true }
        }
      }
    }
  }
  return false
}
```



## Tcl

{{tcllib|math::numtheory}}

```tcl
package require math::numtheory

proc isSemiprime n {
    if {!($n & 1)} {
	return [::math::numtheory::isprime [expr {$n >> 1}]]
    }
    for {set i 3} {$i*$i < $n} {incr i 2} {
	if {$n / $i * $i != $n && [::math::numtheory::isprime $i]} {
	    if {[::math::numtheory::isprime [expr {$n/$i}]]} {
		return 1
	    }
	}
    }
    return 0
}

for {set n 1675} {$n <= 1680} {incr n} {
    puts -nonewline "$n is ... "
    if {[isSemiprime $n]} {
	puts "a semiprime"
    } else {
	puts "NOT a semiprime"
    }
}
```

{{out}}

```txt

1675 is ... a semiprime
1676 is ... NOT a semiprime
1677 is ... a semiprime
1678 is ... a semiprime
1679 is ... a semiprime
1680 is ... NOT a semiprime

```



## zkl

{{trans|C}}

```zkl
fcn semiprime(n){
   reg f = 0;
   p:=2; while(f < 2 and p*p <= n){
      while(0 == n % p){ n /= p; f+=1; }
      p+=1;
   }
   return(f + (n > 1) == 2);
}
```

{{out}}

```txt

[1675 .. 1681].filter(semiprime).println();
L(1678,1679,1681)

```