def main():
flipped = [
get_tile_flipped(line) for line in (advent_tools.read_input_lines())
]
floor = get_floor(flipped)
print('Part 1:', sum(floor.values()))
print('Part 2:', run_part_2(floor))
def init_from_file(self):
lines = advent_tools.read_input_lines()
char_map = {'.': EMPTY, '#': WALL, '0': ROBOT}
for num in range(1, 10):
char_map[str(num)] = GOAL
for y_pos, line in enumerate(lines):
for x_pos, char in enumerate(line):
self.grid[y_pos, x_pos] = char_map[char]
def run_part_2():
lines = advent_tools.read_input_lines()[2:]
nodes = get_nodes(lines)
grid = StorageGrid(nodes)
# Also did it on paper by just writing out the steps
print(7 + 28 + 32 + 5 * 33 + 1)
# But it looks pretty cool to animate it
print(grid.move())
def run_part_2():
instructions = advent_tools.read_input_lines()
digits = []
digit = '5'
for line in instructions:
digit = follow_instruction2(line, digit)
digits.append(digit)
print(''.join(digits))
def read_initial_state(self):
lines = advent_tools.read_input_lines()
gen_pattern = r'a ([\w]+) generator'
mc_pattern = r'a ([\w]+)-compatible microchip'
for floor, line in enumerate(lines, start=1):
for match in re.finditer(gen_pattern, line):
self.generators[floor].add(match.groups()[0])
for match in re.finditer(mc_pattern, line):
self.microchips[floor].add(match.groups()[0])
def run_part_1():
columns = [''] * 8
lines = advent_tools.read_input_lines()
result = []
for line in lines:
for pos, char in enumerate(line):
columns[pos] = columns[pos] + char
for col in columns:
counter = collections.Counter(col)
result.append(counter.most_common(1)[0][0])
print(''.join(result))
def run_part_1():
jumps = [int(line) for line in advent_tools.read_input_lines()]
index = 0
count = 0
while True:
try:
new_jump = jumps[index]
jumps[index] = new_jump + 1
index = index + new_jump
except IndexError:
return count
count = count + 1
def run_part_2():
weights = {}
children = {}
for line in advent_tools.read_input_lines():
if '->' in line:
left, right = line.split('->')
name, whole_weight = left.split()
children[name] = right.replace(',', '').split()
else:
name, whole_weight = line.split()
weight = int(whole_weight[1:-1])
weights[name] = weight
check_balance(weights, children, 'dtacyn')
def run_part_1():
weights = {}
children = {}
for line in advent_tools.read_input_lines():
if '->' in line:
left, right = line.split('->')
name, whole_weight = left.split()
children[name] = right.replace(',', '').split()
else:
name, whole_weight = line.split()
weight = int(whole_weight[1:-1])
weights[name] = weight
all_children = [item for lst in children.values() for item in lst]
print(set(weights.keys()).difference(all_children))
def run_part_2():
rooms = advent_tools.read_input_lines()
for room in rooms:
result = ''
if check_if_room_valid(room):
sector_id = get_sector_id_of_valid(room)
for char_in in room:
if char_in == '-':
result = result + ' '
elif char_in.isalpha():
num_in = ord(char_in) - 97
num_out = (num_in + sector_id) % 26
result = result + chr(num_out + 97)
print(sector_id, result)
def main():
one_to_two = asyncio.Queue()
two_to_one = asyncio.Queue()
computer_one = DuetComputer(two_to_one, one_to_two)
computer_two = DuetComputer(one_to_two, two_to_one)
computer_one.registers['p'] = 0
computer_two.registers['p'] = 1
instructions = advent_tools.read_input_lines()
loop = asyncio.get_event_loop()
run_one = loop.create_task(computer_one.run_program(instructions))
run_two = loop.create_task(computer_two.run_program(instructions))
blocker = loop.create_task(block_detect(one_to_two, two_to_one))
loop.run_until_complete(blocker)
print(computer_two.send_count)
run_one.cancel()
run_two.cancel()
def run_part_1():
lines = advent_tools.read_input_lines()
two_count = 0
three_count = 0
for line in lines:
counter = collections.Counter(line)
has_two = 0
has_three = 0
for _, num in counter.items():
if num == 2:
has_two = 1
if num == 3:
has_three = 1
two_count += has_two
three_count += has_three
return two_count * three_count
def run_both_parts():
instructions = advent_tools.read_input_lines()
bot_dict = {}
output_dict = {}
values = []
for inst in instructions:
words = inst.split()
if (words[0] == 'bot'):
bot_num = int(words[1])
bot_dict[bot_num] = Bot(words, bot_dict, output_dict)
else:
value = int(words[1])
bot_num = int(words[-1])
values.append((bot_num, value))
for bot_num, value in values:
bot_dict[bot_num].give(value)
print('Part 2: ', output_dict[0] * output_dict[1] * output_dict[2])
def run_part_2():
lines = advent_tools.read_input_lines()
min_diff = 99
best_found = None
for first, second in itertools.combinations(lines, 2):
difference = 0
for char1, char2 in zip(first, second):
if char1 != char2:
difference += 1
if difference < min_diff:
min_diff = difference
best_found = (first, second)
first, second = best_found
result = []
for char1, char2 in zip(first, second):
if char1 == char2:
result.append(char1)
return ''.join(result)
def run_part_2():
computer = SafeComputer(advent_tools.read_input_lines())
computer.registers['a'] = 12
print(computer.run_program())
def main():
lines = advent_tools.read_input_lines()
possibilities, allergen_ingredient_map = solve_logic(lines)
print('Part 1:', run_part_1(lines, possibilities))
print('Part 2:', run_part_2(allergen_ingredient_map))
def run_part_1():
rooms = advent_tools.read_input_lines()
valid = [get_sector_id_of_valid(room) for room in rooms]
print(sum(valid))
def run_part_1():
lines = advent_tools.read_input_lines()[2:]
print(len(find_viable_pairs(lines)))
def run_part_2():
lines = advent_tools.read_input_lines()
lines.append('Disc #7 has 11 positions; at time=0, it is at position 0.')
print(get_drop_time(lines))
def run_part_1():
lines = advent_tools.read_input_lines()
print(get_drop_time(lines))
def run_part_1():
instructions = advent_tools.read_input_lines()
password = '******'
print(run_program(instructions, password))
def find_input(scrambled):
instructions = advent_tools.read_input_lines()
for permut in itertools.permutations(list(scrambled)):
result = run_program(instructions, permut)
if result == scrambled:
return ''.join(permut)
def main():
door_key, card_key = (int(line) for line in advent_tools.read_input_lines())
print('Part 1:', run_part_1(door_key, card_key))
to_write = to_write + bitmask[i]
except KeyError:
to_write = to_write + char
memory[inst[1]] = int(to_write, 2)
return sum(memory.values())
def run_part_2(instructions):
memory = {}
ones = []
floating = []
for inst in instructions:
if inst[0] == 'mask':
ones = [i for i, char in enumerate(inst[1]) if char == '1']
floating = [i for i, char in enumerate(inst[1]) if char == 'X']
else:
bits = list("{0:b}".format(inst[1]).zfill(NUM_BITS))
for pos in ones:
bits[pos] = '1'
for bit_vals in itertools.product(('0', '1'),
repeat=len(floating)):
for pos, bit_val in zip(floating, bit_vals):
bits[pos] = bit_val
memory[(int(''.join(bits), 2))] = inst[2]
return sum(memory.values())
if __name__ == '__main__':
data = parse_instructions(advent_tools.read_input_lines())
print('Part 1:', run_part_1(data))
print('Part 2:', run_part_2(data))
def read_data():
data = [[int(num) for num in line.split()]
for line in advent_tools.read_input_lines()]
return data
def main():
data = advent_tools.read_input_lines()
print('Part 1:', sum(evaluate_expression(line, rules_part1)
for line in data))
print('Part 2:', sum(evaluate_expression(line, rules_part2)
for line in data))
if cur_time % bus_id == 0:
return bus_id * (cur_time - start_time)
def calc_moduli(bus_times):
buses = bus_times.split(',')
moduli = {int(buses[0]): 0}
for time_delta, bus_id_str in enumerate(buses[1:], 1):
with contextlib.suppress(ValueError):
bus_id = int(bus_id_str)
moduli[bus_id] = (bus_id - time_delta) % bus_id
return moduli
def run_part_2(bus_data):
moduli = calc_moduli(bus_data[1])
divisors = sorted(moduli.keys(), reverse=True)
to_check = moduli[divisors[0]]
step_size = divisors[0]
for divisor in divisors[1:]:
while to_check % divisor != moduli[divisor]:
to_check = to_check + step_size
step_size = step_size * divisor
return to_check
if __name__ == '__main__':
data = advent_tools.read_input_lines()
print('Part 1:', run_part_1(data))
print('Part 2:', run_part_2(data))
