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