def test_execute_instructions(self):
samples_lines = data_lines(2018, "day_16_A_mine.txt")
instructions_mapping = find_instruction_ids(samples_lines)
processor = Processor(registers=[0, 0, 0, 0])
for program_line in data_lines(2018, "day_16_B_mine.txt"):
instruction = list(map(int, program_line.split()))
instruction_id = instruction[0]
instruction_code = instructions_mapping[instruction_id]
args = instruction[1:]
getattr(processor, instruction_code)(*args)
self.assertListEqual([649, 3, 2, 1], processor.registers)
def test_mine(self):
sky = SkyMap()
for point_str in data_lines(2018, "day_10_mine.txt"):
point = SkyPoint.parse(point_str)
sky.add(point)
self.assertEqual(328, sky.size())
solver = SkySolver(sky, sample_size=10)
surface, iteration, table = solver.solve()
self.assertEqual(620, surface)
self.assertEqual(10605, iteration)
self.assertEqual([
'##### # # ### # # ### ## ###### # #',
'# # # # # # # # # # # # #',
'# # # # # # # # # # # # # ',
'# # # # # # # # # # # # # ',
'##### ## # ## # # # ##### ## ',
'# # ## # ## # ###### # ## ',
'# # # # # # # # # # # # # ',
'# # # # # # # # # # # # # # # ',
'# # # # # # # # # # # # # # #',
'##### # # ### # # ### # # ###### # #',
], list(table))
def test_calculate_time_mine(self):
manual = InstructionManual()
for line in data_lines(2018, 'day_07_mine.txt'):
manual.add(line)
self.assertEqual(1107, manual.calculate_time(num_workers=5))
def test_mine(self):
self.maxDiff = None
example_lines = data_lines(2018, 'day_24_mine.txt')
groups = list(parse(example_lines))
expected = {
"Immune System: 1514 units, 8968 hp, 57 x bludgeoning, weak ['cold'], initiative 9",
"Immune System: 2721 units, 6691 hp, 22 x slashing, weak ['cold'], initiative 15",
"Immune System: 1214 units, 10379 hp, 69 x fire, immune ['bludgeoning'], initiative 16",
"Immune System: 2870 units, 4212 hp, 11 x radiation, initiative 12",
"Immune System: 1239 units, 5405 hp, 37 x cold, weak ['cold'], initiative 18",
"Immune System: 4509 units, 4004 hp, 8 x slashing, weak ['cold'], immune ['radiation'], initiative 20",
"Immune System: 3369 units, 10672 hp, 29 x cold, weak ['slashing'], initiative 11",
"Immune System: 2890 units, 11418 hp, 30 x cold, weak ['fire'], immune ['bludgeoning'], initiative 8",
"Immune System: 149 units, 7022 hp, 393 x radiation, weak ['slashing'], initiative 13",
"Immune System: 2080 units, 5786 hp, 20 x fire, weak ['fire'], immune ['slashing', 'bludgeoning'], initiative 7",
"Infection: 817 units, 47082 hp, 115 x cold, immune ['slashing', 'radiation', 'bludgeoning'], initiative 3",
"Infection: 4183 units, 35892 hp, 16 x bludgeoning, initiative 1",
"Infection: 7006 units, 11084 hp, 2 x fire, initiative 2",
"Infection: 4804 units, 25411 hp, 10 x cold, initiative 14",
"Infection: 6262 units, 28952 hp, 7 x slashing, weak ['fire'], initiative 10",
"Infection: 628 units, 32906 hp, 99 x radiation, weak ['slashing'], initiative 4",
"Infection: 5239 units, 46047 hp, 14 x bludgeoning, immune ['fire'], initiative 6",
"Infection: 1173 units, 32300 hp, 53 x bludgeoning, weak ['cold', 'slashing'], initiative 19",
"Infection: 3712 units, 12148 hp, 5 x slashing, weak ['slashing'], immune ['cold'], initiative 17",
"Infection: 334 units, 43582 hp, 260 x cold, weak ['cold', 'fire'], initiative 5",
}
self.assertSetEqual(expected, {repr(g) for g in groups})
def test_sum_numbers_mine(self):
lines = data_lines(2018, "day_12_mine.txt")
pots, rules = parse_input(lines)
for _ in range(0, 20):
pots.iterate(rules)
self.assertEqual(6201, pots.sum_numbers())
def parse_initial_state(self, filename):
for i, line in enumerate(data_lines(2018, filename)):
for j, c in enumerate(line.rstrip()):
position = (i, j)
if c == "+":
self._intersections.add(position)
elif c == ">":
self._carts[position] = Directions.right, 0
elif c == "<":
self._carts[position] = Directions.left, 0
elif c == "^":
self._carts[position] = Directions.up, 0
elif c == "v":
self._carts[position] = Directions.down, 0
elif c == "\\":
self._bends[position] = {
Directions.left: Directions.up,
Directions.right: Directions.down,
Directions.up: Directions.left,
Directions.down: Directions.right,
}
elif c == "/":
self._bends[position] = {
Directions.left: Directions.down,
Directions.right: Directions.up,
Directions.up: Directions.right,
Directions.down: Directions.left,
}
elif c not in ["-", "|", " "]:
raise RuntimeError("Unknown track item", c)
def test_mine(self):
program = Program(
num_registers=6,
input_lines=data_lines(2018, "day_19_mine.txt"),
processor_class=JumpingProcessor,
)
program.execute(10000000)
self.assertEqual(2072, program.processor.registers[0])
def test_resource_value_mine(self):
lines = data_lines(2018, "day_18_mine.txt")
woodland = Woodlands(input_lines=lines)
for _ in range(10):
woodland.iterate()
self.assertEqual(678529, woodland.resource_value())
def read_network(filename):
network = {}
for line in data_lines(2017, filename):
program_id_str, contacts_str = line.split(" <-> ")
program_id = int(program_id_str)
contact_list_str = contacts_str.split(", ")
contacts = map(int, contact_list_str)
network[program_id] = list(contacts)
return network
def test_mine(self):
lines = data_lines(2018, "day_17_mine.txt")
caves = WaterCaves(lines)
caves.fill_with_water()
self.assertEqual(31667, caves.count_water())
caves.clear_draining_water()
self.assertEqual(25018, caves.count_water())
def test_simulate_mine(self):
lines = data_lines(2018, 'day_24_mine.txt')
groups = list(parse(lines))
surviving_groups = simulate(groups)
self.assertTrue(all("Infection" == g.army for g in surviving_groups))
self.assertEqual(30881, sum(g.units for g in surviving_groups))
def test_find_magic_id(self):
self.assertEqual(None, find_magic_id(
["abcde", "fghik", "klmno", "pqrst", "fguij", "axcye", "wvxyz"]))
self.assertEqual("fgij", find_magic_id(
["abcde", "fghij", "klmno", "pqrst", "fguij", "axcye", "wvxyz"]))
id_list = list(data_lines(2018, "day_02_mine.txt"))
self.assertEqual("jiwamotgsfrudclzbyzkhlrvp", find_magic_id(id_list))
def test_example(self):
labyrinth_lines = data_lines(2017, "day_19_example.txt")
labyrinth = Labyrinth(labyrinth_lines)
walker = Walker(labyrinth)
walker.walk()
self.assertEqual("ABCDEF", walker.word())
self.assertEqual(38, walker.steps())
def test_mine(self):
labyrinth_lines = data_lines(2017, "day_19_mine.txt")
labyrinth = Labyrinth(labyrinth_lines)
walker = Walker(labyrinth)
walker.walk()
self.assertEqual("PBAZYFMHT", walker.word())
self.assertEqual(16072, walker.steps())
def test_options_per_sample(self):
all_lines = data_lines(2018, "day_16_A_mine.txt")
samples = list(parse_samples(all_lines))
self.assertEqual(779, len(samples))
all_matches = map(matching_instructions, samples)
big_matches = filter(lambda matches: len(list(matches)) >= 3,
all_matches)
self.assertEqual(531, len(list(big_matches)))
def test_sum_numbers_mine_long(self):
lines = data_lines(2018, "day_12_mine.txt")
pots, rules = parse_input(lines)
seen = {}
for i in range(0, 92):
pots.iterate(rules)
# From here, all iterations are only shifting the whole plantation right
pots._offset -= (50000000000 - 92)
self.assertEqual(9300000001023, pots.sum_numbers())
def test_simulate_example(self):
example_lines = data_lines(2018, 'day_24_example.txt')
groups = list(parse(example_lines))
surviving_groups = simulate(groups)
self.assertEqual(2, len(surviving_groups))
self.assertTrue(all("Infection" == g.army for g in surviving_groups))
self.assertSetEqual({782, 4434}, {g.units for g in surviving_groups})
self.assertEqual(5216, sum(g.units for g in surviving_groups))
def test_iterate_mine(self):
lines = data_lines(2018, "day_12_mine.txt")
pots, rules = parse_input(lines)
for _ in range(0, 20):
pots.iterate(rules)
self.check_pots(
pots, 1, 120, 101,
"#######.###.#####.#####.#.##.##.###.#.####.######.#.#######.#.####.##.##.###.##.###"
+ "#####################################")
def test_mine_again(self):
program = Program(
num_registers=6,
input_lines=data_lines(2018, "day_19_mine.txt"),
initial_registers=[1, 0, 0, 0, 0, 0],
processor_class=JumpingProcessor,
)
program.execute(34)
self.assertEqual(2072, program.processor.registers[0])
def test_execute_mine(self):
lines = data_lines(2016, "day_10_mine.txt")
bots = ZoomingBots(lines)
bots.execute()
self.assertEqual(('bot', 147), bots.find_comparator(17, 61))
outputs = [bots.get_output(i) for i in range(3)]
self.assertEqual(55637, reduce(mul, outputs))
def test_execute_program(self):
program = Program(
num_registers=6,
input_lines=data_lines(2018, "day_21_mine.txt"),
initial_registers=[1024276, 0, 0, 0, 0, 0],
processor_class=JumpingProcessor,
)
program.execute(10000, log=False)
self.assertEqual(1848, program.total_instructions)
def test_solve_closest_mine(self):
lines = data_lines(2018, 'day_06_mine.txt')
pairs = [line.split(', ') for line in lines]
coordss = [tuple(map(int, pair)) for pair in pairs]
landing = ClosestLandingArea()
for i, coords in enumerate(coordss):
landing.add(i, coords)
self.assertEqual(43302, landing.solve())
def test_find_all_constellations(self):
expected_counts = [2, 4, 3, 8]
for i, example in enumerate(examples):
points = parse(examples[i])
constellations = list(find_all_constellations(points))
self.assertEqual(expected_counts[i], len(constellations))
my_lines = data_lines(2018, "day_25_mine.txt")
my_points = parse(my_lines)
my_constellations = list(find_all_constellations(my_points))
self.assertEqual(420, len(my_constellations))
def test_find_sequence_mine(self):
manual = InstructionManual()
for line in data_lines(2018, 'day_07_mine.txt'):
manual.add(line)
self.assertEqual(26, manual.num_steps())
self.assertEqual(101, manual.num_instructions())
self.assertEqual("BDHNEGOLQASVWYPXUMZJIKRTFC",
"".join(manual.find_sequence()))
def test_find_best_minute_guard(self):
journal = GuardsJournal()
self._add_simple_entries(journal)
self._add_more_entries(journal)
self.assertEqual(("2", 12, 3), journal.find_best_minute_guard())
myjournal = GuardsJournal()
for entry_line in data_lines(2018, "day_04_mine.txt"):
myjournal.add(entry_line.strip())
self.assertEqual(("1097", 21, 15), myjournal.find_best_minute_guard())
self.assertEqual(23037, 1097 * 21)
def test_execute_example(self):
lines = data_lines(2016, "day_10_example.txt")
bots = ZoomingBots(lines)
bots.execute()
for (type, id), data in bots.nodes.items():
if type == 'output':
self.assertEqual(1, len(data['values']))
elif type == 'bot':
self.assertEqual(2, len(data['values']))
self.assertEqual(('bot', 2), bots.find_comparator(2, 5))
def test_find_best_guard_best_minute(self):
journal = GuardsJournal()
self._add_simple_entries(journal)
self._add_more_entries(journal)
self.assertEqual(("1", 31, 10), journal.find_best_guard_best_minute())
myjournal = GuardsJournal()
for entry_line in data_lines(2018, "day_04_mine.txt"):
myjournal.add(entry_line.strip())
self.assertEqual(("727", 449, 49),
myjournal.find_best_guard_best_minute())
self.assertEqual(35623, 727 * 49)
def test_add_entry(self):
journal = GuardsJournal()
journal.add("[1518-11-01 00:00] Guard #10 begins shift")
self.assertEqual(1, journal.size())
journal.add("[1518-11-01 00:05] falls asleep")
self.assertEqual(2, journal.size())
journal.add("[1518-11-01 00:25] wakes up")
self.assertEqual(3, journal.size())
myjournal = GuardsJournal()
for entry_line in data_lines(2018, "day_04_mine.txt"):
myjournal.add(entry_line.strip())
self.assertEqual(1097, myjournal.size())
def test_count_overlaps(self):
cls = ClaimsList()
cls.add("#1 @ 1,3: 4x4")
cls.add("#2 @ 3,1: 4x4")
cls.add("#3 @ 5,5: 2x2")
self.assertEqual(4, cls.count_overlaps())
claims_list = data_lines(2018, "day_03_mine.txt")
claims_mine = ClaimsList()
for claim_string in claims_list:
claims_mine.add(claim_string.strip())
self.assertEqual(110389, claims_mine.count_overlaps())
def test_find_non_overlapped(self):
cls = ClaimsList()
cls.add("#1 @ 1,3: 4x4")
cls.add("#2 @ 3,1: 4x4")
cls.add("#3 @ 5,5: 2x2")
self.assertEqual([3], cls.find_non_overlapped())
claims_list = data_lines(2018, "day_03_mine.txt")
claims_mine = ClaimsList()
for claim_string in claims_list:
claims_mine.add(claim_string.strip())
self.assertEqual([552], claims_mine.find_non_overlapped())
