import aoc
f = open('4.txt')
lines = f.readlines()
f.close()
def part_one():
num_good = 0
for line in lines:
words = line.rstrip('\n').split(' ')
intern_table = {w: True for w in words}
if len(words) == len(intern_table):
num_good = num_good + 1
return num_good
def part_two():
num_good = 0
for line in lines:
words = line.rstrip('\n').split(' ')
intern_table = {''.join(sorted(w)): True for w in words}
if len(words) == len(intern_table):
num_good = num_good + 1
return num_good
aoc.run(part_one, part_two)
15 XDBXC, 2 LTCX, 1 VRPVC => 6 ZLQW
13 WPTQ, 10 LTCX, 3 RJRHP, 14 XMNCP, 2 MZWV, 1 ZLQW => 1 ZDVW
5 BMBT => 4 WPTQ
189 ORE => 9 KTJDG
1 MZWV, 17 XDBXC, 3 XCVML => 2 XMNCP
12 VRPVC, 27 CNZTR => 2 XDBXC
15 KTJDG, 12 BHXH => 5 XCVML
3 BHXH, 2 VRPVC => 7 MZWV
121 ORE => 7 VRPVC
7 XCVML => 6 RJRHP
5 BHXH, 4 VRPVC => 5 LTCX""",
]
test_result_part1 = ["13312", "180697", "2210736"]
test_result_part2 = ["82892753", "5586022", "460664"]
def prepare_data(self, data):
receipts = []
for line in data.splitlines():
receipts.append(Receipt.from_string(line))
return System(receipts)
def run_part1(self, system: System):
return str(system.make("FUEL", 1))
def run_part2(self, system: System):
goal = 1_000_000_000_000
return str(system.make_max(goal))
run(obj=Day14())
L = data.find_object("L")
COM = data
return "%d,%d,%d,%d" % (D.depth, L.depth, COM.depth,
data.count_orbits())
return str(data.count_orbits())
def run_part2(self, data):
if self.test_mode:
you_center = data.find_object("K")
san_center = data.find_object("I")
else:
you_center = data.find_object("YOU").center
san_center = data.find_object("SAN").center
you_centers = you_center.centers
san_centers = san_center.centers
# Find 1st common parent
common_center = None
for center in you_centers:
if center in san_centers:
common_center = center
break
# Distance between each center and the common parent
dist = you_centers.index(common_center) + san_centers.index(
common_center)
return str(dist)
run(obj=Day06())
cnt = Counter(screen.values())
return str(cnt[Tile.BLOCK])
def run_part2(self, computer):
computer = computer.copy()
computer.break_on_input = True
computer.mem[0] = 2
game = Game(computer)
debug = False
while not game.program.halted:
game.step()
if debug:
click.clear()
game.draw()
time.sleep(0.025)
# Super-smart AI, totally powered by deep learning
joystick_pos = 0
if game.ball_x < game.paddle_x:
joystick_pos = -1
elif game.ball_x > game.paddle_x:
joystick_pos = +1
game.program.inputs.append(joystick_pos)
return str(game.score)
run(obj=Day13())
hgt:59cm ecl:zzz
eyr:2038 hcl:74454a iyr:2023
pid:3556412378 byr:2007""",
"""pid:087499704 hgt:74in ecl:grn iyr:2012 eyr:2030 byr:1980
hcl:#623a2f
eyr:2029 ecl:blu cid:129 byr:1989
iyr:2014 pid:896056539 hcl:#a97842 hgt:165cm
hcl:#888785
hgt:164cm byr:2001 iyr:2015 cid:88
pid:545766238 ecl:hzl
eyr:2022
iyr:2010 hgt:158cm hcl:#b6652a ecl:blu byr:1944 eyr:2021 pid:093154719""",
]
test_result_part2 = [0, 4]
def prepare_data(self, data: str) -> List[Passport]:
return [Passport.from_kv_str(block) for block in data.split("\n\n")]
def run_part1(self, data: List[Passport]):
return sum(1 for p in data if p.is_valid_p1)
def run_part2(self, data):
return sum(1 for p in data if p.is_valid_p2)
if __name__ == "__main__":
run(obj=Day04())
"3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0",
"3,23,3,24,1002,24,10,24,1002,23,-1,23,101,5,23,23,1,24,23,23,4,23,99,0,0",
"3,31,3,32,1002,32,10,32,1001,31,-2,31,1007,31,0,33,1002,33,7,33,1,33,31,31,1,32,31,31,4,31,99,0,0,0",
]
test_result_part1 = ["43210", "54321", "65210"]
test_data_part2 = [
"3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5",
"3,52,1001,52,-5,52,3,53,1,52,56,54,1007,54,5,55,1005,55,26,1001,54,"
"-5,54,1105,1,12,1,53,54,53,1008,54,0,55,1001,55,1,55,2,53,55,53,4,"
"53,1001,56,-1,56,1005,56,6,99,0,0,0,0,10",
]
test_result_part2 = ["139629729", "18216"]
def run_amps(self, data, settings_range, loop):
max_signal = -1e6
for settings in it.permutations(settings_range, 5):
amps = Amplifiers(data, settings)
output = amps.run_loop() if loop else amps.run_once()
max_signal = max(max_signal, output)
return str(max_signal)
def run_part1(self, data):
return self.run_amps(data, range(5), False)
def run_part2(self, data):
return self.run_amps(data, range(5, 10), True)
run(obj=Day07())
class Day09(IntcodePuzzle):
test_data_extra = [
"109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99",
"104,1125899906842624,99",
]
test_result_extra = [
"109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99",
"1125899906842624",
]
def test_extra(self, data):
data.run()
return ",".join(str(o) for o in data.outputs)
def run_part1(self, data):
data = data.copy()
data.inputs = [1]
data.run()
return str(data.outputs[0])
def run_part2(self, data):
data = data.copy()
data.inputs = [2]
data.run()
return str(data.outputs[0])
run(obj=Day09())
)
@property
def is_valid_p1(self) -> bool:
return self.v1 <= self.password.count(self.char) <= self.v2
@property
def is_valid_p2(self) -> bool:
ok1 = self.password[self.v1 - 1] == self.char
ok2 = self.password[self.v2 - 1] == self.char
return ok1 ^ ok2
class Day02(Puzzle):
test_data = ["1-3 a: abcde\n1-3 b: cdefg\n2-9 c: ccccccccc"]
test_result_part1 = [2]
test_result_part2 = [1]
def prepare_data(self, data):
return [Password.from_line(line) for line in data.splitlines()]
def run_part1(self, data):
return sum(1 for password in data if password.is_valid_p1)
def run_part2(self, data):
return sum(1 for password in data if password.is_valid_p2)
if __name__ == "__main__":
run(obj=Day02())
]
test_result_part1 = ["179", "1940"]
test_result_part2 = ["2772", "4686774924"]
def prepare_data(self, data):
lines = data.splitlines()
moons = []
steps = 1000
if lines[0].startswith("steps="):
steps = int(lines.pop(0)[6:])
for line in lines:
comps = line.split(",")
coords = [int(comp.split("=")[1].rstrip(">")) for comp in comps]
moons.append(Moon(Vec3(*coords)))
return System(moons, steps)
def run_part1(self, data):
for step in range(data.max_steps):
data.step()
return str(data.total_energy)
def run_part2(self, data):
return str(data.find_cycle())
run(obj=Day12())
.#...##..#.
..#.##.....
.#.#.#....#
.#........#
#.##...#...
#...##....#
.#..#...#.#"""
]
test_result_part1 = [7]
test_result_part2 = [336]
def prepare_data(self, data) -> Map:
map_ = Map(0, 0, set())
for line in data.splitlines():
map_.add_line(line)
return map_
def run_part1(self, data: Map):
return data.count_trees(3, 1)
def run_part2(self, data: Map):
slopes = ((1, 1), (3, 1), (5, 1), (7, 1), (1, 2))
res = 1
for right, down in slopes:
res *= data.count_trees(right, down)
return res
if __name__ == "__main__":
run(obj=Day03())
npos = direc.move(pos)
if npos in empties:
new_oxys.add(npos)
empties.remove(npos)
oxys = new_oxys
return minutes
class Day15(IntcodePuzzle):
def run_part1(self, computer: Computer):
computer = computer.copy()
computer.break_on_output = True
robot = Robot(computer)
steps = robot.explore_for_oxygen()
return str(len(steps))
def run_part2(self, computer: Computer):
computer = computer.copy()
computer.break_on_output = True
robot = Robot(computer)
robot.explore_all()
minutes = robot.fill_oxygen()
return str(minutes)
if __name__ == "__main__":
run(obj=Day15())
class Day17(IntcodePuzzle):
def run_part1(self, computer):
computer = computer.copy()
computer.run()
intersections = find_intersections(computer.outputs)
return str(sum(x * y for (x, y) in intersections))
def run_part2(self, computer):
step1 = computer.copy()
step1.run()
scaffolds = list(find_scaffolds(step1.outputs))
path = find_path(scaffolds)
# print()
# print_outputs(step1.outputs)
# print(to_str(path))
a, b, c, seq = find_moves(path)
inputs = "\n".join(to_str(s) for s in (seq, a, b, c)) + "\nn\n"
step2 = computer.copy()
step2.mem[0] = 2
step2.inputs = [ord(c) for c in inputs]
step2.run()
return str(step2.outputs[-1])
run(obj=Day17())
#!/usr/bin/env python3
from aoc import IntcodePuzzle, run
class Day05(IntcodePuzzle):
def run_part1(self, data):
data = data.copy()
data.inputs = [1]
data.run()
for n in range(len(data.outputs) - 1):
assert data.outputs[n] == 0
return str(data.outputs[-1])
def run_part2(self, data):
data = data.copy()
data.inputs = [5]
data.run()
return str(data.outputs[0])
run(obj=Day05())
max_x = max(self.painted.keys(), key=lambda p: p[0])[0]
min_y = min(self.painted.keys(), key=lambda p: p[1])[1]
max_y = max(self.painted.keys(), key=lambda p: p[1])[1]
out = "\n"
for y in range(min_y, max_y + 1):
for x in range(min_x, max_x + 1):
color = self.painted.get((x, y), 0)
out += BLACK if color == 1 else WHITE
out += "\n"
return out.rstrip()
class Day11(IntcodePuzzle):
def run_part1(self, computer):
robot = HullPaintingRobot(computer.copy())
robot.program.break_on_output = True
robot.run()
return str(len(robot.painted))
def run_part2(self, computer):
robot = HullPaintingRobot(computer)
robot.program.break_on_output = True
robot.painted[(0, 0)] = 1
robot.run()
return robot.get_picture()
run(obj=Day11())
def full_fuel(mass: int) -> int:
"""Calculate fuel required to launch a module + its fuel.
>>> full_fuel(12)
2
>>> full_fuel(1969)
966
>>> full_fuel(100756)
50346
"""
total_fuel = 0
extra = fuel(mass)
while extra > 0:
total_fuel += extra
extra = fuel(extra)
return total_fuel
class Day01(Puzzle):
def prepare_data(self, data):
return [int(line) for line in data.splitlines()]
def run_part1(self, data):
return str(sum(fuel(m) for m in data))
def run_part2(self, data):
return str(sum(full_fuel(m) for m in data))
run(obj=Day01())
TEST_MAP_1,
TEST_MAP_2,
TEST_MAP_3,
]
test_result_part1 = ["8", "33", "210"]
test_data_part2 = [TEST_MAP_3]
test_result_part2 = ["802"]
def prepare_data(self, raw_data):
return Map.from_text(raw_data)
def run_part1(self, data):
return str(data.find_best_spot()[1])
def run_part2(self, data):
shot, last = 0, None
loss = data.find_best_spot()[2]
loss.sort(key=lambda l: l.angle)
while True:
for los in loss:
if los.asteroids:
last = los.asteroids.pop(0)
shot += 1
if shot == 200:
return str(100 * last.x + last.y)
run(obj=Day10())
res = ""
for y in range(int(self.height / 2)):
for x in range(int(self.width / 2)):
arr = (
self.get_color(x * 2, y * 2),
self.get_color(x * 2 + 1, y * 2),
self.get_color(x * 2, y * 2 + 1),
self.get_color(x * 2 + 1, y * 2 + 1),
)
res += PIXELS[arr]
res += "\n"
return res.rstrip()
class Day08(Puzzle):
def prepare_data(self, data):
int_data = [int(c) for c in data.strip()]
return Image.from_list(int_data, 25, 6)
def run_part1(self, data):
idx = data.find_idx_fewest_0()
cnt = data.counters[idx]
res = cnt[1] * cnt[2]
return str(res)
def run_part2(self, data):
return "\n" + data.decode_mini()
run(obj=Day08())
matrix = np.matrix([
list(it.islice(pattern(pos), 1,
len(data) + 1)) for pos in range(1,
len(data) + 1)
], )
vec = np.array(data)
for _ in range(100):
vec = np.array(matrix @ vec)
vec = np.abs(vec[0]) % 10
return "".join(map(str, vec[:8]))
def run_part2(self, data: List[int]) -> str:
data = data * 10000
offset = int("".join(map(str, data[:7])))
assert offset >= (len(data) // 2)
# We only care about data starting at offset!
data = data[:offset - 1:-1]
vec = array.array("b", data)
vec[0] = vec[0] % 10
for phase in range(100):
cday16.fft2_phase(vec)
res = vec[:-9:-1]
return "".join(map(str, res))
run(obj=Day16())
