def main():
input_txt = get_input(17)
int_code_list = ints(input_txt)
code = defaultdict(int, enumerate(int_code_list))
board1 = run_robot(code)
print(f'Part 1: {len(board1)}')
def part2(lines: list[str]):
rotations = {
"L": {
90: counterclockwise_90,
180: rotate,
270: clockwise_90
},
"R": {
90: clockwise_90,
180: rotate,
270: counterclockwise_90
},
}
pos = (0, 0)
waypoint = (10, 1)
for line in lines:
cmd = line[0]
number = utils.ints(line)[0]
if cmd == "F":
pos = utils.tuple_add(pos, tuple(number * i for i in waypoint))
elif cmd in "LR":
waypoint = rotations[cmd][number](waypoint)
elif cmd in DIRECTIONS.keys():
waypoint = utils.tuple_add(
waypoint, tuple(number * i for i in DIRECTIONS[cmd]))
return abs(pos[0]) + abs(pos[1])
def get_numbers_for_index(
valid_nearby_lines: list[str]) -> dict[int, set[int]]:
positions = defaultdict(set)
for n in valid_nearby_lines:
all_numbers = utils.ints(n)
for i, x in enumerate(all_numbers):
positions[i].add(x)
return positions
def main():
input_txt = utils.get_input(5)
lines = []
for line_def in input_txt.strip().split("\n"):
x1, y1, x2, y2 = utils.ints(line_def)
lines.append(((x1, y1), (x2, y2)))
print(f"Part 1: {part1(lines)}")
print(f"Part 2: {part2(lines)}")
def __init__(self, board_input: str, done=False):
self.done = done
self.board = [[None for _ in range(5)] for _ in range(5)]
rows = board_input.strip().split("\n")
all_row_entries = [utils.ints(row) for row in rows]
# TODO: only 5x5 boards
for x in range(5):
for y in range(5):
self.board[x][y] = Number(all_row_entries[x][y])
def main():
input_txt = get_input(19)
int_code_list = ints(input_txt)
code = defaultdict(int, enumerate(int_code_list))
p1 = part1(code)
print(f"Part 1: {p1}")
p2 = part2(code)
print(f"Part 2: {p2}")
def read_ranges(ranges: str) -> dict[str, set[int]]:
valid = {}
for line in ranges.split("\n"):
name = line.split(":")[0]
valid_range = set()
a, b, c, d = map(abs, utils.ints(line))
valid_range.update(set(range(a, b + 1)))
valid_range.update(set(range(c, d + 1)))
valid[name] = valid_range
return valid
def main():
input_txt = utils.get_input(4)
sections = input_txt.split("\n\n")
drawn_numbers = utils.ints(sections[0])
boards_input = sections[1:]
boards = [Board(board_input) for board_input in boards_input]
boards2 = deepcopy(boards)
print(f"Part 1: {part1(drawn_numbers, boards)}")
print(f"Part 2: {part2(drawn_numbers, boards2)}")
def part2(my_ticket: str, ranges: dict[str, set[int]],
valid_nearby_lines: list[str]) -> int:
positions = get_numbers_for_index(valid_nearby_lines)
classification = create_index_to_name_classification(ranges, positions)
assign_index_to_unique_name(classification)
indices = [
i for i, names in classification.items()
if names and names[0].startswith("departure")
]
return math.prod([utils.ints(my_ticket)[i] for i in indices])
def main():
input_txt = utils.get_input(19).rstrip()
rules, text = input_txt.split("\n\n")
all_rules = {}
for rule_line in rules.split("\n"):
idx, rule = rule_line.split(": ")
if "|" in rule:
or_rules = rule.split("|")
or_rules = [utils.ints(x) for x in or_rules]
all_rules[int(idx)] = or_rules
elif '"' in rule:
char = rule.strip('"')
all_rules[int(idx)] = char
else:
and_rules = utils.ints(rule)
all_rules[int(idx)] = [and_rules]
messages = text.split("\n")
print(calc_valid_messages(all_rules, messages))
all_rules[8] = [[42], [42, 8]]
all_rules[11] = [[42, 31], [42, 11, 31]]
print(calc_valid_messages(all_rules, messages))
def part1(areas):
cubes = set()
for area in areas:
x1, x2, y1, y2, z1, z2 = utils.ints(area)
a = [
list(range(x1, x2 + 1)),
list(range(y1, y2 + 1)),
list(range(z1, z2 + 1))
]
triples = set(itertools.product(*a))
if area[:2] == "on":
cubes |= triples
else:
cubes -= triples
return len(cubes)
def part1(valid_ranges: dict[str, set[int]],
nearby: str) -> tuple[int, list[str]]:
not_valid = []
valid_nearby = []
valid_numbers = set().union(*valid_ranges.values())
for line in nearby.split("\n"):
all_numbers = utils.ints(line)
is_valid = True
for n in all_numbers:
if n not in valid_numbers:
not_valid.append(n)
is_valid = False
if all_numbers and is_valid:
valid_nearby.append(line)
return sum(not_valid), valid_nearby
def main():
input_txt = get_input(12)
moons = []
for line in input_txt.rstrip().split('\n'):
moon_pos = tuple(ints(line))
moon = Moon(moon_pos)
moons.append(moon)
p1 = part1(moons)
print(f'Part 1: {p1}')
loop_lengths = []
for pos_idx in range(3):
loop_length = find_loop(pos_idx, deepcopy(moons))
loop_lengths.append(loop_length)
print(loop_lengths)
p2 = np.lcm.reduce(loop_lengths)
print(f'Part 2: {p2}')
def part1(lines: list[str]):
rotations = "ESWN"
dir_ = "E"
pos = (0, 0)
for line in lines:
cmd = line[0]
number = utils.ints(line)[0]
if cmd == "F":
pos = utils.tuple_add(pos,
tuple(number * i for i in DIRECTIONS[dir_]))
elif cmd in "LR":
number = number // 90
idx = rotations.index(dir_)
m = 1 if cmd == "R" else -1
idx += m * number
dir_ = rotations[idx % 4]
elif cmd in DIRECTIONS.keys():
pos = utils.tuple_add(pos,
tuple(number * i for i in DIRECTIONS[cmd]))
return abs(pos[0]) + abs(pos[1])
def main():
input_txt = get_input(11)
int_code_list = ints(input_txt)
code = defaultdict(int, enumerate(int_code_list))
board1 = run_robot(code, 0)
board2 = run_robot(code, 1)
print(f'Part 1: {len(board1)}')
print()
print('Part 2')
width_min = min(board2.keys(), key=lambda x: x[0])[0]
width_max = max(board2.keys(), key=lambda x: x[0])[0]
height_min = min(board2.keys(), key=lambda x: x[1])[1]
height_max = max(board2.keys(), key=lambda x: x[1])[1]
for y in reversed(range(height_min, height_max + 1)):
line = ''
for x in range(width_min, width_max + 1):
if board2[(x, y)]:
line += '\u2588'
else:
line += ' '
print(line)
def main():
input_txt = utils.get_input(6)
lantern_fish = utils.ints(input_txt)
lantern_fish2 = copy.deepcopy(lantern_fish)
print(f"Part 1: {part1(lantern_fish)}")
print(f"Part 2: {part2(lantern_fish2)}")
def main():
input_txt = utils.get_input(7)
intcode = utils.ints(input_txt)
determine_phase_setting(intcode)
def main():
global INPUT
INPUT = 5
input_txt = utils.get_input(5)
intcode = utils.ints(input_txt)
calculate(intcode)
def main():
input_txt = utils.get_input(15).rstrip()
numbers = utils.ints(input_txt)
print(part1(numbers))
print(part2(numbers))
def main():
input_txt = utils.get_input(9).rstrip()
numbers = utils.ints(input_txt)
non_valid = part1(numbers)
print(non_valid)
print(part2(numbers, non_valid))
def main():
input_txt = utils.get_input(1)
depths = utils.ints(input_txt)
print(part1(depths))
print(part2(depths))
def main():
input_txt = utils.get_input(7)
positions = utils.ints(input_txt)
print(f"Part 1: {part1(positions)}")
print(f"Part 2: {part2(positions)}")
def main():
input_txt = utils.get_input(1)
amounts = utils.ints(input_txt)
print(part1(amounts))
print(part2(amounts))
def main():
input_txt = utils.get_input(9)
int_code_list = utils.ints(input_txt)
code = defaultdict(int, enumerate(int_code_list))
determine_phase_setting(code)