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)