def main() -> int:
seen = set()
root2_50M = int(50_000_000**(1 / 2)) + 1
root3_50M = int(50_000_000**(1 / 3)) + 1
root4_50M = int(50_000_000**(1 / 4)) + 1
for x in primes(root2_50M):
x2 = x * x
for y in primes(root3_50M):
y3 = y * y * y
for z in primes(root4_50M):
total = x2 + y3 + z * z * z * z
if total < 50_000_000:
seen.add(total)
else:
break
return len(seen)
def prime_summations(n: int) -> int:
answer = 0
cached_primes: Tuple[int, ...] = tuple(primes(n))
num_primes = len(cached_primes)
max_idx = num_primes - 1
counts: List[int] = [0] * num_primes
# counts is a list containing how many times you add each prime
# so for 5 + 5 + 3 + 2 it would be [1, 1, 2]
counts[0] = n // 2 # primes[0] = 2
while True:
total = sum(x * y for x, y in zip(counts, cached_primes))
counts[0] += 1
if total > n:
idx = 0
while total > n and idx < max_idx:
counts[idx] = 0
idx += 1
counts[idx] += 1
total = sum(x * y for x, y in zip(counts, cached_primes))
if idx >= max_idx:
break
counts[0] = (n - total) // 2 # primes[0] = 2
elif total == n:
answer += 1
return answer
def func(set_of_primes):
last = 2
for x, y in zip(primes(), set_of_primes):
assert is_prime(x)
assert x == y
for z in range(last + 1, x):
assert not is_prime(z)
last = x
def main() -> int:
answer = 1
for p in primes():
new = answer * p
if new <= 1_000_000:
answer = new
else:
break
return answer
def main() -> int:
ten_8 = 10**8
cached_primes = tuple(primes(ten_8 // 2 + 1))
seen = {
x * y
for y in cached_primes
for x in takewhile((ten_8 // y).__ge__, cached_primes)
}
return len(seen)
def main() -> int:
min_p = 235_000
ten_ten = 10**10
for n, p in enumerate(primes(), 1):
if p < min_p or n & 1 == 0: # Seems to always produce remainder of 2?
continue
base = ((p - 1)**n + (p + 1)**n)
if base < ten_ten:
continue
elif base % (p * p) > ten_ten:
return n
return -1
def main() -> int:
iter_primes = iter(primes())
cached_primes: List[int] = []
while sum(cached_primes) < 1_000_000:
cached_primes.append(next(iter_primes))
cached_primes.pop()
for number in range(len(cached_primes), 21, -1):
for group in groupwise(cached_primes, number):
total = sum(group)
if is_prime(total):
return total
return -1
def main() -> int:
answer = -1
for p in primes():
cur_digits = tuple(digits(p))
num_digits = len(cur_digits)
if num_digits > 7:
break
elif any(digit > num_digits or cur_digits.count(digit) != 1
for digit in cur_digits):
continue
elif p > answer:
answer = p
return answer
def main() -> int:
answer: int = 0
pow_10: int = 10
iterator = primes(1000005) # iterate over primes <1000005
next(iterator) # skip 2
next(iterator) # skip 3
p1: int = next(iterator) # p1 = 5
for p2 in iterator: # 7, 11, 13, 17, ...
while pow_10 < p1:
pow_10 *= 10
answer += (p1 * p2 * mul_inv(p2, pow_10)) % (p2 * pow_10)
# simplified Chinese Remainder Theorem
p1 = p2
return answer
def main():
cached_primes = tuple(primes(6000))
for goal in count(35, 2):
if is_prime(goal):
continue
for p in takewhile(goal.__gt__, cached_primes):
done = False
for x in range(1, ceil(sqrt((goal - p) / 2)) + 1):
if p + 2 * x * x == goal:
done = True
break
if done:
break
else:
return goal
def main() -> int:
answer = 0
def check(*numbers: int) -> bool:
"""Modifies answer if necessary, then returns True if you need to continue"""
if numbers[-2] >= numbers[-1]:
return True # otherwise we can't guarantee uniqueness
length = is_not_pandigital(*numbers)
if length == 9:
return True # this means any nested loops can't be pandigital
if not length:
nonlocal answer
answer += 1
return True # if this set is pandigital, skip nested loops
return False
cached_primes = tuple(primes(98765432)) # should be largest eligible number
for a in takewhile((10**5).__gt__, cached_primes):
a_digits = ceil(log10(a))
for b in takewhile((10**(9 - a_digits)).__gt__, cached_primes):
if check(a, b):
continue
b_digits = a_digits + ceil(log10(b))
for c in takewhile((10**(9 - b_digits)).__gt__, cached_primes):
if check(a, b, c):
continue
c_digits = b_digits + ceil(log10(c))
for d in takewhile((10**(9 - c_digits)).__gt__, cached_primes):
if check(a, b, c, d):
continue
d_digits = c_digits + ceil(log10(d))
for e in takewhile((10**(9 - d_digits)).__gt__, cached_primes):
if check(a, b, c, d, e):
continue
e_digits = d_digits + ceil(log10(e))
for f in takewhile((10**(9 - e_digits)).__gt__, cached_primes):
if check(a, b, c, d, e, f):
continue
return answer
def main() -> int:
answer = count = 0
for p in primes():
if count == 11:
break
elif p < 10:
continue
else:
right = left = p
while is_prime(right):
right = right // 10
if right != 0:
continue
while is_prime(left):
x = 10
while x < left:
x *= 10
left %= x // 10
if left != 0:
continue
answer += p
count += 1
return answer
def main() -> int:
primes_at_1000 = primes()
for p in primes_at_1000:
if p > 1000:
break
primes_at_1000, pgen_1 = tee(primes_at_1000)
for p1 in pgen_1:
if p1 == 1487:
continue
pgen_1, pgen_2 = tee(pgen_1)
for p2 in pgen_2:
if p2 > 10000 - p1 // 2:
break
pgen_2, pgen_3 = tee(pgen_2)
for p3 in pgen_3:
if p3 > 10000:
break
elif p1 - p2 < p2 - p3:
continue
elif p1 - p2 > p2 - p3:
break
elif set(digits(p1)) == set(digits(p2)) == set(digits(p3)):
return p1 * 10**8 + p2 * 10**4 + p3
return -1
def primes_and_negatives(*args) -> Iterator[int]:
for p in primes(*args):
yield p
yield -p
def main() -> int:
return sum(takewhile((2_000_000).__gt__, primes()))
def main() -> int:
for idx, num in enumerate(primes(), 1):
if idx == 10001:
return num
return -1
