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