def main(verbose=False):
data = [[int(entry) for entry in row.split(",")]
for row in get_data(83).split("\n") if row]
arranged_data = {}
size = len(data)
for i in range(size):
for j in range(size):
arranged_data[(i, j)] = data[i][j]
MINIMUM = min(arranged_data.values())
def heuristic(node):
return (2 * size - 2 - sum(node)) * MINIMUM
def adjacent(node):
node_x, node_y = node
return [(node_x + 1, node_y), (node_x - 1, node_y),
(node_x, node_y + 1), (node_x, node_y - 1)]
return astar(arranged_data,
(0, 0),
(size - 1, size - 1),
heuristic,
adjacent)
def main(verbose=False):
data = get_data(98)[1:-1].split('","')
words = strings_by_length(data)
max_len = int(sqrt(10)**max(words))
squares = strings_by_length(
[i**2 for i in range(1, int(sqrt(10)**max(words)))])
max_val = 0
for word_length in sorted(words.keys())[::-1]:
total_words = len(words[word_length])
for first in range(total_words - 1):
for second in range(first + 1, total_words):
first_word = words[word_length][first]
second_word = words[word_length][second]
# check anagrams
if sorted(first_word) == sorted(second_word):
for square in squares[word_length]:
val, translation = same_signature(square, first_word)
if val:
translated = second_word
for letter, digit in translation:
translated = translated.replace(letter, digit)
new_number = int(translated)
if new_number in squares[word_length]:
to_add = max(square, new_number)
if to_add > max_val:
max_val = to_add
if max_val > 0:
return max_val
raise Exception("Program failed to find solution")
def main(verbose=False):
data = [get_points(line) for line in get_data(102).split("\n") if line]
count = 0
for points in data:
if zero_in(points):
count += 1
return count
def main(verbose=False):
message = get_data(59).split(',')
message = [int(char) for char in message]
possible_keys = []
for ascii1 in range(97, 123):
for ascii2 in range(97, 123):
for ascii3 in range(97, 123):
possible_keys.append([ascii1, ascii2, ascii3])
for key in possible_keys:
curr = translate(message, key)
if (curr.upper().find('THE') != -1
and curr.upper().find('IS') != -1
and curr.upper().find('AND') != -1
and curr.upper().find('OF') != -1
and curr.upper().find('ARE') != -1):
break
key_as_word = ''.join(chr(val) for val in key)
result = '\n\nActual Message:\n%s\n\nThe key is: %s or %s.' % (
curr, key_as_word, key)
if verbose:
return '%s%s' % (sum(ord(letter) for letter in curr), result)
else:
return sum(ord(letter) for letter in curr)
def main(verbose=False):
data = get_data(54)
hands = [read_hand(row) for row in data.split("\n") if row]
hands = [(top_cards(entry[0]), top_cards(entry[1])) for entry in hands]
count = 0
for hand in hands:
if compare_hands(*hand) == 1:
count += 1
return count
def num_triangle():
# Assumes file is "A","ABILITIY","ABLE",...
words = get_data(42).strip('"').split('","')
vals = [word_to_value(word) for word in words]
triangle_hash = {}
count = 0
for val in vals:
if reverse_polygonal_number(3, val, triangle_hash) != -1:
count += 1
return count
def main(verbose=False):
data = [row.split(",") for row in get_data(99).split("\n") if row]
max_val = -1
winner = None
for i, row in enumerate(data):
log_val = int(row[1]) * log(int(row[0]))
if log_val > max_val:
max_val = log_val
winner = i
return winner + 1 # account for 0 vs. 1 initial index
def main(verbose=False):
data = [[int(dig) for dig in row] for row
in get_data(79).split("\r\n") if row]
all_values = list(set(reduce(operator.add, data)))
for password in all_permutations(all_values):
correct = True
for left, middle, right in data:
left_index = password.index(left)
middle_index = password.index(middle)
right_index = password.index(right)
if not (left_index < middle_index < right_index):
correct = False
break
if correct:
break
if not correct:
raise Exception("No match found")
return ''.join(str(key) for key in password)
def main(verbose=False):
data = [row.split(',') for row in get_data(107).split('\r\n') if row]
adjacency = {}
size = len(data)
network_sum = 0
# UNDIRECTED
for node in range(size - 1):
for dest in range(node + 1, size):
if data[node][dest] != '-':
value = int(data[node][dest])
network_sum += value
# sets value to [] if not set, returns value at key
adjacency.setdefault(node, []).append((dest, value))
adjacency.setdefault(dest, []).append((node, value))
_, min_sum = prims_algo(adjacency)
return network_sum - min_sum
def main(verbose=False):
DATA = get_data(11)
DATA = [[int(entry) for entry in row.split()]
for row in DATA.split("\n") if row]
# UP/DOWN goes from DATA[x][y] to DATA[x+3][y] where 0 <= x, x+3, y <= 19
vert = max(convert(make_path((x, y), (1, 0), 4), DATA) for x
in range(0, 16 + 1) for y in range(19 + 1))
# LEFT/RIGHT goes from DATA[x][y] to DATA[x][y+3] where 0 <= x, y, y+3 <= 19
horiz = max(convert(make_path((x, y), (0, 1), 4), DATA) for x
in range(0, 19 + 1) for y in range(16 + 1))
# DIAGONAL L->R goes from DATA[x][y] to DATA[x+3][y+3] via +[1,1]
diag_l_r = max(convert(make_path((x, y), (1, 1), 4), DATA) for x
in range(0, 16 + 1) for y in range(16 + 1))
# DIAGONAL R->L goes from DATA[x][y] to DATA[x-3][y+3] via +[-1,1]
diag_r_l = max(convert(make_path((x, y), (-1, 1), 4), DATA) for x
in range(3, 19 + 1) for y in range(16 + 1))
return max(vert, horiz, diag_l_r, diag_r_l)
def main(verbose=False):
number = get_data(13)
total = sum(int(line) for line in number.split("\n") if line)
return str(total)[:10]
def main(verbose=False):
data = [[int(entry) for entry in row.split(",")]
for row in get_data(82).split("\n") if row]
return column_by_column(data)
def main(verbose=False):
triangle = get_data(18).strip()
TRIANGLE_MAT = [[int(elt) for elt in line.split()]
for line in triangle.split("\n") if line]
return max_sum(TRIANGLE_MAT)
def main(verbose=False):
data = [num for num in get_data(89).split("\n") if num]
original_digits = len("".join(data))
best = [to_roman(actual(numeral)) for numeral in data]
return original_digits - len("".join(best))
def main(verbose=False):
puzzles = get_data(96).split("\n")
puzzles = [reduce(operator.add, puzzles[10 * index + 1:10 * index + 10])
for index in range(50)]
return sum(corner_sum(puzzle) for puzzle in puzzles)
def main(verbose=False):
# The name file is a comma separated file with quotes
names = sorted(get_data(22).strip('"').split('","'))
return sum((i + 1)*name_score(name) for i, name in enumerate(names))
def main(verbose=False):
n = int("".join(line.strip() for line in get_data(8).split("\n")))
return max(product_consec_digits(n, 5))
