def parse_input(file_name): return { parent_bag_color: content_rules for parent_bag_color, content_rules in ( _parse_bag_color_rule(bag_color_rule_string) for bag_color_rule_string in common.get_input_lines(file_name)) }
def solve2(): challenge_list = sorted(map(int, filter(len, get_input_lines(FILE_NUM)))) for num1_index, first_num in enumerate(challenge_list): total = TARGET_SUM - first_num inner_prod = solve1(total, challenge_list[num1_index:]) if inner_prod is not None: return inner_prod * first_num
def solve1(total=TARGET_SUM, challenge_list=None): if challenge_list is None: challenge_list = sorted( map(int, filter(len, get_input_lines(FILE_NUM)))) for num in challenge_list: required_num = total - num if required_num in challenge_list: return num * required_num
def parse_input(file_name): return { output_chemical: { 'output_amount': output_amount, 'inputs': inputs, } for output_chemical, output_amount, inputs in ( _parse_reaction(reaction_string) for reaction_string in common.get_input_lines(file_name)) }
def parse_input(file_name): lookup = { 'B': '1', 'F': '0', 'R': '1', 'L': '0', } return [ int(''.join(lookup[c] for c in line), 2) for line in common.get_input_lines(file_name) ]
def solve1_old(): tree_lines = list(get_input_lines(FILE_NUM)) line_length = len(tree_lines[0]) tree_count = 0 x = 0 for (line_index, tree_line) in enumerate(tree_lines): tree_count += tree_line[x] == TREE_CHAR x = (x + 3) % line_length return tree_count
def solve2(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) instructions = get_instructions(lines) max_coord = get_max(instructions) field = get_field(max_coord + 1, max_coord + 1) populate_field(field, instructions, True) return get_danger_count(field)
def solve2(is_sample=False): lines = list(get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) oxygen_lines, scrubber_lines = get_split(lines, 0) for digit in range(1, len(lines[0])): if len(oxygen_lines) > 1: oxygen_lines = get_split(oxygen_lines, digit)[0] if len(scrubber_lines) > 1: scrubber_lines = get_split(scrubber_lines, digit)[1] return int(oxygen_lines[0], 2) * int(scrubber_lines[0], 2)
def parse_input(file_name): settings = [] for line in common.get_input_lines(file_name): index1, index2, char, password = re.search( r'(\d+)-(\d+) ([a-z]): ([a-z]+)', line).groups(0) indexes = [int(v) - 1 for v in (index1, index2)] settings.append({ 'indexes': indexes, 'char': char, 'password': password, }) return settings
def solve1(is_sample=False, seats_callback=find_all_immediate_neighbors, taken_tolerance=4): lines = get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None) rows = [list(row) for row in lines] while check_has_changed(deepcopy(rows), rows, seats_callback, taken_tolerance): pass # wait.. that's illegal! count_seats = sum([row.count(OCCUPIED_SEAT) for row in rows]) print('\n'.join([' '.join(row) for row in rows])) return count_seats
def parse_input(file_name): settings = [] for line in common.get_input_lines(file_name): span_start, span_end, char, password = re.search( r'(\d+)-(\d+) ([a-z]): ([a-z]+)', line).groups(0) span = [int(s) for s in (span_start, span_end)] settings.append({ 'span': span, 'char': char, 'password': password, }) return settings
def solve1(x_steps=3, y_steps=1, tree_lines=None): if tree_lines is None: tree_lines = list(get_input_lines(FILE_NUM)) line_length = len(tree_lines[0]) tree_count = 0 x = 0 for line_index in range(0, len(tree_lines), y_steps): tree_count += tree_lines[line_index][x] == TREE_CHAR x = (x + x_steps) % line_length return tree_count
def get_diff_map(): sorted_adapter_list = [0] + sorted(map(int, get_input_lines(FILE_NUM))) sorted_adapter_list += [sorted_adapter_list[-1] + 3] diff_map = {1: 0, 2: 0, 3: 0} latest_adapter = sorted_adapter_list[0] for adapter in sorted_adapter_list[1:]: diff_to_current = adapter - latest_adapter diff_map[diff_to_current] += 1 latest_adapter = adapter return diff_map
def solve2(): adapters = [0] + sorted(map(int, get_input_lines(FILE_NUM))) possible_edges = [1] + ([0] * (max(adapters))) for edge in adapters[1:]: reachable_edges = [] for previous_index in range(edge - 3, edge): if previous_index >= 0: reachable_edges.append(possible_edges[previous_index]) possible_edges[edge] = sum(reachable_edges) return possible_edges[-1]
def solve1(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) values = [int(x) for x in lines] increment_count = 0 for value_index in range(1, len(values)): previous_value = values[value_index - 1] current_value = values[value_index] if current_value > previous_value: increment_count += 1 return increment_count
def get_bus_lines_with_details(is_sample=False): _, bus_input = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None)) bus_lines: List[str] = bus_input.split(',')[::-1] buses = [] difference = 0 for bus in bus_lines: if bus != OUT_OF_ORDER_BUS: bus_line = int(bus) buses.append([bus_line, difference % bus_line]) difference += 1 return buses
def solve2(): numbers = list(map(int, get_input_lines(FILE_NUM))) invalid_number = find_invalid_number(numbers) for start_index in range(len(numbers) - 1): accumulated_sum = numbers[start_index] for last_index in range(start_index + 1, len(numbers)): accumulated_sum += numbers[last_index] if accumulated_sum == invalid_number: target_sequence = numbers[start_index:last_index + 1] return min(target_sequence) + max(target_sequence) elif accumulated_sum > invalid_number: break
def solve1(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) fishes = [int(x) for x in lines[0].split(',')] for step in range(80): fish_count = range(len(fishes)) for fish_index in fish_count: fishes[fish_index] -= 1 if fishes[fish_index] < 0: fishes[fish_index] = 6 fishes.append(8) return len(fishes)
def solve1(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None)) depart_time = int(lines[0]) bus_lines = [ int(bus) for bus in lines[1].split(',') if bus != OUT_OF_ORDER_BUS ] least_wait: int = max(bus_lines) best_bus_line = None for bus_line in bus_lines: current_wait = bus_line - depart_time % bus_line if least_wait > current_wait: least_wait = current_wait best_bus_line = bus_line return least_wait * best_bus_line
def solve2(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) h_pos, depth, aim = 0, 0, 0 for line in lines: direction, units = line.split(' ') units = int(units) if direction == 'forward': h_pos += units depth += aim * units elif direction == 'up': aim -= units else: aim += units return h_pos * depth
def get_instructions(): instructions = [] jump_list = [] for line in get_input_lines(FILE_NUM): instruction_type, val = line.split(' ') val = int(val) instruction_entry = [str(instruction_type), val] is_potential_jump = instruction_type in [ INST_TYPES['JUMP_TO_LINE'], INST_TYPES['NO_OPERATION'] ] instructions.append(instruction_entry) index = len(instructions) - 1 jump_list.append([index] + instruction_entry) if is_potential_jump else None return [instructions, jump_list]
def solve2_old(): tree_lines = list(get_input_lines('03')) line_length = len(tree_lines[0]) logic_list = [{ 'x': 0, 'increment_by': 1, 'check_every': 1, 'count': 0 }, { 'x': 0, 'increment_by': 3, 'check_every': 1, 'count': 0 }, { 'x': 0, 'increment_by': 5, 'check_every': 1, 'count': 0 }, { 'x': 0, 'increment_by': 7, 'check_every': 1, 'count': 0 }, { 'x': 0, 'increment_by': 1, 'check_every': 2, 'count': 0 }] for (line_index, tree_line) in enumerate(tree_lines): for logic_line in logic_list: check_modulo = logic_line['check_every'] if line_index % check_modulo != 0: continue x = logic_line['x'] logic_line['count'] += tree_line[x] == TREE_CHAR logic_line['x'] = (x + logic_line['increment_by']) % line_length return prod(map(lambda x: x.get('count'), logic_list))
def solve1(is_sample=False): lines = list(get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) crab_pos = [int(x) for x in lines[0].split(',')] unique_pos = list(set(crab_pos)) count_pos = [len([x for x in crab_pos if x == up]) for up in unique_pos] cost_pos = [] for to_pos in unique_pos: current_cost = 0 for from_index in range(len(unique_pos)): from_pos, count = unique_pos[from_index], count_pos[from_index] cost_per_unit = abs(to_pos - from_pos) current_cost += count * cost_per_unit cost_pos.append(current_cost) return min(cost_pos)
def solve2(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) total_count = 0 for line in lines: numbers: list output: list numbers, output = [[sorted(list(y)) for y in x.split(' ')] for x in line.split(' | ')] numbers.sort(key=lambda num: len(num)) relevant_numbers = get_correct_nums(numbers) total_count += int(''.join( [str(relevant_numbers.index(op)) for op in output])) pass return total_count
def solve1(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) total_count = 0 for line in lines: numbers: list output: list numbers, output = [[sorted(list(y)) for y in x.split(' ')] for x in line.split(' | ')] numbers.sort(key=lambda num: len(num)) relevant_numbers = [numbers[0], numbers[1], numbers[2], numbers[9]] # 1, 7, 4, 8 total_count += len([op for op in output if op in relevant_numbers]) pass return total_count
def solve2(is_sample=False): lines = list(get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) crab_pos = [int(x) for x in lines[0].split(',')] all_pos = [x for x in range(max(crab_pos) + 1)] count_pos = [len([x for x in crab_pos if x == up]) for up in all_pos] cost_pos = [] for to_pos in all_pos: current_cost = 0 for from_index in range(len(all_pos)): from_pos, count = all_pos[from_index], count_pos[from_index] change_per_unit = abs(to_pos - from_pos) if change_per_unit: cost_per_unit = (change_per_unit * (change_per_unit + 1)) / 2 current_cost += count * cost_per_unit cost_pos.append(current_cost) return min(cost_pos)
def solve1(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) coords = {'x': 0, 'y': 0} for line in lines: direction, units = line.split(' ') coord = 'x' is_addition = True if direction in y_moves: coord = 'y' if direction == y_moves[0]: is_addition = False if is_addition: coords[coord] += int(units) else: coords[coord] -= int(units) return coords['x'] * coords['y']
def solve1(is_sample=False): lines = list(get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) value_per_digit = [0] * len(lines[0]) count_digits = len(lines[0]) threshold = len(lines) / 2 gamma, epsilon = 0, 0 factor = 2 ** (count_digits - 1) for line in lines: values = list(map(int, line)) for i in range(0, count_digits): value_per_digit[i] += values[i] for digit in range(0, count_digits): if value_per_digit[digit] > threshold: gamma += factor else: epsilon += factor factor /= 2 return gamma * epsilon
def solve2(is_sample=False): lines = list( get_input_lines(FILE_NUM, SAMPLES_FOLDER if is_sample else None, HOME_DIR)) fishes = [int(x) for x in lines[0].split(',')] fish_counts = get_fish_counts(fishes) pending_new_fish = 0 for step in range(256): for count_index in range(len(fish_counts)): if count_index == 0: pending_new_fish = fish_counts[count_index] else: fish_counts[count_index - 1] = fish_counts[count_index] fish_counts[count_index] = 0 # moving the old fish and new fish to their new positions if pending_new_fish: fish_counts[6] += pending_new_fish fish_counts[8] += pending_new_fish pending_new_fish = 0 return sum(fish_counts)
def solve1(): numbers = list(map(int, get_input_lines(FILE_NUM))) return find_invalid_number(numbers)