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 test_join_digits(self) -> None:
self.assertEqual(digs.join_digits([0]), 0)
self.assertEqual(digs.join_digits([1]), 1)
self.assertEqual(digs.join_digits([0, 1]), 1)
self.assertEqual(digs.join_digits([1, 2]), 12)
self.assertEqual(digs.join_digits((3, 2, 1)), 321)
self.assertEqual(digs.join_digits(range(0, 7, 2)), 246)
self.assertEqual(digs.join_digits([1, 0, 0, 1], 2), 9)
self.assertEqual(digs.join_digits([1, 7, 3, 4], 8), 988)
self.assertEqual(digs.join_digits([3, 'D', 'c', 0], 16), 15808)
def solve():
pandigital = list(range(10))
result = 0
for permutation in permutations(pandigital):
if join_digits(permutation[1:4]) % 2 != 0:
continue
if join_digits(permutation[2:5]) % 3 != 0:
continue
if join_digits(permutation[3:6]) % 5 != 0:
continue
if join_digits(permutation[4:7]) % 7 != 0:
continue
if join_digits(permutation[5:8]) % 11 != 0:
continue
if join_digits(permutation[6:9]) % 13 != 0:
continue
if join_digits(permutation[7:10]) % 17 != 0:
continue
result += join_digits(permutation)
return result
def truncations(n):
"""
Returns all possible truncations of n.
>>> truncations(3797)
{97, 3, 37, 7, 3797, 379, 797}
"""
d = split_digits(n)
result = set([n])
for i in range(1, len(d)):
result.add(join_digits(d[i:]))
result.add(join_digits(d[:i]))
return result
def rotations(n):
d = deque(split_digits(n))
result = []
for i in range(len(d)):
result.append(join_digits(d))
d.rotate()
return result
def replace_letters(word, numbers, mapping):
"""Constructs a number from a word, replacing the letters with numbers based on indexes in mapping
>>> replace_letters("CARE", (1, 9, 6, 2), {'C': 0, 'R': 1, 'E': 2, 'A': 3})
1296
>>> replace_letters("RACE", (1, 9, 6, 2), {'C': 0, 'R': 1, 'E': 2, 'A': 3})
9216
"""
return join_digits(numbers[mapping[letter]] for letter in word)
def solve():
four_digit_primes = set(ibetween(gen_primes(), LOWER, UPPER))
for prime in four_digit_primes:
prime_permutations = digit_permutations(prime) & four_digit_primes
terms_of_three = combinations(prime_permutations, 3)
for terms in terms_of_three:
if equidistant(terms):
result = join_digits(terms)
if result != EXCLUDE:
return result
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():
data = read_data("p096_sudoku.txt")
sudokus = parse_sudokus(data)
result = 0
for i, sudoku in enumerate(sudokus, 1):
solved = solve_sudoku(sudoku)
top_left = join_digits(sudoku[0][0:3])
result += top_left
info(f"Sudoku {i} {'solved' if solved else 'FAILED'}: {top_left}")
info(sudoku)
info("")
return result
def solve() -> Optional[int]:
best_digits: Optional[Tuple[int, int, int, int]] = None
max_count = 0
# check all digit combinations 0 <= a < b < c < d <= 9
for a in range(0, 7):
for b in range(a + 1, 8):
for c in range(b + 1, 9):
for d in range(c + 1, 10):
results = digit_results(a, b, c, d)
count = natural_prefix_len(sorted(results))
if count > max_count:
max_count = count
best_digits = (a, b, c, d)
return None if best_digits is None else digs.join_digits(best_digits)
def solve(up_to=6, gons=3):
numbers = set(range(1, up_to + 1))
maximum = 0
for internal_nodes in combinations(numbers, gons):
# Skip 17-digit solutions
if 10 in internal_nodes:
continue
external_nodes = tuple(numbers - set(internal_nodes))
for ring in xgon_rings(external_nodes, internal_nodes):
concatenated = join_digits(map(join_digits, ring))
maximum = max(maximum, concatenated)
return maximum
def solve():
longest = (0, [])
for a in range(1, 10):
for b in range(a + 1, 10):
for c in range(b + 1, 10):
for d in range(c + 1, 10):
digits = [a, b, c, d]
length = consecutive_positive_integers(targets(digits))
logger.info(f"{digits}: {length}")
if length > longest[0]:
longest = (length, digits)
return join_digits(longest[1])
def solve() -> int:
# keep track of all digits preceding other digits
pre_digits: Dict[int, Set[int]] = {}
attempts = fio.ints_from_file(FILE_NAME)
for attempt in attempts:
digits = digs.get_digits(attempt[0])
for i, digit in enumerate(digits):
# add digit to dict if we haven't seen it before
if digit not in pre_digits:
pre_digits[digit] = set()
# add all of the preceding digits
for j in range(i):
pre_digits[digit].add(digits[j])
# sort digits by how many other digits precede them
ordering: List[Tuple[int, Set[int]]] = list(pre_digits.items())
ordering.sort(key=(lambda x: len(x[1])))
digits = [order[0] for order in ordering]
return digs.join_digits(digits)
def reverse_digits(n):
"""
>>> reverse_digits(1292)
2921
"""
return join_digits(reversed(split_digits(n)))
def is_square_mapping(digit_map: Mapping[str, int], word: str) -> bool:
"""Checks if digit_map maps the letters in word into a perfect square."""
mapped_digits = [digit_map[letter] for letter in word]
return (mapped_digits[0] != 0 and
seqs.is_square(digs.join_digits(mapped_digits)))
def solve(target):
digits = list(range(10))
permutation = nth(permutations(digits), target)
return join_digits(permutation)
