def main() -> None:
count = 0
for line in aoc.get_lines(2):
if line:
password_format, password = line.split(": ")
amounts, character = password_format.split(" ")
minimal_count, maximal_count = [
int(number) for number in amounts.split("-")
]
if minimal_count <= password.count(character) <= maximal_count:
count += 1
print(count)
count = 0
for line in aoc.get_lines(2):
if line:
password_format, password = line.split(": ")
positions, character = password_format.split(" ")
first_position, last_position = [
int(number) - 1 for number in positions.split("-")
]
if len(password) > last_position and (
(password[first_position] == character)
^ (password[last_position] == character)
):
count += 1
print(count)
def main() -> None:
ship = Ship(aoc.get_lines(12))
ship.run()
print(ship.manhattan_distance)
ship = Ship(aoc.get_lines(12))
ship.run2()
print(ship.manhattan_distance)
def main() -> None:
lines = aoc.get_lines(13)
# lines = "939\n7,13,x,x,59,x,31,19".split("\n")
timestamp = int(lines[0])
buses = [int(bus) for bus in lines[1].split(",") if bus != "x"]
earliest_departure = timestamp
min_bus = min(buses, key=lambda bus: bus - (earliest_departure % bus))
total_wait = min_bus - earliest_departure % min_bus
result = min_bus * total_wait
print(f"{earliest_departure=} {min_bus=} {total_wait=} {result=}")
offsets = {
bus: offset
for offset, bus in enumerate(
[int(bus) if bus != "x" else None for bus in lines[1].split(",")]
)
if bus is not None
}
print("\nPart 2")
print(buses)
jump = 1
time = 0
for bus in buses:
print(f"Fixing bus {bus}")
offset = offsets[bus]
while (not (time + offset) % bus == 0) or time == 0:
time += jump
jump *= bus
print(time)
def main() -> None:
board = [line for line in aoc.get_lines(3) if line]
def is_tree(x: int, y: int) -> bool:
return board[y][x % len(board[0])] == "#"
def count_trees(dx: int, dy: int) -> int:
x = 0
y = 0
tree_count = 0
while 1:
x += dx
y += dy
if y >= len(board):
break
tree_count += is_tree(x, y)
return tree_count
accumulator = 1
for dx, dy in [[1, 1], [3, 1], [5, 1], [7, 1], [1, 2]]:
result = count_trees(dx, dy)
print(f"- Right {dx}, down {dy}: {result}")
accumulator *= result
print(f"==> {accumulator}")
def main() -> None:
cpu = CPU(aoc.get_lines(8))
cpu.run()
print(f"Found with at accumulator at {cpu.accumulator}.")
for index in range(len(cpu.instructions)):
if cpu.try_fix(index):
break
print(
f"FOUND: Instruction #{index}, accumulator is now {cpu.accumulator}.")
def main() -> None:
for line in aoc.get_lines(7):
Rule(line)
print(
len([
rule for rule in Rule.all_rules.values()
if rule.contains_shiny_gold
]))
print(Rule.all_rules["shiny gold"].contained_bags)
def main():
assert run(get_lines('d01.example')) == 241861950
return run(get_lines('d01'))
def main():
assert run(get_lines('d08.example')) == 8
return run(get_lines('d08'))
def main():
assert run(get_lines('d11.example')) == 26
return run(get_lines('d11'))
def main():
assert run(get_lines('d09.example'), 127) == 62
return run(get_lines('d09'), 57195069)
def main():
assert run(get_lines('d01.example')) == 514579
return run(get_lines('d01'))
def main():
assert run(get_lines('d03.example')) == 7
return run(get_lines('d03'))
def main():
assert get_seat_id('BFFFBBFRRR') == 567
assert get_seat_id('FFFBBBFRRR') == 119
assert get_seat_id('BBFFBBFRLL') == 820
return run(get_lines('d05'))
def main() -> None:
print(sum(interprete(lex(tokenize(line))) for line in aoc.get_lines(18)))
print(sum(interprete2(lex(tokenize(line))) for line in aoc.get_lines(18)))
def main():
assert run(get_lines('d07.example')) == 4
return run(get_lines('d07'))
def main():
assert run(get_lines('d02.example')) == 2
return run(get_lines('d02'))
def main():
assert run(get_lines('d10.example.small')) == 8
assert run(get_lines('d10.example.large')) == 19208
return run(get_lines('d10'))
def main() -> None:
lines = aoc.get_lines(14)
memory: Dict[int, int] = {}
mask1s = 0b_0000_0000_0000_0000_0000_0000_0000_0000_0000
mask0s = 0b_1111_1111_1111_1111_1111_1111_1111_1111_1111
line_regex = re.compile(r"^([a-z]+)(?:\[(.+?)\])? = (.+)$")
for line in lines:
command, argument, value = line_regex.match(line).groups()
if command == "mem":
memory[int(argument)] = (int(value) & mask0s) | mask1s
elif command == "mask":
mask0s = 0
mask1s = 0
for character in value:
mask0s <<= 1
mask1s <<= 1
if character == "X":
mask0s |= 1
mask1s |= 0
elif character == "1":
mask0s |= 1
mask1s |= 1
elif character == "0":
mask0s |= 0
mask1s |= 0
else:
assert False, f"Invalid character {character} in mask"
else:
assert False, f"Invalid command {command}"
print(sum(memory.values()))
############################################################################
mask1s = 0b_0000_0000_0000_0000_0000_0000_0000_0000_0000
mask0s = 0b_1111_1111_1111_1111_1111_1111_1111_1111_1111
floats: List[int] = []
memory = {}
for line in lines:
command, argument, value = line_regex.match(line).groups()
if command == "mem":
write_value = int(value)
address = int(argument)
newline = "\n"
for floating_masks in more_itertools.powerset(floats):
mask = reduce(lambda a, b: a | b, floating_masks, 0)
local_address = ((int(argument) & mask0s) | mask1s) | mask
memory[local_address] = write_value
elif command == "mask":
mask0s = 0
mask1s = 0
floats = []
float_index = 0b_1_0000_0000_0000_0000_0000_0000_0000_0000_0000
for character in value:
mask0s <<= 1
mask1s <<= 1
float_index >>= 1
if character == "X":
mask0s |= 0
mask1s |= 0
floats.append(float_index)
elif character == "1":
mask0s |= 1
mask1s |= 1
elif character == "0":
mask0s |= 1
mask1s |= 0
else:
assert False, f"Invalid character {character} in mask"
else:
assert False, f"Invalid command {command}"
print(sum(memory.values()))
def main():
assert run(get_lines('d10.example.small')) == 35
assert run(get_lines('d10.example.large')) == 220
return run(get_lines('d10'))
def main():
assert run(get_lines('d07.example.2')) == 126
return run(get_lines('d07'))
def main():
assert run(get_lines('d12.example')) == 286
return run(get_lines('d12'))
