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))