def e12(): triangle = lambda n: n*(n+1)/2 primes = primes_up_to(10**5) current_counter = 1 while num_divisors( triangle( current_counter ), primes) <= 500: current_counter += 1 return triangle( current_counter )
def candidates(): bound = 10000 primes = utils.primes_up_to(bound) for p in primes: for i in range(1, bound - p): triple = (p, p + i, p + 2 * i) if all(q in primes for q in triple): yield triple
from utils import primes_up_to def truncate_number(number): digits = str(number) for i in range(1, len(digits)): yield int(digits[i:]) yield int(digits[:i]) primes = primes_up_to(1000000) truncatable_primes = (prime for prime in primes if prime > 10 and all(n in primes for n in truncate_number(prime))) answer = sum(truncatable_primes) print(answer)
import utils primes = utils.primes_up_to(100000) double_squares = set(2 * n * n for n in range(1, 10000)) def search(n): return any(n - p in double_squares for p in primes) print(min(i for i in range(3, 100000, 2) if i not in primes and not search(i)))
def e10(): return sum(primes_up_to(2 * 10**6))
import utils prime_set = utils.primes_up_to(1000000) def is_circular_prime(n): s = str(n) return all (r in prime_set for i in range(len(s)) for r in (int(s[i:] + s[0:i]),)) print (sum(1 for i in range(2, 1000000) if is_circular_prime(i)))
from utils import is_pandigital, is_prime_naive, primes_up_to # note that 3, 8 and 9-digit pandigitals are all divisible by 3 # so biggest is 7 digits at most primes = primes_up_to(7654321 + 1) print(max(p for p in primes for s in (str(p), ) if is_pandigital(s, len(s))))
def e3(): return max(factorize_into_primes(600851475143, primes_up_to(10**6)))
import utils primes = set(utils.primes_up_to(10000 - 0)) def consecutive_primes(a, b): n = 0 while n**2 + a * n + b in primes: n += 1 return n print(consecutive_primes(1, 41)) print(consecutive_primes(-79, 1601)) (a, b) = max(((a, b) for a in range(-999, 1000) for b in range(-1000, 1001)), key=lambda pair: consecutive_primes(pair[0], pair[1])) print(a * b)
import utils BOUND = 9999 N = 5 prime_set = utils.primes_up_to(BOUND) prime_list = list(prime_set) prime_list.sort() prime_list_str = [str(n) for n in prime_list] prime_set_str = set(prime_list_str) def recurse(s, i0): if len(s) >= N: return s for i in range(i0, len(prime_list_str)): p1 = prime_list_str[i] # hybrid strategy: enumerate primes to loop over, but make check explicitly # so we don't have to generate _all_ the primes because the space of primes generated # by concatenation is smaller if all( utils.is_prime_naive(int(p_concat)) for p0 in s for p_concat in (p0 + p1, p1 + p0)): new_s = s + [p1] x = recurse(new_s, i + 1) # print(new_s) if x: # stop looking early if we find something return x
import utils bound = 1000000 primes = utils.primes_up_to(bound) primes_list = list(primes) primes_list.sort() def num_in_family(s, d): return sum(1 for i in range(0, 10) for s2 in (s.replace(d, str(i)), ) if int(s2) in primes and s2[0] != "0") def condition(p): s = str(p) distinct_digits = list(s) return max(num_in_family(s, d) for d in distinct_digits) >= 8 for p in primes: if condition(p): print(p) break
from utils import primes_up_to print (sum(primes_up_to(2000000)))
from itertools import chain, combinations, permutations from utils import primes_up_to primes = primes_up_to(9999) def digit_permutations(integer): digits = str(integer) return { int(''.join(permutation)) for permutation in permutations(digits) if '0' not in permutation } def equally_separated(items): sequence = sorted(items) differences = { y - x for x, y in zip(sequence, sequence[1:]) } return len(differences) == 1 prime_permutations = ( digit_permutations(n) & primes for n in primes )
import utils upper_bound = 1000000 prime_set = utils.primes_up_to(upper_bound) def is_truncatable_prime(n): s = str(n) return all( int(s[0:i]) in prime_set and int(s[i:]) in prime_set for i in range(1, len(s))) print(sum(p for p in prime_set if p >= 10 and is_truncatable_prime(p)))