def part2():
def get_all_flips_seamonster_count():
seamonster_count = get_seamonster_count(image, seamonster)
if seamonster_count == 0:
# Flip horizontal
seamonster_count = get_seamonster_count(flip_horizontal(image),
seamonster)
if seamonster_count == 0:
# Flip vertical
seamonster_count = get_seamonster_count(flip_vertical(image),
seamonster)
return seamonster_count
tiles = get_tiles()
seamonster = read_lines('Seamonster.txt')
corners = [tile for tile in tiles if tile.get_match_count() == 2]
image = generate_full_image(corners)
seamonster_count = get_all_flips_seamonster_count()
while seamonster_count == 0:
image = rotate_90(image)
seamonster_count = get_all_flips_seamonster_count()
seamonster_hash_count = len(
[char for char in ''.join(seamonster) if char == '#'])
total_hash_count = len([char for char in ''.join(image) if char == '#'])
final_count = total_hash_count - (seamonster_hash_count * seamonster_count)
return final_count
def process(is_valid):
lines = read_lines('Input.txt')
return len([
policy_and_password
for policy_and_password in [PolicyAndPassword(line) for line in lines]
if is_valid(policy_and_password)
])
def part2():
lines = [int(line) for line in read_lines('Input.txt')]
combos = list(combinations(lines, 2))
print(combos)
pair = [
pair for pair in combos if remainder_in_list(pair[0] + pair[1], lines)
].pop()
return pair[0] * pair[1] * (2020 - pair[0] - pair[1])
def find_invalid():
lines = [int(line) for line in read_lines('Input.txt')]
invalid = -1
countback = 25
next_index = countback
while invalid == -1:
invalid = check_next(next_index, countback, lines)
next_index += 1
return invalid
def part1():
lines = [
line.replace('\n', '').replace('"', '')
for line in read_lines("Input.txt")
]
rule_end_index = lines.index('')
rules = lines[:rule_end_index]
rule_map = {
int(line.split(': ')[0]): line.split(': ')[1]
for line in rules
}
regex = re.compile('^' + get_regex(rule_map[0], rule_map, 0) + '$')
lines_to_validate = lines[rule_end_index + 1:]
print(len([match for match in lines_to_validate if regex.match(match)]))
def part1():
lines = read_lines('Input.txt')
target = int(lines[0])
buses = [int(bus) for bus in lines[1].replace('x,', '').split(',')]
bus_time_map = {}
for bus in buses:
running_total = 0
while running_total < target:
running_total += bus
bus_time_map[running_total] = bus
final_time = min(bus_time_map.keys())
return (final_time - target) * bus_time_map[final_time]
def part1():
direction = EAST
position = Point(START_POSITION.x, START_POSITION.y)
lines = read_lines("Input.txt")
for line in lines:
instruction = line[0]
amount = int(line[1:])
if instruction in ["R", "L"]:
direction = rotate(direction, instruction, amount)
elif instruction in DIRECTIONS:
position = move(position, DIRECTIONS.index(instruction), amount)
else:
position = move(position, direction, amount)
return abs(position.x) + abs(position.y)
def part1():
line = [Entry(int(c)) for c in read_lines('Input.txt')[0]]
populate_links(line)
play_game(line, 100)
cup_one = [cup for cup in line if cup.value == 1][0]
next_cup = cup_one.next_cup
result = ''
while next_cup.value != 1:
result += str(next_cup.value)
next_cup = next_cup.next_cup
print(result)
def part2():
line = [Entry(int(c)) for c in read_lines('Input.txt')[0]]
max_num = max([int(e.value) for e in line])
for i in range(max_num + 1, 1000001):
line.append(Entry(i))
populate_links(line)
play_game(line, 10000000)
cup_one = [cup for cup in line if cup.value == 1][0]
result = cup_one.next_cup.value * cup_one.next_cup.next_cup.value
# print(cup_one.next_cup.value)
# print(cup_one.next_cup.next_cup.value)
print(result)
def part2():
def get_prev(number):
return [line for line in lines if line >= number - 3 and not line >= number]
def process_next():
number = lines[index]
path_counts[number] = 0
for prev in get_prev(number):
path_counts[number] += path_counts[prev]
lines = [int(row) for row in file_reader.read_lines('Input.txt')]
lines.append(0)
lines.sort()
path_counts = {0: 1}
for index in range(1, len(lines)):
process_next()
return path_counts[max(lines)]
def part2():
def has_count(bag):
return bag != 'noother'
def bags_within_bag_colour(bag_count_item):
bag_count_list = [
*[
bag for bag in bag_map.get(bag_count_item[0]).split(',')
if has_count(bag)
]
]
return {
bag[1:len(bag)]: int(bag[0]) * bag_count_item[1]
for bag in bag_count_list
}
def bags_within_non_empty(bags_within):
return len(bags_within) > 0
def get_contained_directly(bag_count_items):
return [
bags_within for bags_within in [
bags_within_bag_colour(bag_colour)
for bag_colour in bag_count_items
] if bags_within_non_empty(bags_within)
]
def populate_bag_list(bag_count_map):
contained_directly = get_contained_directly(bag_count_map.items())
if len(contained_directly) > 0:
complete_list.extend(contained_directly)
if len(contained_directly) > 0:
for bag_count_direct_map in contained_directly:
populate_bag_list(bag_count_direct_map)
bag_map = get_bag_map(read_lines('Input.txt'))
complete_list = []
populate_bag_list({'shinygold': 1})
return sum(
chain.from_iterable({this_map.values()
for this_map in complete_list}))
def parse_input(process):
def parse_line():
new_mask = mask
parts = line.split(" = ")
line_type = parts[0]
if line_type == MASK:
new_mask = parts[1].replace("\n", "")
else:
mem_address = parts[0].split("[")[1].replace("]", "")
process(int(parts[1].replace("\n", "")), result, mem_address, new_mask)
return new_mask
lines = read_lines('Input.txt')
mask = ""
result = {}
for line in lines:
mask = parse_line()
return sum(result.values())
def process(upper):
def take_turn():
if turn < len(start_nums):
next_num = start_nums[turn]
else:
next_num = turn - 1 - num_turn_map[
last_num] if last_num in num_turn_map else 0
num_turn_map[last_num] = turn - 1
return next_num
start_nums = [int(num) for num in read_lines("Input.txt")[0].split(",")]
last_num = ""
num_turn_map = {}
for turn in range(0, upper):
last_num = take_turn()
return last_num
def part2():
lines = read_lines('Input.txt')
buses = lines[1].split(',')
bus_index_map = {
int(bus): index
for index, bus in enumerate(buses) if bus != 'x'
}
bus_list = [int(bus) for bus in buses if bus != 'x']
bus_list.sort()
bus_list.reverse()
jump = 1
answer = bus_list[0] - bus_index_map[bus_list[0]]
for bus in bus_list:
index = bus_index_map[bus]
while (answer + index) % int(bus) != 0:
answer += jump
jump *= int(bus)
return answer
def part1():
subject_number = 7
lines = read_lines('Input.txt')
card_pub_key = int(lines[0])
door_pub_key = int(lines[1])
value = 1
card_loop_size = 0
while value != card_pub_key:
value *= subject_number
value = value % 20201227
card_loop_size += 1
subject_number = door_pub_key
enc_key = 1
for i in range(0, card_loop_size):
enc_key *= subject_number
enc_key = enc_key % 20201227
print(enc_key)
def get_initial_state():
black_tiles = set()
lines = read_lines('Input.txt')
for line in lines:
char_index = 0
x = 0
y = 0
while char_index < len(line):
char = line[char_index]
char_index += 1
direction = char
if char == 'n' or char == 's':
direction += line[char_index]
char_index += 1
if direction == 'e':
x += 2
elif direction == 'se':
x += 1
y -= 1
elif direction == 'sw':
x -= 1
y -= 1
elif direction == 'w':
x -= 2
elif direction == 'nw':
x -= 1
y += 1
elif direction == 'ne':
x += 1
y += 1
point = Point(x, y)
if point in black_tiles:
black_tiles.remove(point)
else:
black_tiles.add(point)
return black_tiles
def get_all_ingredients_and_allergen_map():
lines = read_lines('Input.txt')
allergen_to_ingredient = {}
all_ingredients = list()
for line in lines:
contains_str = ' (contains '
contains_index = line.index(contains_str)
ingredients = line[:contains_index]
allergens = line[contains_index + len(contains_str):].replace(
',', '').replace(')', '')
ingredient_set = set(ingredients.split(' '))
all_ingredients.extend(list(ingredient_set))
for allergen in allergens.split(' '):
if allergen in allergen_to_ingredient.keys():
allergen_to_ingredient[allergen] = set.intersection(
ingredient_set, allergen_to_ingredient[allergen])
else:
allergen_to_ingredient[allergen] = ingredient_set
return [all_ingredients, allergen_to_ingredient]
def part2():
waypoint_relative = Point(10, 1)
ship_position = Point(START_POSITION.x, START_POSITION.y)
waypoint_position = Point(START_POSITION.x + waypoint_relative.x, START_POSITION.y + waypoint_relative.y)
lines = read_lines("Input.txt")
for line in lines:
instruction = line[0]
amount = int(line[1:])
if instruction in ["R", "L"]:
waypoint_position = rotate_waypoint(waypoint_position, ship_position, instruction, amount)
waypoint_relative = Point(waypoint_position.x - ship_position.x, waypoint_position.y - ship_position.y)
elif instruction in DIRECTIONS:
waypoint_position = move(waypoint_position, DIRECTIONS.index(instruction), amount)
waypoint_relative = Point(waypoint_position.x - ship_position.x, waypoint_position.y - ship_position.y)
else:
for i in range(0, amount):
ship_position = Point(waypoint_position.x, waypoint_position.y)
waypoint_position = Point(ship_position.x + waypoint_relative.x, ship_position.y + waypoint_relative.y)
return abs(ship_position.x) + abs(ship_position.y)
def part1():
def add_next():
prev = chain[-1]
diff = 1
while True:
for line in lines:
if prev + diff == line:
chain.append(line)
return diff
diff += 1
lines = [int(row) for row in file_reader.read_lines('Input.txt')]
chain = [0]
one_diff = 0
three_diff = 0
while max(chain) != max(lines):
next_diff = add_next()
if next_diff == 1:
one_diff += 1
if next_diff == 3:
three_diff += 1
return one_diff * (three_diff + 1)
def part1():
def bags_containing_bag_colour(bag_colour):
return [
key for key in bag_map.keys() if bag_colour in bag_map.get(key)
]
def populate_bag_list(bag_list):
if len(bag_list) == 0:
return
contain_directly = [
*chain.from_iterable([
bags_containing_bag_colour(bag_colour)
for bag_colour in bag_list
])
]
complete_bag_list.update(contain_directly)
populate_bag_list(contain_directly)
bag_map = get_bag_map(read_lines('Input.txt'))
complete_bag_list = set()
populate_bag_list(['shinygold'])
return len(complete_bag_list)
def part2():
sum_str_lines = read_lines('Input.txt')
return sum([calc_sum_part2(line.replace(' ', '').replace('\n', ''), True)[0] for line in sum_str_lines])
def get_seat_ids() -> list:
return [get_seat_id(line) for line in read_lines('Input.txt')]
def __init__(self, filename):
self.lines = read_lines(filename)
def read_hands():
lines = read_lines('Input.txt')
player2_index = lines.index('Player 2:')
player1_cards = [int(line) for line in lines[1:player2_index - 1]]
player2_cards = [int(line) for line in lines[player2_index + 1:]]
return [player1_cards, player2_cards]
def part2():
lines = [int(line) for line in read_lines('Input.txt')]
number_to_find = find_invalid()
contiguous_set = find_contiguous_set(lines, number_to_find)
return min(contiguous_set) + max(contiguous_set)
def part1():
lines = [int(line) for line in read_lines('Input.txt')]
match = [number for number in lines
if remainder_in_list(number, lines)].pop()
return match * (2020 - match)
