def main():
global prime_set
utilities.generate_primes_sieve(MAX)
prime_set = set(utilities.primes)
factors_cache = []
term_index = dict()
total = 0
for n in range(1, MAX):
factors = prime_factors(n)
factors_cache.append((utilities.product(factors), factors, n))
factors_cache.sort()
for i in range(len(factors_cache)):
term_index[factors_cache[i][2]] = i
prev_prod = -1
for a in factors_cache:
factors_prod = a[0]
if factors_prod != prev_prod:
b_list = [
b for b in factors_cache[factors_cache.index(a) + 1:]
if a[0] * b[0] < MAX and len(a[1] | b[1]) == len(a[1]) +
len(b[1])
]
prev_prod = factors_prod
if a[0]**2 >= MAX:
break
for b in b_list:
if a[0] * b[0] >= MAX:
break
if a[2] + b[2] >= MAX:
continue
c = factors_cache[term_index[a[2] + b[2]]]
if len(a[1] | b[1] | c[1]) == len(a[1]) + len(b[1]) + len(
c[1]) and a[0] * b[0] * c[0] < c[2]:
total += c[2]
return total
def main(): utilities.generate_primes_sieve(1000000) for n in range(1, 1000000): cache.clear() count = count_combos(0, n, [p for p in utilities.primes if p < n]) if count > 5000: return n
def main():
utilities.generate_primes_sieve(1000000)
for i in range(0, len(utilities.primes), 2):
n = i + 1
r = utilities.primes[i] * n * 2
if r > 10**10:
return n
def main():
utilities.generate_primes_sieve(1000000)
upper_bound_range = int(math.log(TARGET * 2, 3)) + 1
upper_bound = utilities.product(
[utilities.primes[i] for i in range(int(math.log(TARGET * 2, 3)) + 1)])
factors_list = [3]
while True:
n = gen_from_sq_factors(factors_list)
solutions = (utilities.product(factors_list) + 1) // 2
if solutions > TARGET and n < upper_bound:
upper_bound = n
if len(factors_list) >= upper_bound_range:
return upper_bound
if n > upper_bound or solutions > TARGET:
for i in range(len(factors_list)):
if factors_list[i] > 3:
factors_list[i] = 3
if i == len(factors_list) - 1:
factors_list.append(3)
else:
factors_list[i + 1] += 2
break
else:
return upper_bound
else:
factors_list[0] += 2
def main():
utilities.generate_primes_sieve(1000000)
totients = list(range(1000001))
totients[1] = 0
for p in utilities.primes:
for n in range(p, 1000001, p):
totients[n] = totients[n] * (p - 1) // p
return sum(totients)
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
templates = [''.join(num) for num in list(itertools.product(digits, digits, digits, "*", "*", "*"))+ list(itertools.product(digits, digits, "*", "*", "*")) + list(itertools.product(digits, "*", "*", "*"))]
templates = [''.join(item) for sublist in [set(itertools.permutations(template)) for template in templates] for item in sublist]
for template in templates:
prime_family = [p for p in [int(template.replace("*", digit)) for digit in digits] if p in prime_set and len(str(p)) == len(template)]
if len(prime_family) >= 8:
return int(min(prime_family))
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
count = 0
for p in prime_set:
rotations = {int(str(p)[i:] + str(p)[:i]) for i in range(1, len(str(p)))}
if rotations & prime_set == rotations:
count += 1
return count
def main():
utilities.generate_primes_sieve(1000000)
prime_set = {str(p) for p in utilities.primes}
single_digit_primes = {p for p in prime_set if len(p) == 1}
left_truncatables = {''.join(p) for p in itertools.product("123456789", single_digit_primes)} & prime_set
right_truncatables = {''.join(p) for p in itertools.product(single_digit_primes, "123456789")} & prime_set
for i in range(6):
left_truncatables |= {''.join(p) for p in itertools.product("123456789", left_truncatables)} & prime_set
right_truncatables |= {''.join(p) for p in itertools.product(right_truncatables, "123456789")} & prime_set
return sum({int(p) for p in left_truncatables & right_truncatables})
def main():
utils.generate_primes_sieve(MAX, include_list=False)
candidates = {p - 1 for p in utils.prime_set}
for n in range(1, MAX + 1):
if n not in utils.prime_set:
for m in range(1, n):
prod = m * (n - m)
if prod > MAX:
break
candidates.discard(prod)
return sum(candidates)
def main():
utils.generate_primes_sieve(TARGET)
count = 2
for p in utils.primes[1:]:
if p * 16 < TARGET:
count += 1
if p * 4 < TARGET:
count += 1
if (p + 1) % 4 == 0:
count += 1
return count
def main():
utils.generate_primes_sieve(TARGET + 500)
total = 0
for i in range(2, len(utils.primes)):
p1 = utils.primes[i]
p2 = utils.primes[i + 1]
if p1 > TARGET:
break
mod_val = p2 - (10**len(str(p1)) % p2)
result = solve_congruence(p2, mod_val)[1] * p1 % p2
total += result * 10**len(str(p1)) + p1
return total
def main():
utilities.generate_primes_sieve(1000000)
totients = list(range(1000001))
for p in utilities.primes:
for n in range(p, 1000001, p):
totients[n] = totients[n] * (p - 1) // p
max_ratio = 0
best_n = 0
for n in range(1, 1000001):
if n / totients[n] > max_ratio:
max_ratio = n / totients[n]
best_n = n
return best_n
def main(): utilities.generate_primes_sieve(1000000) sums = set() for p1 in utilities.primes: if p1**4 > MAX: break for p2 in utilities.primes: if p1**4 + p2**3 > MAX: break for p3 in utilities.primes: if p1**4 + p2**3 + p3**2 > MAX: break sums.add(p1**4 + p2**3 + p3**2) return len(sums)
def main():
utilities.generate_primes_sieve(10000000)
totients = list(range(10000000))
for p in utilities.primes:
for n in range(p, 10000000, p):
totients[n] = totients[n] * (p - 1) // p
min_ratio = math.inf
best_n = 0
for n in range(2, 10000000):
if n / totients[n] < min_ratio and sorted(str(n)) == sorted(
str(totients[n])):
min_ratio = n / totients[n]
best_n = n
return best_n
def main():
utilities.generate_primes_sieve(100000)
primes = sorted([
''.join(p) for p in itertools.chain.from_iterable(
itertools.permutations(all_digits, r)
for r in range(1,
len(all_digits) + 1))
if utilities.is_prime(int(''.join(p)))
],
key=lambda x: sorted(x))
prime_groups = [
(''.join(k), len(list(g)))
for k, g in itertools.groupby(primes, key=lambda x: sorted(x))
]
return find_sets(prime_groups, all_digits, 0)
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
for n in itertools.count(9, 2):
if n not in prime_set:
found = False
for p in {p for p in prime_set if p < n}:
m = 1
while p + (2 * m**2) < n:
m += 1
if p + (2 * m**2) == n:
found = True
break
if not found:
return n
def main(): utils.generate_primes_sieve(100000) total = 5 for p in utils.primes[2:]: prev_result = -1 for n in itertools.count(1): result = 10**gcd(10**n, p - 1) % p if prev_result == result: if result == 1: pass else: total += p break else: prev_result = result return total
def main():
utilities.generate_primes_sieve(MAX)
prime_set = set(utilities.primes)
largest_n = 0
value = 0
for a in range(-999, 1000):
for b in range(-999, 1000):
n = 0
p = n**2 + a * n + b
while p in prime_set:
n += 1
p = n**2 + a * n + b
if n > largest_n:
largest_n = n
value = a * b
return value
def main():
utils.generate_primes_sieve(MAX)
targets = {1, 3, 7, 9, 13, 27}
antitargets = {num for num in range(1, 27) if num not in targets}
candidates = range(10, MAX, 10)
for p in utils.primes:
if p > 1000:
break
mod_targets = {target % p for target in targets}
hits = {n for n in range(p) if p - (n**2 % p) not in mod_targets or n**2 + (p - (n**2 % p)) == p}
candidates = {candidate for candidate in candidates if candidate % p in hits}
total = 0
for n in candidates:
if is_prime_targets(n**2, targets) and not is_any_prime_targets(n**2, antitargets):
total += n
return total
def main(): utilities.generate_primes_sieve(1000000) prime_set = set(utilities.primes) prime_count = 0 total_count = 1 n = 1 for i in range(2, 1000000, 2): for j in range(3): n += i total_count += 1 if n in prime_set or utilities.is_prime(n): prime_count += 1 n += i total_count += 1 if prime_count * 10 < total_count: return i + 1
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
total = 0
total_count = 0
for i in itertools.count(10, 10):
for n in [i + 1, i + 3, i + 7, i + 9]:
if n not in prime_set:
remainder = 1
count = 1
while remainder != 0:
remainder = (remainder * 10 + 1) % n
count += 1
if (n - 1) % count == 0:
total += n
total_count += 1
if total_count == 25:
return total
def main():
global prime_set
utils.generate_primes_sieve(162000)
prime_set = set(utils.primes)
divisors_list = sorted([1] + divisors(10**9))
factors = set()
prev_vals = set()
for div in divisors_list:
val = 10**div + 1
val_factors = prime_factors(val)
factors |= val_factors
val = int("1" * div)
prev_vals.add(val)
val_factors = prime_factors(val)
factors |= val_factors
if len(factors) >= 40:
break
return sum(sorted(factors)[:40])
def main():
utilities.generate_primes_sieve(100000000)
prime_set = set(utilities.primes)
small_prime_set = {p for p in utilities.primes if p < 10000}
groups = [[p1, p2] for p1 in small_prime_set for p2 in small_prime_set
if p1 < p2 and match_in_group([p1], p2, prime_set)]
groups = [
group + [p] for p in small_prime_set for group in groups
if p > max(group) and match_in_group(group, p, prime_set)
]
groups = [
group + [p] for p in small_prime_set for group in groups
if p > max(group) and match_in_group(group, p, prime_set)
]
groups = [
group + [p] for p in small_prime_set for group in groups
if p > max(group) and match_in_group(group, p, prime_set)
]
return sum(groups[0])
def main():
total = 0
unclaimed_ks = set(range(2, 12001))
utilities.generate_primes_sieve(100000)
for n in itertools.count(2):
factors = prime_factors(n)
factor_combos = [
nums for nums in factor_groups(tuple(factors)) if len(nums) >= 2
]
k_val_found = False
for combo in factor_combos:
k_val = (n - sum(combo)) + len(combo)
if k_val in unclaimed_ks:
unclaimed_ks.remove(k_val)
k_val_found = True
if k_val_found:
total += n
if len(unclaimed_ks) == 0:
break
return total
def main():
utilities.generate_primes_sieve(100000)
total = 0
for d in range(10):
base = list(itertools.repeat(str(d), DIGITS))
digit_total = 0
for i in range(1, DIGITS):
index_combos = list(itertools.combinations(range(DIGITS), i))
digit_groups = list(itertools.product("0123456789", repeat=i))
for combo in index_combos:
for group in digit_groups:
p = base.copy()
for j in range(i):
p[combo[j]] = group[j]
p = int(''.join(p))
if len(str(p)) == DIGITS and utilities.is_prime(p):
digit_total += p
if digit_total > 0:
break
total += digit_total
return total
def main():
utils.generate_primes_sieve(MAX)
count = 0
found_index = -1
upper_bound_multiplier = 10
for n_root in itertools.count(1):
if n_root**2 * upper_bound_multiplier > MAX:
break
for i in range(found_index + 1, len(utils.primes)):
if utils.primes[i] > n_root**2 * upper_bound_multiplier:
break
n = n_root**3
p = utils.primes[i]
val = n**3 + n**2 * p
root = int(round(val**(1 / 3)))
if root**3 == val:
count += 1
upper_bound_multiplier = p / n_root**2
found_index = i
break
return count
def main(): utilities.generate_primes_sieve(MAX) prime_set = set(utilities.primes) index = 0 size = len(utilities.primes) while size > 0: if size % 10 == 0: print((index, size)) p = sum(utilities.primes[index:index + size]) if p in prime_set: return p while p > MAX: if index == 0: p -= utilities.primes[size - 1] if p in prime_set: return p else: index = 0 p = 0 size -= 1 else: index += 1
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
consecutives = 0
for n in itertools.count(4):
factors = 0
n_temp = n
for p in utilities.primes:
if n_temp % p == 0:
factors += 1
while n_temp % p == 0:
n_temp //= p
if n_temp in prime_set:
factors += 1
break
if n_temp == 1:
break
if factors == 4:
consecutives += 1
else:
consecutives = 0
if consecutives == 4:
return n - 3
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
total = 2
for i in itertools.count(2):
base = utilities.triangle(i - 1) * 6 + 1
for j in range(7):
n = base + 1 + j * i
if j == 6:
n -= 1
if j < 6 and j > 0:
prev_layer = n - (i * j + (i - 1) * (6 - j))
next_layer = n + (i * (6 - j) + (i + 1) * j)
candidates = [
prev_layer, next_layer - 1, next_layer, next_layer + 1
]
elif j == 0:
next_layer = n + i * 6
next_next_layer = n + (i * 2 + 1) * 6
candidates = [
next_layer - 1, next_layer + 1, next_next_layer - 1
]
else: # j == 6
prev_prev_layer = n - (i * 2 - 1) * 6
prev_layer = n - i * 6
next_layer = n + (i + 1) * 6
candidates = [
prev_prev_layer + 1, prev_layer + 1, next_layer - 1
]
count = 0
for candidate in candidates:
if abs(n - candidate) in prime_set:
count += 1
if count == 3:
total += 1
if total == TARGET:
return n
def main(): utilities.generate_primes_sieve(2000000) return sum(utilities.primes)
