def main():
# Guess biggest prime we want to check
N = 10**4
primes = list(get_primes_up_to_n(N))
# Build dict to know which pairs of primes work
prime_checking_set = set(get_primes_up_to_n(N**2))
prime_concat_dict = defaultdict(set)
for p, q in combinations(primes, 2):
if concat(p, q) in prime_checking_set and concat(
q, p) in prime_checking_set:
prime_concat_dict[p].add(q)
prime_concat_dict[q].add(p)
# Choose primes from dict and look for minimum sum
min_sum = 4 * N
for p1 in primes:
i2 = prime_concat_dict[p1]
for p2 in i2:
i3 = i2 & prime_concat_dict[p2]
for p3 in i3:
i4 = i3 & prime_concat_dict[p3]
for p4 in i4:
i5 = i4 & prime_concat_dict[p4]
for p5 in i5:
total = p1 + p2 + p3 + p4 + p5
if total < min_sum:
min_sum = total
print(min_sum)
def main():
primes = set(get_primes_up_to_n(10**4)) - set(get_primes_up_to_n(10**3))
for p in primes:
prime_perms = set(get_perms(p)) & primes
primes = primes - prime_perms
prime_perms = sorted(prime_perms)
for i in range(len(prime_perms)):
pi = prime_perms[i]
for j in range(i + 1, len(prime_perms)):
pj = prime_perms[j]
if 2 * pj - pi in prime_perms:
concat = str(pi) + str(pj) + str(2 * pj - pi)
if concat != "148748178147":
print(concat)
return
def main():
primes = set(get_primes_up_to_n(10**6))
total = 0
for p in primes:
if p > 10 and all(t in primes for t in gen_truncations(p)):
total += p
print(total)
def main():
primes = list(get_primes_up_to_n(10**7))
primes_set = set(primes)
min_ratio = 10**7
for n in range(2, 10**7):
if n in primes_set:
continue
et = n
n_copy = n
early_exit = False
for p in primes:
if p * p > n_copy:
break
if n_copy % p == 0:
et *= p - 1
et //= p
if n / et > min_ratio:
early_exit = True
break
while n_copy % p == 0:
n_copy //= p
if early_exit:
continue
if n_copy > 1:
et *= n_copy - 1
et //= n_copy
if n / et < min_ratio and sorted(str(et)) == sorted(str(n)):
min_ratio = n / et
best_n = n
print(best_n)
def main():
primes = [2]
for n in range(2, 100):
if n > primes[-1]:
primes = list(get_primes_up_to_n(n))
if recurse(n, primes) > 5000:
break
print(n)
def main():
primes = set(get_primes_up_to_n(10**6))
count = 2 # Count 2 and 5, excluded by checks below
for n in range(1, 10**6):
if any((d % 2 == 0 or d == 5) for d in map(int, str(n))):
continue
if all(c in primes for c in cycle_number_gen(n)):
count += 1
print(count)
def main():
upper_lim = 10**8
primes = list(get_primes_up_to_n(upper_lim // 2))
count = 0
for i in range(len(primes)):
for j in range(i, len(primes)):
if primes[i] * primes[j] < upper_lim:
count += 1
else:
break
print(count)
def main():
N = 10**9
primes = list(get_primes_up_to_n(100))
hamming_nos = {1}
for p in primes:
for x in set(hamming_nos):
prod = x * p
while prod <= N:
hamming_nos.add(prod)
prod *= p
print(len(hamming_nos))
def S(N):
primes = list(get_primes_up_to_n(N // 2))
total = 0
for i in range(len(primes)):
p = primes[i]
if p * p > N:
break
for j in range(i + 1, len(primes)):
q = primes[j]
if p * q > N:
break
total += M(p, q, N)
return total
def main():
primes = get_primes_up_to_n(10**5)
total = 10 # 2 + 3 + 5
for p in primes:
if p < 7:
continue
n = A(p)
while n % 2 == 0:
n //= 2
while n % 5 == 0:
n //= 5
if n != 1:
total += p
print(total)
def main():
n_max = 4 * 10**7
target_length = 25
primes = list(get_primes_up_to_n(n_max))
totients = totient_sieve(n_max, np.array(primes))
@njit
def chain_length(n):
if n == 1:
return 1
return 1 + chain_length(totients[n])
print(sum(p for p in primes if chain_length(p) == target_length))
def smallest_with_2n_divisors(n):
primes = get_primes_up_to_n(10 ** 7)
prod = 1
max_prime = next(primes)
heap = [max_prime]
for _ in range(n):
next_term = heapq.heappop(heap)
heapq.heappush(heap, next_term * next_term)
if next_term == max_prime:
max_prime = next(primes)
heapq.heappush(heap, max_prime)
prod *= next_term
prod %= MOD
return prod
def count_primes(n_max):
tn_is_prime = np.ones(n_max + 1, dtype=np.bool)
primes = [
p for p in get_primes_up_to_n(int(2**0.5 * n_max)) if p % 8 in (1, 7)
]
for p in primes:
if p % 8 == 7:
# In this case, square root is easy to find
r = powmod((p - 1) // 2, (p + 1) // 4, p)
r = min(r, p - r)
else:
r = tonelli_shanks(p, (p + 1) // 2)
tn_is_prime[p - r::p] = False
tn_is_prime[p + r::p] = False
return np.sum(tn_is_prime[2:])
def main():
N = 50 * 10**6
primes = list(get_primes_up_to_n(ceil(sqrt(N))))
prime_2 = [p**2 for p in primes]
prime_3 = [p**3 for p in primes]
prime_4 = [p**4 for p in primes]
is_sum = [False] * N
for a in prime_2:
for b in prime_3:
if a + b > N:
break
for c in prime_4:
if a + b + c > N:
break
is_sum[a + b + c - 1] = True
print(sum(is_sum))
def main():
primes = list(get_primes_up_to_n(10**6))
done = False
for p in primes:
digits = str(p)
unique_digits = set(digits)
for u_digit in unique_digits:
p_with_asterisks = [
p_digit if p_digit != u_digit else "*" for p_digit in digits
]
rep_family = list(
filter(is_prime, get_replacement_family(p_with_asterisks)))
if len(rep_family) == 8:
print(min(rep_family))
done = True
break
if done:
break
def main():
primes = list(get_primes_up_to_n(10**6))
primes_set = set(primes)
prime_sum = 0
max_sum_len = 0
while prime_sum < primes[-1]:
prime_sum += primes[max_sum_len]
max_sum_len += 1
for sum_len in range(max_sum_len, 1, -1):
prime_sum = sum(primes[:sum_len])
pos = 0
while pos < len(primes) - sum_len and prime_sum < primes[-1]:
if prime_sum in primes_set:
print(prime_sum)
return
prime_sum += primes[pos + sum_len] - primes[pos]
pos += 1
def main():
N = 10**6
primes = list(get_primes_up_to_n(N))
def euler_totient(n):
ret = n
for p in primes:
if p * p > n:
break
if n % p == 0:
ret *= (p - 1)
ret //= p
while n % p == 0:
n //= p
if n > 1:
ret *= (n - 1)
ret //= n
return ret
print(sum(euler_totient(r) for r in range(1, N + 1)) - 1)
def main():
N = 12 * 10**4
primes = list(get_primes_up_to_n(N))
@lru_cache(maxsize=None)
def rad(n):
ret = 1
for p in primes:
if p > n:
break
if n % p == 0:
ret *= p
n //= p
return ret
# Possible optimisation - compute radicals and primes simultaneously
rads = defaultdict(list)
for n in range(1, N):
rads[rad(n)].append(n)
rads = sorted((rad, lst) for rad, lst in rads.items())
total = 0
for c in range(2, N):
rad_c = rad(c)
if 2 * rad_c >= c:
continue
for rad_a, a_vals in rads:
if 2 * rad_a * rad_c >= c:
break
for a in a_vals:
if 2 * a > c:
break
if rad_a * rad(c - a) * rad_c < c and gcd(c - a, a) == 1:
total += c
print(total)
def main():
N = 5 * 10**7
primes = list(get_primes_up_to_n(N))
print(sum((p % 4 == 3) + (p * 4 < N) + (p * 16 < N) for p in primes))
def main():
print(sum(get_primes_up_to_n(2 * 10**6)))
def main():
n_max = 15 * 10**7
primes = np.fromiter(get_primes_up_to_n(n_max + 27), dtype=np.int32)[4:]
print(sum(n for n in range(10, n_max, 10) if consec_primes(n, primes)))
def main():
primes = get_primes_up_to_n(10**6)
for i, p in enumerate(primes, 1):
if i % 2 == 1 and (2 * i * p) % (p * p) > 10**10:
print(i)
break
def main():
k = 10 ** 9
primes = get_primes_up_to_n(10 ** 6)
prime_factors = (p for p in primes if p > 5 and pow(10, k % (p - 1), p) == 1)
print(sum(islice(prime_factors, 40)))
def main():
primes = list(get_primes_up_to_n(10**6 + 3))
print(sum(f(p1, p2) for p1, p2 in zip(primes[2:], primes[3:])))
def bin_sum_primes(n, r):
primes = get_primes_up_to_n(n)
return sum(p * bin_padic_val(n, r, p) for p in primes)
def test_get_primes_up_to_n():
assert list(utils.get_primes_up_to_n(10)) == [2, 3, 5, 7]
assert list(utils.get_primes_up_to_n(4)) == [2, 3]
def main():
primes = np.fromiter(get_primes_up_to_n(10**8), dtype=np.int32)[2:]
print(np.sum(S(primes)))
def main():
n_max = 64 * 10 ** 6
primes = np.fromiter(get_primes_up_to_n(n_max), dtype=np.int32)
print(sum_square_sigma(n_max, primes))
