adj = part_two_adjacents(grid, row, col) if grid[row][col] == 'L' and '#' not in adj: newrow += '#' elif grid[row][col] == '#' and adj.count('#') >= 5: newrow += 'L' else: newrow += grid[row][col] newgrid.append(newrow) return newgrid def part_two(grid: List[str]) -> int: while True: after = process_part_two_seats(grid) if after == grid: return ''.join(grid).count('#') grid = after if __name__ == '__main__': data = get_line_data("11") print(part_one(data)) print(part_two(data))
graph, source = f"0_0_{data[0][0]}", target = f"{len(data[0]) - 1}_{len(data) - 1}_{data[-1][-1]}", weight = "weight" ) total = 0 for node in path[1:]: x, y, v = node.split("_") total += int(v) return total if __name__ == '__main__': data = get_line_data("15") core_data = [list(map(int, row)) for row in data] print(f"part one: {solve(core_data)}") # multiply the core data by a factor of 5 expanded_data = core_data[:] for x in range(1, 5): temp = np.array(core_data) temp += x expanded_data = [a + b for a, b in zip(expanded_data, temp.tolist())] core_expanded_data = expanded_data[:] for x in range(1, 5):
from utils import get_line_data from numpy import prod from typing import List def get_trees(data: List[str], right: int, down: int) -> int: trees = 0 for x in range(len(data)): if (x * down <= len(data)) and (data[x * down][(x * right) % len(data[0])] == "#"): trees += 1 return trees if __name__ == '__main__': data = get_line_data("03") print(get_trees(data, 3, 1)) print( prod([ get_trees(data, right, down) for right, down in [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)] ]))
total = 0 for remainder, bus in pairs: # the base for the modular inverse base = N // bus # the actual modular inverse total += remainder * base * (pow(base, bus - 2) % bus) # modulo of the product total %= N return total if __name__ == '__main__': data = get_line_data("13") timestamp = int(data[0]) busses = [int(x) for x in data[1].split(",") if x != "x"] p1_result = part_one(timestamp, busses) print(p1_result) # remainder and the bus id busses = [(int(bus) - index, int(bus)) for index, bus in enumerate(data[1].split(",")) if bus != "x"] p2_result = part_two(busses) print(p2_result) pairs = [(index, int(bus)) for index, bus in enumerate(data[1].split(","))
def create_pocket_dimension(data: List[str], dims: int) -> PocketDimension: active_points = set() for i, row in enumerate(data): for j, status in enumerate(row): if status == '#': point = (i, j) + tuple(0 for _ in range(dims - 2)) active_points.add(point) return PocketDimension(active_points) def part_1(data: List[str]) -> int: pocket_dimension = create_pocket_dimension(data, 3) pocket_dimension.run_process() return len(pocket_dimension.active_points) def part_2(data: List[str]) -> int: pocket_dimension = create_pocket_dimension(data, 4) pocket_dimension.run_process() return len(pocket_dimension.active_points) if __name__ == '__main__': data = get_line_data("17") print(part_1(data)) print(part_2(data))
for target in path_map[current]: if target not in visited: new_visited = set(visited) if target.lower() == target: new_visited.add(target) paths.append((target, new_visited, twice)) elif target in visited and twice is None and target not in [ 'start', 'end' ]: paths.append((target, visited, target)) return answer if __name__ == '__main__': data = get_line_data("12") paths = defaultdict(list) for line in data: f, t = line.split("-") paths[f].append(t) paths[t].append(f) p1_result = part_one(paths) print(p1_result) p2_result = part_two(paths) print(p2_result)
def run_part(data: List[str], part: int): mask = None memory = collections.defaultdict(int) for line in data: op, arg = line.split(' = ') if op == 'mask': mask = arg else: mem_pos = int(op[4:-1]) if part == 1: memory[mem_pos] = run_mask(int(arg), mask) elif part == 2: for m in run_masks(mem_pos, mask): memory[m] = int(arg) return sum(memory.values()) if __name__ == '__main__': data = get_line_data("14") p1_result = run_part(data, 1) print(p1_result) p2_result = run_part(data, 2) print(p2_result)
def part_1(record: str) -> int: if len(record) < 1: return 0 start, end, letter, password = parse_line(record) if password.count(letter) >= start and password.count(letter) <= end: return 1 return 0 def part_2(record: str) -> int: if len(record) < 1: return 0 start, end, letter, password = parse_line(record) if (password[start - 1] == letter) ^ (password[end - 1] == letter): return 1 return 0 if __name__ == '__main__': data = get_line_data("02") print(sum(map(part_1, data))) print(sum(map(part_2, data)))
from utils import get_line_data from tqdm import tqdm def root(a): for i in tqdm(range(100000000)): if pow(7, i, 20201227) == a: return i if __name__ == '__main__': data = get_line_data("25") a, b = [int(i) for i in data] print(pow(a, root(b), 20201227))
pass else: new_layout[point] = 1 for point, value in adjacent_blacks.items(): if value == 2 and self.layout.get(point, 0) % 2 == 0: new_layout[point] = 1 self.layout = new_layout def part_two(data: List[str]) -> int: layout = parse_layout(data) floor = Floor(layout) for _ in range(100): floor.run_day() return sum(1 for value in floor.layout.values() if value % 2 == 1) if __name__ == '__main__': data = get_line_data("24") p1_result = part_one(data) print(p1_result) p2_result = part_two(data) print(p2_result)
def part_one(data): total = 0 for line in data: outputs = line.split(" | ")[1].split() for o in outputs: if len(set(o)) in [2, 4, 3, 7]: total += 1 return total def part_two(data): total = 0 for line in data: board = CircuitBoard(line) board.solve() total += int(board.sum_outputs()) return total if __name__ == '__main__': data = get_line_data("08") print(part_one(data)) print(part_two(data))
return sum([POINTS[key] * value for key, value in c.items()]) def part_two(data): scores = [] for line in data: if line_is_incomplete(line): cleaned = clean_line(line) rev_cleaned = cleaned[::-1] c = 0 for char in rev_cleaned: c = c * 5 + INCOMPLETE_POINTS[char] scores.append(c) scores.sort() return scores[len(scores) // 2] if __name__ == '__main__': data = get_line_data("10") p1_result = part_one(data) print(p1_result) p2_result = part_two(data) print(p2_result)
def part_two(processed_info: Dict[str, List[str]]): needs_processing = True while needs_processing: for key in processed_info.keys(): if len(processed_info[key]) == 1: for key_2 in processed_info.keys(): if key == key_2: continue processed_info[key_2].discard(list(processed_info[key])[0]) needs_processing = continue_process(processed_info) output = [] for key, value in processed_info.items(): output.append((key, list(value)[0])) output.sort(key=lambda x: x[0]) return ",".join(x[1] for x in output) if __name__ == '__main__': data = get_line_data("21") processed = process_data(data) print(part_one(data, processed)) print(part_two(processed))
if 0 <= rr < len(self.rows) and 0 <= cc < len( self.rows[0]) and self.rows[rr][cc] != 9: deque.append((rr, cc)) sizes.append(size) return sizes def part_one(data): b = Board(data) return b.find_lows() def part_two(data): b = Board(data) sizes = b.get_basin_sizes() sizes.sort() return sizes[-3] * sizes[-2] * sizes[-1] if __name__ == '__main__': data = get_line_data("09") p1_result = part_one(data) print(p1_result) p2_result = part_two(data) print(p2_result)
current = data[0] for i in data[1:]: current = add(current, i) return magnitude(current) def part_two(data): max_val = -1 for a, b in itertools.product(data, repeat=2): val = magnitude(add( a, b, )) max_val = max([max_val, val]) return max_val if __name__ == '__main__': data = get_line_data("18") data = [json.loads(x) for x in data] p1_result = part_one(data) print(p1_result) p2_result = part_two(data) print(p2_result)
from utils import get_line_data from typing import List def part_one(seat_ids: List[int]) -> int: return max(seat_ids) def part_two(seat_ids: List[int]) -> int: for x in range(min(seat_ids), max(seat_ids)): if x not in seat_ids: return x if __name__ == '__main__': data = get_line_data("05") t = str.maketrans({'B': '1', 'R': '1', 'F': '0', 'L': '0'}) seat_ids = [int(line.translate(t), 2) for line in data] print(part_one(seat_ids)) print(part_two(seat_ids))