def get_candidates(limit):
"""Returns a list of candidate values for a and b. a and b should always
be 1, -1, a prime or a negative prime.
"""
candidate_primes = list(takewhile(lambda n: n <= limit, gen_primes()))
return [1] + candidate_primes + [-1] + [-x for x in candidate_primes]
def solve(limit, search_delta=0.3):
lower = int(sqrt(limit) * (1 - search_delta))
upper = int(sqrt(limit) * (1 + search_delta))
primes = list(ibetween(gen_primes(), lower, upper))
info(f"Searching using prime factors {lower} < p < {upper}")
result_n, result_q = None, inf
for factors in combinations(primes, 2):
n = prod(factors)
if n > limit:
continue
phi_n = phi(n)
if is_permutation(n, phi_n):
q = n / phi_n
if q < result_q:
result_n, result_q = n, q
info(f"n = {n}\tphi(n) = {phi_n}\tn/phi(n) = {q}")
return result_n
def solve(limit):
"""Returns the sum of all primes below limit.
>>> solve(10)
17
"""
return sum(takewhile(lambda p: p < limit, gen_primes()))
def solve():
four_digit_primes = set(ibetween(gen_primes(), LOWER, UPPER))
for prime in four_digit_primes:
prime_permutations = digit_permutations(prime) & four_digit_primes
terms_of_three = combinations(prime_permutations, 3)
for terms in terms_of_three:
if equidistant(terms):
result = join_digits(terms)
if result != EXCLUDE:
return result
def largest_prime_factor(n):
"""
>>> largest_prime_factor(13195)
29
"""
largest_factor = 0
limit = sqrt(n)
for p in takewhile(lambda p: p < limit, gen_primes()):
if n % p == 0:
largest_factor = p
return largest_factor
def solve(target):
truncatable_primes = set()
primes = dropwhile(lambda p: p in EXCLUDE, gen_primes())
for p in primes:
if len(truncatable_primes) == target:
break
truncations_p = truncations(p)
if all(map(is_prime, truncations_p)):
info(f"{p} = {truncations_p}")
truncatable_primes.add(p)
return sum(truncatable_primes)
def solve(group_size=4, limit=1000):
primes = list(takewhile(lambda n: n < limit, gen_primes()))
pairs = prime_pairs(primes)
lowest_sum = math.inf
for prime in primes:
groups = make_groups(
frozenset([prime]), pairs[prime], group_size, pairs)
for group in groups:
if sum(group) < lowest_sum:
lowest_sum = sum(group)
return lowest_sum
def solve(limit):
"""Returns the numbers of circular primes below limit.
>>> solve(100)
13
"""
primes = takewhile(lambda n: n < limit, gen_primes())
count = 0
for p in primes:
if all(map(is_prime, rotations(p))):
info(p)
count += 1
return count
def solve(target=5):
n = 0
ways = 0
prime = gen_primes()
primes = (next(prime), )
while ways < target:
n += 1
while primes[0] < n:
primes = (next(prime), ) + primes
ways = partitions(n, primes)
return n
def solve():
masks = defaultdict(set)
for prime in gen_primes():
digits = str(prime)
for masked_digit in set(digits):
masked = digits.replace(masked_digit, "x")
for replaced_digit in range(10):
candidate = int(masked.replace("x", str(replaced_digit)))
# Discard leading zeros
if len(str(candidate)) != len(masked):
continue
if is_prime(candidate):
masks[masked].add(candidate)
if len(masks[masked]) >= TARGET:
return min(masks[masked])
def solve(limit=50):
numbers = set()
primes = list(takewhile(lambda p: p < sqrt(limit), gen_primes()))
for a in primes:
a2 = a**2
for b in primes:
b3 = b**3
ab = a2 + b3
for c in primes:
c4 = c**4
abc = ab + c4
if abc >= limit:
break
info(f"{abc} = {a}^2 + {b}^3 + {c}^4")
numbers.add(abc)
return len(numbers)
import itertools
from common.primes import gen_primes, is_prime
LIMIT = 1_000_000
primes = list(itertools.takewhile(lambda p: p < LIMIT, gen_primes()))
longest = 0
result = 0
for start in range(0, len(primes)):
prime_slice = primes[start:]
total = 0
for length, prime in enumerate(prime_slice, 1):
total += prime
if total >= LIMIT:
break
if length > longest and is_prime(total):
longest = length
result = total
print(result)
def solve(target):
return nth(gen_primes(), target)
import itertools
from common.primes import gen_primes, is_prime
limit = 10_000
PRIMES = list(itertools.takewhile(lambda n: n < limit, gen_primes()))
def is_twice_square(n):
"""Returns whether n is twice a square
>>> is_twice_square(2 * (3 ** 2))
True
>>> is_twice_square(2 * (4 ** 2))
True
"""
return ((n / 2) ** 0.5).is_integer()
def is_prime_plus_twice_square(n):
"""Returns whetner n can be written as a prime plus two times a square
"""
for prime in PRIMES:
if prime >= i:
break
if is_twice_square(i - prime):
return True
return False
