def ans(): size = 5 skip_to = 8300 for p in Prime.gen_nums(): if p < skip_to: continue nums = [q for q in Prime.gen_nums(p) if compatible(q, p)] for tuple_ in combinations(nums, size - 1): if remarkable(tuple_): return p + sum(tuple_)
def ans(): for prime in Prime.gen_nums(): if prime < 120000: continue # Replace all combinations of digits list_ = list(str(prime)) length = len(list_) for count in range(length): combs = combinations(range(length), count) for indices in combs: # Count the number of primes by replacing # the selected digits with some other digit generated_primes = set() for replacement in range(10): copy = list_.copy() for i in indices: copy[i] = str(replacement) number = int(''.join(copy)) if Prime.contains(number): generated_primes.add(number) if 7 < len(generated_primes): return min(generated_primes)
def ans(): truncatable = set() for p in Prime.gen_nums(): if is_truncatable(p): truncatable.add(p) if len(truncatable) == 11: break return sum(truncatable)
def ans(): n = 1 for p in Prime.gen_nums(): next_ = n * p if 1000000 < next_: return n n = next_ return n
def ans(): groups = defaultdict(set) for prime in Prime.gen_nums(10000): groups[''.join(sorted(str(prime)))].add(prime) for set_ in groups.values(): for comb in combinations(set_, 3): seq = sorted(list(comb)) if seq[0] < 1000: continue if (seq[2] + seq[0] == 2 * seq[1] and seq[0] != 1487): return ''.join(str(n) for n in seq)
def ans(): prime_list = list(Prime.gen_nums(4000)) longest = (0, 0) for i in range(len(prime_list)): sum_ = 0 for j in range(i, len(prime_list)): sum_ += prime_list[j] if 1000000 <= sum_: break if Prime.contains(sum_) and longest[1] < j - i + 1: longest = (sum_, j - i + 1) return longest[0]
def ans(): divisors = list(Prime.gen_nums(18)) sum_ = 0 for p in gen_pandigitals(from_=0, to=9): has_property = True for i in range(1, 8): dividend = int(str(p)[i:i + 3]) if dividend % divisors[i - 1] != 0: has_property = False break if has_property: sum_ += p return sum_
def ans(): circular_primes = set([2]) for p in Prime.gen_nums(1000000): if any(x in str(p) for x in '02468'): continue is_circular = True for i in range(len(str(p))): if not Prime.contains(int(str(p)[i:] + str(p)[:i])): is_circular = False break if is_circular: circular_primes.add(p) return len(circular_primes)
def ans(): # The insight is that n / phi(n) is minimized when n has a few, large prime # factors (n can't be prime, since prime numbers don't satisfy the # permutation criteria). Also, note that we don't actually have to compute # all of the numbers coprime with n to determine phi(n); instead we can use # the fact that n is a product of two primes to calculate phi(n) in # constant time. min_n = None min_value = None primes = Prime.gen_nums(10**4) combos = combinations(primes, 2) for one, two in list(combos): n = one * two if 10**7 <= n: continue num_coprimes = one * two - one - two + 1 if sorted(str(n)) == sorted(str(num_coprimes)): value = n / num_coprimes if not min_value or value < min_value: min_n = n min_value = value return min_n
def ans(): return sum(Prime.gen_nums(2000000))