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)