def concatenates_to_prime(a, b): """Returns whether both ab and ba are prime >>> concatenates_to_prime(109, 673) True """ return is_prime(join_digits((a, b))) and is_prime(join_digits((b, a)))
def solve() -> int: n = 7 answer = -1 # test all odd composite numbers for property while answer == -1: n += 2 # skip number if it is not composite if prime.is_prime(n): continue # check if the given number is a counterexample is_counterexample = True primes = prime.primes_up_to(n) for p in primes: # test property for each prime diff = n - p if diff % FACTOR == 0 and seqs.is_square(diff // FACTOR): is_counterexample = False break # if property doesn't hold for this n, set it as answer if is_counterexample: answer = n return answer
def solve(): largest_pandigital_prime = 0 for n in range(1, 10): digits = set(range(1, n + 1)) for c in permutations(digits): candidate = join_digits(c) if is_prime(candidate): largest_pandigital_prime = candidate return largest_pandigital_prime
def solve() -> int: total = 0 # search for strong RTH primes with each number of digits up to POWER - 1 rth_num_sums = [(0, 0)] for _ in range(POWER - 1): # build new RTH numbers by adding digits to previous list new_rth_num_sums = [] candidate_nums = [] for base_num, base_sum in rth_num_sums: base_part = base_num * 10 for digit in range(10): new_num = base_part + digit new_sum = base_sum + digit # avoid dividing by 0 if new_sum == 0: continue # keep track of all strong RTH numbers div, mod = divmod(new_num, new_sum) if mod == 0: new_rth_num_sums.append((new_num, new_sum)) if prime.is_prime(div): candidate_nums.append(new_num) # prepare RTH numbers and their digit sums for next iteration rth_num_sums = new_rth_num_sums # check for strong RTH primes formed from RTH number bases for base_num in candidate_nums: base_part = base_num * 10 for digit in range(1, 10, 2): n = base_part + digit if prime.is_prime(n): total += n return total
def solve(): masks = defaultdict(set) for prime in gen_primes(): digits = str(prime) for masked_digit in set(digits): masked = digits.replace(masked_digit, "x") for replaced_digit in range(10): candidate = int(masked.replace("x", str(replaced_digit))) # Discard leading zeros if len(str(candidate)) != len(masked): continue if is_prime(candidate): masks[masked].add(candidate) if len(masks[masked]) >= TARGET: return min(masks[masked])
def solve() -> int: # TODO: find (provably) better lower bound on prime addend size primes = prime.primes_up_to(max(1000, LIMIT // 10)) num_primes = len(primes) # create matrix with primes along diagonal dyna_sums: List[List[int]] = [[] for _ in range(num_primes)] for i in range(num_primes): dyna_sums[i] = [0] * num_primes dyna_sums[i][i] = primes[i] # compute dynamic sums, up to LIMIT - 1 for j in range(1, num_primes): for i in range(j - 1, -1, -1): dyna_sum = dyna_sums[i][j - 1] + dyna_sums[j][j] if dyna_sum >= LIMIT: break else: dyna_sums[i][j] = dyna_sum # search for prime sum of max consecutive terms max_consec = -1 best_prime = -1 for i in range(num_primes): for j in range(i, num_primes): # stop searching if no more sums < LIMIT in current row if dyna_sums[i][j] == 0: break # check if sum meets criteria and is better than best so far if prime.is_prime(dyna_sums[i][j]): consec = j - i + 1 if consec > max_consec: max_consec = consec best_prime = dyna_sums[i][j] return best_prime
def solve() -> int: side = 1 value = 1 diag_count = 0 prime_count = 0 prime_frac = 1.0 while prime_frac > MIN_FRACTION: # each layer has side length 2 greater than previous side += 2 # count primes along diagonals of spiral side_sub_1 = side - 1 for _ in range(4): # each diagonal is (side - 1) greater than previous value += side_sub_1 # increment number of diagonal values and primes as necessary diag_count += 1 if prime.is_prime(value): prime_count += 1 prime_frac = prime_count / diag_count return side
from common.primes import is_prime TARGET = 0.1 n = 1 step = 2 total_diagonals = 1 diagonal_primes = set() while True: for i in range(4): n += step total_diagonals += 1 if is_prime(n): diagonal_primes.add(n) step += 2 width = step - 1 prime_ratio = len(diagonal_primes) / total_diagonals if prime_ratio < 0.1: print(width) break
import itertools from common.primes import gen_primes, is_prime LIMIT = 1_000_000 primes = list(itertools.takewhile(lambda p: p < LIMIT, gen_primes())) longest = 0 result = 0 for start in range(0, len(primes)): prime_slice = primes[start:] total = 0 for length, prime in enumerate(prime_slice, 1): total += prime if total >= LIMIT: break if length > longest and is_prime(total): longest = length result = total print(result)
def solve() -> int: families: Set[Sequence[int]] = set() # test 5-digit numbers for i in range(1, 5): for digit_i in range(10): for digit_one in range(10): count = 0 family = [] for digit_repl in range(10): if count < FAMILY_SIZE - (10 - digit_repl): break num = digit_one for d in range(1, 5): if d == i: num += digit_i * 10**d else: num += digit_repl * 10**d if prime.is_prime(num): count += 1 family.append(num) if count == FAMILY_SIZE: families.add(tuple(sorted(family))) # test 6-digit numbers for i in range(1, 6): for j in range(1, 6): for digit_i in range(10): for digit_j in range(10): for digit_one in range(10): count = 0 family = [] for digit_repl in range(10): if count < FAMILY_SIZE - (10 - digit_repl): break num = digit_one for d in range(1, 6): if d == i: num += digit_i * 10**d elif d == j: num += digit_j * 10**d else: num += digit_repl * 10**d if prime.is_prime(num): count += 1 family.append(num) if count == FAMILY_SIZE: families.add(tuple(sorted(family))) # find min prime that satisfies problem requirements min_primes = [] for fam in families: min_prime = fam[0] digit_count = digs.count_digits(min_prime) for i in range(1, len(fam)): if digs.count_digits(fam[i]) != digit_count: break min_primes.append(min_prime) return min(min_primes)
def solve() -> int: total = 0 # search for truncatable primes until MAX_COUNT are found count = 0 m = 5 while count < MAX_COUNT: # search for candidate prime numbers m < n around multiples of 6 m += 6 n = m + 2 # check if m itself is prime before testing truncations if prime.is_prime(m): # check if m is a right truncatable prime right_trunc_prime = True for truncation in digs.digit_truncations_right(m): if truncation == m: continue if not prime.is_prime(truncation): right_trunc_prime = False break # if necessary, check if m is also a left truncatable prime if right_trunc_prime: left_trunc_prime = True for truncation in digs.digit_truncations_left(m): if truncation == m: continue if not prime.is_prime(truncation): left_trunc_prime = False break # if m is both a left and right truncatable prime, add to total if left_trunc_prime: count += 1 total += m # check if n itself is prime before testing truncations if prime.is_prime(n): # check if n is a right truncatable prime right_trunc_prime = True for truncation in digs.digit_truncations_right(n): if truncation == n: continue if not prime.is_prime(truncation): right_trunc_prime = False break # if necessary, check if n is also a left truncatable prime if right_trunc_prime: left_trunc_prime = True for truncation in digs.digit_truncations_left(n): if truncation == n: continue if not prime.is_prime(truncation): left_trunc_prime = False break # if n is both a left and right truncatable prime, add to total if left_trunc_prime: count += 1 total += n return total
def test_is_prime(self) -> None: primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53} for n in range(2, 59): self.assertEqual(prime.is_prime(n), n in primes) self.assertFalse(prime.is_prime(993)) self.assertFalse(prime.is_prime(995)) self.assertTrue(prime.is_prime(997)) self.assertFalse(prime.is_prime(999)) self.assertFalse(prime.is_prime(10006719)) self.assertTrue(prime.is_prime(10006721)) self.assertFalse(prime.is_prime(10006723)) self.assertFalse(prime.is_prime(2097151)) self.assertTrue(prime.is_prime(2147483647)) self.assertFalse(prime.is_prime(4294967295))
def concats_prime(n: int, m: int) -> bool: """Determines if n and m can concatenate in either order to form primes.""" return (prime.is_prime(digs.concat_numbers(n, m)) and prime.is_prime(digs.concat_numbers(m, n)))
def formula_primes(a, b): """Returns a list of primes generated by the formula.""" return list(takewhile(lambda n: is_prime(n), gen_formula(a, b)))
def is_prime(n: int) -> bool: """Memoized wrapper for the is_prime function.""" return prime.is_prime(n)
>>> is_twice_square(2 * (3 ** 2)) True >>> is_twice_square(2 * (4 ** 2)) True """ return ((n / 2) ** 0.5).is_integer() def is_prime_plus_twice_square(n): """Returns whetner n can be written as a prime plus two times a square """ for prime in PRIMES: if prime >= i: break if is_twice_square(i - prime): return True return False for i in range(3, limit, 2): if is_prime(i): continue if not is_prime_plus_twice_square(i): print(i) break