Python Challenge - Semi-Prime Numbers

This community-built FAQ covers the “Semi-Prime Numbers” code challenge in Python. You can find that challenge here, or pick any challenge you like from our list.

Top Discussions on the Python challenge Semi-Prime Numbers

There are currently no frequently asked questions or top answers associated with this challenge – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this challenge. Ask a question or post a solution by clicking reply (reply) below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this challenge, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

Join the Discussion. Help a fellow learner on their journey.

Ask or answer a question about this exercise by clicking reply (reply) below!
You can also find further discussion and get answers to your questions over in #get-help.

Agree with a comment or answer? Like (like) to up-vote the contribution!

Need broader help or resources? Head to #get-help and #community:tips-and-resources. If you are wanting feedback or inspiration for a project, check out #project.

Looking for motivation to keep learning? Join our wider discussions in #community

Learn more about how to use this guide.

Found a bug? Report it online, or post in #community:Codecademy-Bug-Reporting

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

def semi_prime_count(n):
count = 0
for i in range(4, n):
facts = numFactors(i)
for fact in facts:
if isPrime(fact[0]) and isPrime(fact[1]):
count += 1
return count

def numFactors(n):
newlst =
num = int(n**0.5)+1
for i in range(2, num):
if n % i == 0:
other = n // i
newlst.append((i, other))
return newlst

def isPrime(n):
if n == 1:
return False
if n == 2:
return True
num = int(n ** 0.5) + 1
for i in range(2, num):
if n % i == 0:
return False
return True


1 Like
import numpy as np import math def semi_prime_count(n): list_of_primes = [n for n in range(2, n + 1) if is_prime(n)] list_of_semi_primes = [] for x in list_of_primes: for y in list_of_primes: if x * y < n and x * y not in list_of_semi_primes: list_of_semi_primes.append(x*y) return len(list_of_semi_primes) def is_prime(n): if n == 2: return True for i in range(2, math.ceil(np.sqrt(n)) + 1): if n % i == 0: return False return True semi_prime_count(10)
def semi_prime_count(n): def isprime(i): n= int(i/2) while n>=2: if i%n == 0 : return False n = n-1 return True def is_product_two(number): i = 2 count = [] while i<=number: if number%i == 0 and isprime(i): count.append(i) number = int(number/i) else: i += 1 if len(count)==2 or (len(count)==1 and count[0]*count[0]==number): print("True") print(count) return True print("False") print(count) return False count = 0 for i in range (1, n): if is_product_two(i): count +=1 return count print(semi_prime_count(10))

def semi_prime_count(n):
count = 0
for i in range(n):
if compare_divisors(i):
count += 1
return count

#Checks if there is at least one pair of prime numbers that have n as the product
def compare_divisors(n):
primes = get_primes(n)
for i in primes:
if n / i in primes:
return True
return False

#Returns a list of prime numbers up to (but not including) n
def get_primes(n):
primes = list()
#Variable i will be the possible prime number, while j is the iterating number that will check for every possible divisor between 2 and i
for i in range(1, n):
isPrime = True
for j in range(i):
if j > 1 and i % j == 0:
isPrime = False
if isPrime:
list.append(primes, i)
return primes


Got it down to 0.1 seconds to find the answer for 1000000 with no additional modules which is quite good. One can probably improve the Sieve with numpy and other techniques.
Also please highlight the non-inclusive in the question, since most of my time working on this challenge was spend figuring out why my solutions were wrong because of me not reading correctly.

def primes(n): num = [i for i in range(1,n,2)] for p in range(1,int(len(num)/2)): if num[p] == 0: continue for q in range(p,len(num),2*p+1): if q == p: continue num[q] = 0 num[0] = 2 return [num[i] for i in range(len(num)) if num[i] != 0] def semi_prime_count(n): n -= 1 if n < 4: return 0 l = primes(int(n/2)+1) counter = 0 for p in range(len(l)): for q in range(p,len(l)): if l[p] * l[q] > n: break counter += 1 return counter print(semi_prime_count(1000000))
def is_prime(n): #first defining a function that identifies prime numbers (returns true/false) if n == 1: return False else: for i in range(2, n - 1): if n % i == 0: return False return True def semi_prime_count(n): l = [] #first we need an empty list (len of l will be returned) for i in range(1, n): #checking for every number between 1 and n j = 1 #initializing index for while-loop (can be removed if done in for-loop) while j < i: #checking every number between 1 and i if is_prime(j) and is_prime(int(i/j)) and i/j == int(i/j): #i is a semi prime number if these conditions are met (notice that is_prime only accepts integers, so to avoid rounding mistakes we have to add the third condition) l.append(i) break else: j += 1 #no infinite while loops here! return len(l) #the length of the list is the number of semi prime numbers we found in range(n) print(semi_prime_count(100))

I might be able to optimize prime number finder better so it can search for larger n but… oh well

def prime_number(n): # prime number list finder if n < 2: return [] # if n >= 2, 2 is a prime number for all numbers <= n) listy = [2] for i in range(3, n+1): # for all numbers from 3 to n for j in range(0, len(listy)): # going through the list of primes (listy) if i % listy[j] == 0: # ignore if not prime break if j == len(listy)-1: # if not divisible by all prime numbers in the list, it is a prime number and gets appended to listy. listy.append(i) return listy def semi_prime_count(n): primes = prime_number(n) sp = [] answer = [] counter = 0 # ignores cases where there are less than 2 primes. if len(primes) < 2: return 0 # take the product of 2 prime numbers and append to sp for i in range(0,len(primes)): for j in range(0, len(primes)): sp.append(primes[i]*primes[j]) # removing duplicates and sorting list by converting to dict, then to sorted list sp = sorted(list(dict.fromkeys(sp))) for k in sp: # for all elements in sp if k >= n: # find the point which k >= n, ignore the rest. (answer is the answer) break answer.append(k) # return len(answer) return len(answer) print(semi_prime_count(3000))
from itertools import product def is_prime(n): is_prime = True if n == 0 or n == 1: return False if n == 2: return True for i in range(2, (n//2)+1): if n % i == 0: is_prime = False break return is_prime def find_primes(n): primes = list() for num in range(n): if is_prime(num): primes.append(num) return primes def semi_prime_count(n): primes = find_primes(n) products = set(tuple(x) for x in list(map(sorted, product(primes, repeat=2)))) count = 0 for x in range(2, n): for t in products: if (t[0]*t[1]) == x: count += 1 return count print(semi_prime_count(10))
def is_prime(n): return not any(n % x == 0 for x in range(2, n)) def factor_pairs(n): return [(x, y) for x in range(1, n) for y in range(1, n) if x * y == n] def semi_prime_count(n): semi_primes = 0 for _ in range(1, n): primes = [] if is_prime(_): continue for x, y in factor_pairs(_): if x in primes or y in primes: continue if all([is_prime(x), is_prime(y)]): semi_primes += 1 primes.append(x) primes.append(y) continue return semi_primes print(semi_prime_count(10))

def semi_prime_count(n):
primes =
for num in range(n):
if num > 1:
for i in range(2,num+1):
if num%i == 0:
primes = list(set(primes))

semi_prime =
for base in range(len(primes)-1):
num1 = primes[base]
for ind in range(base, len(primes)):
mult = num1 * primes[ind]
if mult < n:

return len(semi_prime)


I used the prime factorization algorithm for this.
I put checking whether a number is semi-prime as a separate function.

from math import sqrt, ceil, floor

def is_semi_prime(n):
  if (n < 4):
    return False
  prime_factors = []
  d = 2   # first possible prime divisor is 2
  while n > 1 and d <= n:
      if (n % d) == 0:  
        prime_factors.append(d) # if d is a factor, add it to the list
        n = n // d  # divide by d if d is a factor
      else: # if d is not a factor, go to next possible divisor 
        d += 1 
  return len(prime_factors) == 2 # check if have 2 prime factors

def semi_prime_count(n):
  count = 0
  for x in range(1, n):
    if (is_semi_prime(x)):
      count += 1
  return count

def is_prime(n): if n == 1: return False #added time efficiencies if n == 2 or n == 3: return True if n % 2 == 0 or n % 3 == 0: return False for i in range(2,n): if n % i == 0: return False return True def semi_prime_count(n): count = 0 seen = set() for num in range(n): for i in range(2,num): if num not in seen and is_prime(i) and num % i == 0 and is_prime(num//i): seen.add(num) count += 1 return count semi_prime_count(10)
def semi_prime_count(n): primes = [] for i in range(2, n + 1): counter = 0 for k in range(1, i + 1): if i % k == 0: counter += 1 if counter == 2: primes.append(i) new_list = [num for num in range(n+1)] newer_list = [new_list[i] for i in range(2, len(new_list)-1) if new_list[i] not in primes] counter1 = 0 for num in newer_list: for i in range(len(primes)): for k in range(i+1, len(primes)): if num == primes[i]*primes[k]: counter1 += 1 if num == primes[i]**2: counter1 +=1 return counter1 print(semi_prime_count(11))