def part_two(input_file: str) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
# parse inputs into instructions
original_instructions = [
Instruction(line.split(' ')[0], int(line.split(' ')[1]))
for line in inputs
]
# find all of the nop, or jump instruction indexes instructions idx
corruptions_candidate_fixes = []
for i, instr in enumerate(original_instructions):
if instr.operation == 'nop':
corruptions_candidate_fixes.append((i, 'jmp'))
if instr.operation == 'jmp':
corruptions_candidate_fixes.append((i, 'nop'))
# iterate through the candidate fixes, create a fixed instruction set, try to run and if
# we terminate then we found the fix and can return the accumulator
for i, new_op in corruptions_candidate_fixes:
# create deep copy of original instructions
new_instructions = copy.deepcopy(original_instructions)
# fix current candidate instruction
new_instructions[i].operation = new_op
program = Program(new_instructions)
program.run_until_loop_detected_or_completion()
if program.is_terminated:
return program.accumulator
def part_one(input_file: str, task: str) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
#instantiate WaitingArea object and run until stable
waiting_area = WaitingArea(inputs=inputs, task=task)
waiting_area.run_process_until_stable()
return waiting_area.get_occupied_count()
def part_one(input_file: str, total: int) -> int:
# read in input file
expenses = read_input_list(input_file, line_type=int)
# iterate through the values and get what the other value would
# need to be for this pair to be the solution
for value in expenses:
other_value = total - value
if other_value in expenses:
return value * other_value
def part_two(input_file: str, total: int) -> int:
# read in input file
expenses = read_input_list(input_file, line_type=int)
# iterate through with indexes so we dont re-check the first pair of
# numbers
for i, value in enumerate(expenses):
for second_value in expenses[i + 1:]:
third_value = total - value - second_value
if third_value in expenses:
return value * second_value * third_value
def part_two(input_file: str) -> int:
# read input fil
inputs = read_input_list(input_file, strip_new_line=True)
# parse into instructions and instantiate boat
instructions = [Instruction(instr[0], int(instr[1:])) for instr in inputs]
boat = Boat(instructions=instructions)
# navigate and return final distance
boat.naviagate_waypoint()
return boat.get_manhatten_dist()
def part_one(input_file: str, plane_size: Tuple[int, int]) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
# iterate through tickets and find the seat id
# keep track of max seat id along the way
max_seat_id = -float('inf')
for ticket in inputs:
seat_id = find_seat(ticket=ticket, plane_size=plane_size)
if seat_id > max_seat_id:
max_seat_id = seat_id
return max_seat_id
def part_one(input_file: str) -> int:
# read input file
inputs = read_input_list(input_file, line_type=int)
# sort inputs to get adapters in order adding outlet and computer in as well
adapters = [0] + sorted(inputs) + [max(inputs) + 3]
# we know we have to use min joltage jump we will have to use all of our adapters
# so we can just take the difs of all out adapters
differences = Counter(
[cur - prev for (prev, cur) in zip(adapters, adapters[1:])])
return differences[1] * differences[3]
def part_one(input_file: str, preamble_len: int) -> int:
# read input file
inputs = read_input_list(input_file, line_type=int)
# iterate over all values starting after the preamble and
# check if they are valid. Return once we find the first invalid
for i, num in enumerate(inputs[preamble_len:]):
# since we are enumerating starting after the preamble the i in our
# loop will actually be the start of the preamble (our first value is inputs[25])
# and our i = 0, so the preamble is the slice [i, i + preamble_len]
preamble = inputs[i:i + preamble_len]
if not is_valid(num, preamble):
return num
def part_two(input_file: str) -> int:
# read input file
inputs = read_input_list(input_file)
# parse inputs
passwords = [
PasswordData.from_input_str(input_str) for input_str in inputs
]
# iterate over all passwords and count if valid
total_valid = 0
for password in passwords:
if password.is_valid_position:
total_valid += 1
return total_valid
def part_one(input_file: str) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
# parse inputs into instructions
instructions = [
Instruction(line.split(' ')[0], int(line.split(' ')[1]))
for line in inputs
]
# instantiate the program and run until we detect a loop
program = Program(instructions)
program.run_until_loop_detected_or_completion()
#return the value of the accumulator
return program.accumulator
def part_two(input_file: str, plane_size: Tuple[int, int]) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
# collect known seats
known_seats = [
find_seat(ticket=ticket, plane_size=plane_size) for ticket in inputs
]
# for each seat check if there is an empty seat on either side of the seat
# between another known seat
for seat in known_seats:
if seat - 1 not in known_seats and seat - 2 in known_seats:
return seat - 1
if seat + 1 not in known_seats and seat + 2 in known_seats:
return seat + 1
def part_one(input_file: str, slope: Tuple[int, int]) -> int:
# read input file
inputs = read_input_list(input_file)
# parse rows into cols and instantiate area
input_map = [list(line.strip('\n')) for line in inputs]
area = Area(map=input_map, slope=slope)
# traverse area until we get to the bottom and count trees along
# the way
total_trees = 0
while True:
area.move()
if area.reached_bottom:
break
if area.is_on_tree:
total_trees += 1
return total_trees
def part_two(input_file: str) -> int:
# read input file
inputs = read_input_list(input_file, line_type=int)
# sort inputs to get adapters in order adding outlet and computer in as well
adapters = [0] + sorted(inputs) + [max(inputs) + 3]
# we have too many branches to brute force so we need to use dynamic programming
# let paths[i] be the total number of paths that end adapter i.
# We know that we can use adapters where there is a voltage difference of 1, 2 or 3
# therefore paths[i] is paths[i-3] + paths[i-2] + paths[i-1]
paths = [0 for _ in range(adapters[-1])]
# fill in the base case, there is one way to have joltage 0
paths = [1] + paths
for adapter in adapters[1:]:
for dif in range(1, 4):
if adapter - dif >= 0:
paths[adapter] += paths[adapter - dif]
return paths[-1]
def part_one(input_file: str, desired_bag_color: str) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
# parse our rules and create a mapping of bags > inner bags
bag_tree = {}
for line in inputs:
raw_bag_color, raw_inner_bags = line.split('contain')
bag_color = "_".join(raw_bag_color.replace('bags', '').strip().split())
inner_bags = process_raw_inner_bags(raw_inner_bags)
bag_tree[bag_color] = inner_bags
# initialize container for valid outer colors and do a breadth first search
# starting at each outer color and see if we find the desired color
bags_containing_desired_color = set()
def breadth_first_search(initial_color: str, desired_color: str) -> None:
queue = [
inner_bag.color for inner_bag in bag_tree.get(initial_color, [])
]
while queue:
current_bag_color = queue.pop()
if current_bag_color == desired_color:
bags_containing_desired_color.add(initial_color)
return
inner_bags = bag_tree.get(current_bag_color, [])
for inner_bag in inner_bags:
queue.append(inner_bag.color)
for initial_color in bag_tree:
breadth_first_search(initial_color, desired_bag_color)
return len(bags_containing_desired_color)
def part_two(input_file: str, preamble_len: int) -> int:
# read input file
inputs = read_input_list(input_file, line_type=int)
# get target value from part one
target = part_one(input_file, preamble_len)
# perform a brute force search looking for the cumulative sum equal to our targe
range_found = False
for i in range(len(inputs)):
for j in range(i + 1, len(inputs)):
if sum(inputs[i:j + 1]) == target:
range_found = True
break
if range_found:
break
minimum = min(inputs[i:j + 1])
maximum = max(inputs[i:j + 1])
return minimum + maximum
def part_two(input_file: str, desired_bag_color: str) -> int:
# read input file
inputs = read_input_list(input_file, strip_new_line=True)
# parse our rules and create a mapping of bags > inner bags
bag_tree = {}
for line in inputs:
raw_bag_color, raw_inner_bags = line.split('contain')
bag_color = "_".join(raw_bag_color.replace('bags', '').strip().split())
inner_bags = process_raw_inner_bags(raw_inner_bags)
bag_tree[bag_color] = inner_bags
def breadth_first_search(initial_color: str, total_bags) -> None:
# initialize queue of tupples of bags to count along with the number of
# "parent bags" to multiply our the quantities
queue = [(inner_bag, 1)
for inner_bag in bag_tree.get(initial_color, [])]
while queue:
# pop off next bag with parent count and add the number of this bag to the
# total
current_bag, parent_count = queue.pop()
total_bags += current_bag.amount * parent_count
# iterate over the inner bags of the current bag and add to queue with new
# parent count
for inner_bag in bag_tree.get(current_bag.color, []):
queue.append((inner_bag, parent_count * current_bag.amount))
return total_bags
total_bags = breadth_first_search(desired_bag_color, 0)
return total_bags
