def main():
saved_chars = 0
for index, line in enumerate(file_reader(FILE)):
original = line.strip()
new_version = optimal_form(original)
print("1: %s\n2: %s" % (original, new_version))
saved = len(original) - len(new_version)
print("saved:", saved)
saved_chars += saved
# input("\n")
# if index > 5:
# break
print(saved_chars)
for tile in sides_dict.values():
all_sides |= tile
side_matches = defaultdict(list)
for side in all_sides:
for key, cube_sides in sides_dict.items():
if side in cube_sides:
side_matches[side].append(key)
match_table = defaultdict(set)
for match in side_matches.values():
if len(match) > 1:
left, right = match
match_table[left].add(right)
match_table[right].add(left)
corners = []
for name, pair in match_table.items():
if len(pair) == 2:
corners.append(int(name))
return math.prod(corners)
if __name__ == "__main__":
t0 = file_reader("examples/AOC20_20_example.txt")
assert compute(t0) == 20899048083289
start = perf_counter()
day20 = file_reader("inputs/2020_20.txt")
p1 = compute(day20)
end = perf_counter()
runtime = round((end - start) * 1000, 1)
print(f"solution part 1: {p1}")
print(f"runtime: {runtime}ms")
blacks = blacks - to_white
blacks = blacks | to_black
return len(blacks)
if __name__ == "__main__":
print("calculating...")
assert find_target("ee") == (2, 0)
assert find_target("ww") == (-2, 0)
assert find_target("nene") == (2, -2)
assert find_target("neneseseww") == (0, 0)
assert find_target("seswnwne") == (0, 0)
assert find_target("eenenewwswsw") == (0, 0)
t0 = file_reader("examples/AOC20_24_example.txt", output="lines")
assert compute(t0) == 10
assert compute_two(t0, 100) == 2208
start = perf_counter()
day24 = file_reader("inputs/2020_24.txt", output="lines")
stp1 = perf_counter()
p1 = compute(day24)
stp2 = perf_counter()
p2 = compute_two(day24, 100)
end = perf_counter()
rt_p1 = round((stp2 - stp1) * 1000, 1)
rt_p2 = round((end - stp2) * 1000, 1)
total_runtime = round((end - start) * 1000, 1)
print(f"solution part 1: {p1} ({rt_p1}ms)")
print(f"solution part 2: {p2} ({rt_p2}ms)")
t0 = [line.strip() for line in t0_raw.strip().split('\n')]
t1 = [line.strip() for line in t1_raw.strip().split('\n')]
assert convert_binary('XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X', '0b1011') == 73
assert convert_binary('XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X', '0b1100101') == 101
assert convert_binary('XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X', '0b0') == 64
assert address_combos('000000000000000000000000000000X1101X', [30, 35]) == [26, 27, 58, 59]
assert address_combos('00000000000000000000000000000001101X', [35]) == [26, 27]
assert get_addresses('000000000000000000000000000000X1001X', 42) == [26, 27, 58, 59]
assert get_addresses('00000000000000000000000000000000X0XX', 26) == [16, 17, 18, 19, 24, 25, 26, 27]
assert compute(t0) == 165
assert compute_two(t1) == 208
st = perf_counter()
day14 = file_reader('inputs/2020_14.txt', output='lines')
st_p1 = perf_counter()
p1 = compute(day14)
st_p2 = perf_counter()
p2 = compute_two(day14)
end = perf_counter()
time_p1 = round((st_p2 - st_p1) * 1000, 1)
time_p2 = round((end - st_p2) * 1000, 1)
total_time = round((end - st) * 1000, 1)
print(f"solution part 1: {p1} ({time_p1}ms)")
print(f"solution part 2: {p2} ({time_p2}ms)")
print(f"total execution time: {total_time}ms")
return calculator(simplified)
def compute(homework: List[str], calculator: Callable) -> int:
"""
Evaluate the expression on each line of the homework. Return the sum of
the resulting values.
To solve part 1 supply regular_math function as the calculator.
To solve part 2 supply funky_math function as the calculator.
"""
result = 0
for line in homework:
result += calculate_expression(line, calculator)
return result
if __name__ == '__main__':
t0 = "1 + 2 * 3 + 4 * 5 + 6" # 71, 231
t1 = "2 * 3 + (4 * 5)" # 26, 46
t2 = "5 + (8 * 3 + 9 + 3 * 4 * 3)" # 437, 1445
t3 = "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))" # 12240, 669060
t4 = "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2" # 13632, 23340
all_tests = [t0, t1, t2, t3, t4] # 26406, 694122
assert compute(all_tests, regular_math) == 26406
assert compute(all_tests, funky_math) == 694122
day18 = file_reader('inputs/2020_18.txt', output='lines')
print("solution part 1:", compute(day18, regular_math))
print("solution part 2:", compute(day18, funky_math))
assert calc_waypoint([10, 4], 'L', 180) == [-10, -4]
assert calc_waypoint([10, -2], 'R', 90) == [-2, -10]
assert calc_waypoint([10, -2], 'R', 180) == [-10, 2]
assert calc_waypoint([3, 0], 'R', 90) == [0, -3]
assert calc_waypoint([3, 0], 'L', 270) == [0, -3]
assert direction_change('R', 'N', 90) == 'E'
assert direction_change('L', 'N', 90) == 'W'
assert direction_change('R', 'E', 180) == 'W'
assert direction_change('L', 'E', 180) == 'W'
assert direction_change('R', 'S', 270) == 'E'
assert direction_change('L', 'S', 270) == 'W'
t0 = ['F10', 'N3', 'F7', 'R90', 'F11']
t1 = ['F10', 'N3', 'F7', 'L90', 'F11']
t2 = ['F10', 'S3', 'F7', 'L90', 'F11']
assert compute(t0) == 25
assert compute_two(t0) == 286
assert compute_two(t1) == 274
start = perf_counter()
day12_raw = file_reader('inputs/2020_12.txt', output='lines')
p1 = compute(day12_raw)
p2 = compute_two(day12_raw)
end = perf_counter()
runtime = round((end - start) * 1000, 1)
print(f"solution part 1: {p1}")
print(f"solution part 2: {p2}")
print(f"runtime: {runtime}ms")
# assert t0.get_children(3) == {4, 5}
# assert t0.get_children(4) == {'a'}
# assert t0.get_children(5) == {'b'}
t1 = Image(t1_raw)
# print(t1.rules)
# print(t1.messages)
# print(t1.parents)
# pprint(t1.rule_strings())
# print()
t2 = Image(t2_raw)
# print(t2.rules)
# pprint(t2.rule_strings())
day19_raw = file_reader('inputs/2020_19.txt')
day19 = Image(day19_raw)
pprint(day19.messages)
print(len(day19.messages))
len_dict = Counter()
for ms in day19.messages:
lm = len(ms)
len_dict[lm] += 1
pprint(len_dict)
# pprint(day19.rules)
# all_pos = set(day19.rule_strings()[0])
# print(all_pos)
# the_count = 0
# for m in day19.messages:
# if m in all_pos:
# the_count += 1
dangerous = []
while frontier:
current = frontier.popleft()
alg, pot_set = current
pts = pot_set - seen
if len(pts) == 1:
pt_name = pts.pop()
dangerous.append((alg, pt_name))
seen.add(pt_name)
else:
frontier.append(current)
danger_list = ""
for p in sorted(dangerous, key=lambda z: z[0]):
danger_list = danger_list + p[1] + ","
return danger_list[:-1]
if __name__ == "__main__":
t0 = """
mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
trh fvjkl sbzzf mxmxvkd (contains dairy)
sqjhc fvjkl (contains soy)
sqjhc mxmxvkd sbzzf (contains fish)
"""
start = perf_counter()
day21 = file_reader("inputs/2020_21.txt", output="lines")
print("solution part 2:", compute(day21))
end = perf_counter()
print(f"total runtime: {round((end - start) * 1000, 1)}ms")
)
while True:
p1 = hand1.popleft()
p2 = hand2.popleft()
if p1 > p2:
hand1.extend([p1, p2])
last_winner = "p1"
else:
hand2.extend([p2, p1])
last_winner = "p2"
winner = len(hand1) == 0 or len(hand2) == 0
if winner:
break
winning_hand = hand1 if last_winner == "p1" else hand2
card_count = len(winning_hand)
points = [card * (card_count - i) for i, card in enumerate(winning_hand)]
return sum(points)
if __name__ == '__main__':
t0 = file_reader('examples/AOC20_22_example.txt')
assert compute(t0) == 306
start = perf_counter()
day22 = file_reader("inputs/2020_22.txt")
part1 = compute(day22)
end = perf_counter()
runtime = round((end - start) * 1000, 1)
print(f"solution part 1: {part1}")
print(f"runtime: {runtime}ms")
your ticket:
11,12,13
nearby tickets:
3,9,18
15,1,5
5,14,9
"""
t0_parts = [part.strip() for part in t0_raw.strip().split('\n\n')]
t0_others_raw = t0_parts[2].split(':\n')
t0_other_ticket_strings = t0_others_raw[1].replace('\n', ',')
t0_fields = [field.strip() for field in t0_parts[0].strip().split('\n')]
t0_other = [int(ticket) for ticket in t0_other_ticket_strings.split(',')]
day16_raw = file_reader('inputs/2020_16.txt')
# print(type(day16_raw))
day16_parts = [part.strip() for part in day16_raw.strip().split(('\n\n'))]
# print(day16_parts[0])
day16_others_raw = day16_parts[2].split(':\n')
# print(day16_others_raw)
day16_other_ticket_strings = day16_others_raw[1].replace('\n', ',')
# print(day16_other_ticket_strings)
day16_fields = [field.strip() for field in day16_parts[0].strip().split('\n')]
# print(day16_fields)
day_16_all_other_fieldnums = [
int(ticket) for ticket in day16_other_ticket_strings.split(',')
]
day16_all_other_tickets = get_other_tickets(day16_raw)
day16_wrong_numbers = compute(day16_fields,
