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)))
