def main():
n = 1
for p in prime_generator():
next_n = n * p
if next_n > 10**6:
break
n = next_n
print(n)
def problem(self):
prime_gen = prime_generator()
prime = prime_gen.next()
answer = 0
while prime < 2e6:
answer += prime
prime = prime_gen.next()
return answer
def problem_007(n_prime: int = 10001) -> int:
"""
Straightforward solution using prime_generator. Iterate over prime numbers up to n_prime.
- O(1) space-complexity
"""
for i, num in prime_generator():
if i == n_prime:
return num
def main():
prod = 1
a, b = 15499, 94744
for p in prime_generator():
prod *= p
if b * euler_totient(prod) < a * (prod - 1):
upper_bound = prod
lower_bound = prod // p
break
for candidate in range(lower_bound, upper_bound + 1, lower_bound):
if b * euler_totient(candidate) < a * (candidate - 1):
print(candidate)
break
def problem_010(upper_bound: int = 2_000_000) -> int:
"""
Straightforward solution using prime_generator.
- O(n^(3/2)) time-complexity
- O(1) space-complexity
"""
result = 0
for i, num in prime_generator():
if num >= upper_bound:
break
result += num
return result
def calculate(number_list):
"""Calculates the type of number.
If the sum of their divisors is exactly the number the it is perfect, else if the sum is lower than the number it is deficient
and if the sum is greater than the number it is an abundant number.
:param number_list: list with the numbers to calculate
:returns: nothing, it will debug the number categorization
"""
primes_list = prime_generator(prime_seed)
for number in number_list:
logger.debug("Calculating for %s", number)
validnumber = toValidNumber(number)
if validnumber < 0:
continue
divisors = calculate_divisors(validnumber, primes_list);
logger.debug("Divisors are %s", divisors)
total = sum(divisors)
logger.debug("Sum is %s", total)
if total == validnumber:
logger.info ("Number %s is perfect", validnumber)
elif total < validnumber:
logger.info("Number %s is deficient", validnumber)
else:
logger.info("Number %s is abundant", validnumber)
def problem(self):
prime_gen = prime_generator()
for i in xrange(1, 10001):
prime_gen.next()
return prime_gen.next()
def nth_prime(n):
upper = nth_prime_upper_bound(n)
for i, p in enumerate(prime_generator(upper), 1):
if i == n:
return p
def prime_n(n):
for a, i in enumerate(prime_generator()):
if a == n:
return i
#! python3
"""Find the lowest sum for a set of five primes for which any two primes
concatenate to produce another prime."""
from time import time
import sys
from os.path import dirname
sys.path.insert(0, dirname(dirname(__file__)))
from utils import is_prime, prime_generator
t0 = time()
pairs = dict()
for i in map(str, prime_generator()): # It takes ~45 seconds
own = set(j for j in pairs
if is_prime(int(i + j)) and is_prime(int(j + i)))
for j in own:
pj = pairs[j] & own
for k in pj:
pk = pairs[k] & pj
for l in pk:
print(".", end="", flush=True)
for m in pairs[l] & pk:
print("\n\n")
print(i, j, k, l, m)
print(sum(map(int, (i, j, k, l, m))))
print("In %d seconds" % (time() - t0))
raise SystemExit
pairs[i] = own
def sum_of_primes_below(n):
n = int(n)
return sum(prime_generator(n - 1))
def problem(self):
prime_gen = prime_generator()
for i in xrange(1, 10001):
prime_gen.next()
return prime_gen.next()
def test_prime_generator():
gen = utils.prime_generator()
assert 2 == next(gen)
assert 3 == next(gen)
assert 5 == next(gen)
assert 7 == next(gen)
#! python3
"""Find the smallest prime which, by replacing part of the number
(not necessarily adjacent digits) with the same digit,
is part of an eight prime value family."""
import sys
from os.path import dirname
sys.path.insert(0, dirname(dirname(__file__)))
from utils import is_prime, prime_generator
alreadyTested = set()
for i in prime_generator():
alreadyTested.add(i)
s = str(i)
for l in set(s):
if s.count(l) == 1: # If there is only one there will exist a max of 7
continue # primes and the other 3 will be multiples of 3
n = 0
for p in range(s.startswith(l), 10):
permutation = int(s.replace(l, str(p)))
if is_prime(permutation):
alreadyTested.add(permutation)
n += permutation in alreadyTested
if n == 8:
break
else:
continue
break
print(i)