def test_small_steps(self): start_bed = load_seabed( get_test_file_path("samples/d25/small/initial.txt")) expected_step = load_seabed( get_test_file_path("samples/d25/small/step4.txt")) stepped = do_step(do_step(do_step(do_step(start_bed)))) self.assertEqual(expected_step, stepped)
def test_stop_step(self): start_bed = load_seabed( get_test_file_path("samples/d25/stop/initial.txt")) expected_bed = load_seabed( get_test_file_path("samples/d25/stop/step1.txt")) stepped = do_step(start_bed) self.assertEqual(expected_bed, stepped)
def test_nothing_to_shunt(self): cave = load_cave( get_test_file_path("samples/d23/unfolded/mid_example.txt")) shunted = load_cave( get_test_file_path("samples/d23/unfolded/mid_example.txt")) auto_shunt(shunted) self.assertEqual(get_cave_hash(cave), get_cave_hash(shunted)) self.assertEqual(cave.total_cost, shunted.total_cost)
def test_intra_room_shunts(self): expected_shunted = load_cave( get_test_file_path("samples/d23/unfolded/shunted.txt")) cave = load_cave( get_test_file_path("samples/d23/unfolded/to_shunt.txt")) auto_shunt(cave) self.assertEqual(get_cave_hash(cave), get_cave_hash(expected_shunted)) self.assertEqual(cave.total_cost, 2001)
def test_corridor_shunt(self): expected_shunted = load_cave( get_test_file_path("samples/d23/unfolded/corridor_shunted.txt")) cave = load_cave( get_test_file_path("samples/d23/unfolded/to_corridor_shunt.txt")) auto_shunt(cave) self.assertEqual(get_cave_hash(cave), get_cave_hash(expected_shunted)) cost = 1 + 2000 + 4000 + 9000 self.assertEqual(cave.total_cost, cost)
def setUp(self) -> None: self.complete = load_cave( get_test_file_path("samples/d23/complete.txt")) self.example = load_cave( get_test_file_path("samples/d23/example1.txt")) self.corridor = load_cave( get_test_file_path("samples/d23/example_corridor.txt")) self.complete.idealised_cost = 1000 self.complete.total_cost = 1000 self.corridor.idealised_cost = 100 self.corridor.total_cost = 100 self.example.idealised_cost = 10 self.example.total_cost = 10
def test_stopper_steps(self): start_bed = load_seabed( get_test_file_path("samples/d25/stop/initial.txt")) expected_steps = { 1: load_seabed(get_test_file_path("samples/d25/stop/step1.txt")), 10: load_seabed(get_test_file_path("samples/d25/stop/step10.txt")), } stepped = start_bed for i in range(10): stepped = do_step(start_bed) if i in expected_steps: print(i) self.assertEqual(expected_steps[i], stepped)
def test_corridor(self): cave = load_cave( get_test_file_path("samples/d23/example_corridor.txt")) self.assertEqual(cave.total_cost, 0) self.assertListEqual(cave.corridor, [ None, None, None, None, None, get_desert(), None, get_desert(), None, get_amber(), None ]) self.assertEqual(cave.rooms[0].type, AmphipodType.AMBER) self.assertEqual(cave.rooms[1].type, AmphipodType.BRONZE) self.assertEqual(cave.rooms[2].type, AmphipodType.COPPER) self.assertEqual(cave.rooms[3].type, AmphipodType.DESERT) self.assertEqual(cave.rooms[0].join_index, 2) self.assertEqual(cave.rooms[1].join_index, 4) self.assertEqual(cave.rooms[2].join_index, 6) self.assertEqual(cave.rooms[3].join_index, 8) self.assertListEqual(cave.rooms[0].spaces, [get_amber(), None]) self.assertListEqual(cave.rooms[1].spaces, [get_bronze(), get_bronze()]) self.assertListEqual(cave.rooms[2].spaces, [get_copper(), get_copper()]) self.assertListEqual(cave.rooms[3].spaces, [None, None])
def test_image(self): _, image = load_image(get_test_file_path("samples/d20.txt")) expected_image = ["#..#.", "#....", "##..#", "..#..", "..###"] self.assertListEqual(expected_image, image.pixels) self.assertEqual(5, image.height) self.assertEqual(5, image.width) self.assertEqual(".", image.infinity_pixel)
def test_folded_twenty_steps(self): cave = load_cave( get_test_file_path("samples/d23/unfolded/twenty_steps.txt")) cost = 7000 + 8 + 3000 + 4 + 4 + 4000 + 40 + 11 * 1000 + 5 + 9000 cost += 70 + 600 + 50 + 60 + 40 + 5000 + 600 + 600 + 30 + 8 print(cost) self.assertEqual(find_completion_cost(cave), cost)
def test_sample_four(self): numbers = load_snail_numbers( get_test_file_path("samples/d18/sample4.txt")) expected = [[[[8, 7], [7, 7]], [[8, 6], [7, 7]]], [[[0, 7], [6, 6]], [8, 7]]] total = sn_sum(numbers) self.assertEqual(decode_to_lists(total), expected)
def test_overlapping_sample_pair(self): readouts = load_readouts( get_test_file_path("samples/d19/overlapping.txt")) rhs_frame, rhs_orientation = find_reference_frame( readouts[0], readouts[1], 12) rhs_aligned = realign_scanner(readouts[1], rhs_orientation) rhs_beacons = [ apply_reference_frame(beacon, rhs_frame) for beacon in rhs_aligned.beacons ] lhs_beacons = {beacon for beacon in readouts[0].beacons} common_beacons = { beacon for beacon in rhs_beacons if beacon in lhs_beacons } expected_beacons = { Point(x=-618, y=-824, z=-621), Point(x=-537, y=-823, z=-458), Point(x=-447, y=-329, z=318), Point(x=404, y=-588, z=-901), Point(x=544, y=-627, z=-890), Point(x=528, y=-643, z=409), Point(x=-661, y=-816, z=-575), Point(x=390, y=-675, z=-793), Point(x=423, y=-701, z=434), Point(x=-345, y=-311, z=381), Point(x=459, y=-707, z=401), Point(x=-485, y=-357, z=347) } self.assertSetEqual(common_beacons, expected_beacons)
def test_load_data(self): data = load_data_rows(get_test_file_path("samples/d09.txt")) expected = [[2, 1, 9, 9, 9, 4, 3, 2, 1, 0], [3, 9, 8, 7, 8, 9, 4, 9, 2, 1], [9, 8, 5, 6, 7, 8, 9, 8, 9, 2], [8, 7, 6, 7, 8, 9, 6, 7, 8, 9], [9, 8, 9, 9, 9, 6, 5, 6, 7, 8]] self.assertListEqual(data, expected)
def test_find_minimums(self): minimums = find_minimums( load_data_rows(get_test_file_path("samples/d09.txt"))) self.assertEqual(len(minimums), 4) self.assertEqual(minimums[0], LocalMinimum(x=1, y=0, value=1)) self.assertEqual(minimums[1], LocalMinimum(x=2, y=2, value=5)) self.assertEqual(minimums[2], LocalMinimum(x=6, y=4, value=5)) self.assertEqual(minimums[3], LocalMinimum(x=9, y=0, value=0))
def test_vars(self): lines = [ l[:-1] for l in open(get_test_file_path("samples/d03.txt")).readlines() ] vars = calc_power_vars(lines) self.assertEqual(vars.gamma, 22) self.assertEqual(vars.epsilon, 9)
def test_o2(self): lines = [ l[:-1] for l in open(get_test_file_path("samples/d03.txt")).readlines() ] vars = calc_life_vars(lines) self.assertEqual(vars.o2, 23) self.assertEqual(vars.co2, 10)
def test_pixel_indexer(self): _, image = load_image(get_test_file_path("samples/d20.txt")) self.assertEqual(get_pixel(image, -1, 0), ".") self.assertEqual(get_pixel(image, 5, 0), ".") self.assertEqual(get_pixel(image, 0, 5), ".") self.assertEqual(get_pixel(image, 0, 0), "#") self.assertEqual(get_pixel(image, 4, 4), "#") self.assertEqual(get_pixel(image, 2, 3), "#")
def test_infinity_flip(self): algo, image = load_image(get_test_file_path("samples/d20.txt")) algo.pixel_map = "#" + algo.pixel_map[1:] algo.pixel_map = algo.pixel_map[0:-1] + "." enhanced = enhance(image, algo) enhanced_again = enhance(enhanced, algo) self.assertEqual(enhanced.infinity_pixel, "#") self.assertEqual(enhanced_again.infinity_pixel, ".")
def test_load(self): loaded = load_map(get_test_file_path("samples/d15/small.txt")) map = [ [6, 3, 9], [5, 2, 1], [5, 9, 1], ] self.assertListEqual(loaded, map)
def test_initial(self): seabed = load_seabed( get_test_file_path("samples/d25/small/initial.txt")) self.assertEqual(seabed.height, 7) self.assertEqual(seabed.width, 7) self.assertListEqual(seabed.seabed, [ "...>...", ".......", "......>", "v.....>", "......>", ".......", "..vvv.." ])
def test_one_step(self): algo, image = load_image(get_test_file_path("samples/d20.txt")) enhanced = enhance(image, algo) expected = [ ".........", "..##.##..", ".#..#.#..", ".##.#..#.", ".####..#.", "..#..##..", "...##..#.", "....#.#..", "........." ] self.assertEqual(enhanced.infinity_pixel, ".") self.assertListEqual(enhanced.pixels, expected)
def test_load_map(self): cave_map = load_map(get_test_file_path("samples/d12/small_map.txt")) self.assertEqual(len(cave_map), 6) self.assertListEqual(cave_map["start"], ["A", "b"]) self.assertListEqual(cave_map["A"], ["start", "c", "b", "end"]) self.assertListEqual(cave_map["b"], ["start", "A", "d", "end"]) self.assertListEqual(cave_map["c"], ["A"]) self.assertListEqual(cave_map["d"], ["b"]) self.assertListEqual(cave_map["end"], ["A", "b"])
def test_valid_exit_completion(self): cave = load_cave(get_test_file_path("samples/d23/one_step.txt")) sorted_caves = SortedCaveList() sorted_caves.add(cave) possible_caves = get_valid_corridor_exits(sorted_caves.pop()) self.assertEqual(len(possible_caves), 1) self.assertEqual(is_complete(possible_caves[0]), True) sorted_caves.add(possible_caves[0]) self.assertEqual(sorted_caves.has_completion(), True)
def test_all_beacons(self): readouts = load_readouts( get_test_file_path("samples/d19/overlapping.txt")) scanners = readouts unique_beacons, frames = find_unique_points(scanners) self.assertEqual(len(unique_beacons), 79) self.assertEqual( get_greatest_distance([frame for _, frame in frames.items()]), 3621)
def test_expansions(self): expansions = load_map(get_test_file_path("samples/d14.txt")) self.assertEqual(apply_expansions(expansions, "NNCB"), "NCNBCHB") self.assertEqual(apply_expansions(expansions, "NCNBCHB"), "NBCCNBBBCBHCB") self.assertEqual(apply_expansions(expansions, "NBCCNBBBCBHCB"), "NBBBCNCCNBBNBNBBCHBHHBCHB") self.assertEqual( apply_expansions(expansions, "NBBBCNCCNBBNBNBBCHBHHBCHB"), "NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB")
def test_valid_exit_completion_algo(self): cave = load_cave(get_test_file_path("samples/d23/one_step.txt")) sorted_caves = SortedCaveList() sorted_caves.add(cave) for room in cave.rooms: for possible_cave in get_valid_room_exits(cave, room): sorted_caves.add(possible_cave) for possible_cave in get_valid_corridor_exits(cave): sorted_caves.add(possible_cave) self.assertEqual(sorted_caves.has_completion(), True)
def test_load_sample(self): program = load_code(get_test_file_path("samples/d10.txt")) expected_program = [ "[({(<(())[]>[[{[]{<()<>>", "[(()[<>])]({[<{<<[]>>(", "{([(<{}[<>[]}>{[]{[(<()>", "(((({<>}<{<{<>}{[]{[]{}", "[[<[([]))<([[{}[[()]]]", "[{[{({}]{}}([{[{{{}}([]", "{<[[]]>}<{[{[{[]{()[[[]", "[<(<(<(<{}))><([]([]()", "<{([([[(<>()){}]>(<<{{", "<{([{{}}[<[[[<>{}]]]>[]]" ] self.assertListEqual(expected_program, program)
def testLoad(self): input = load_input(get_test_file_path("samples/d04.txt")) self.assertListEqual(input.numbers, [7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1]) self.assertEqual(len(input.cards), 3) sample_card:BingoCard = input.cards[2] for number in input.numbers[0:11]: self.assertFalse(sample_card.call_number(number)) self.assertTrue(sample_card.call_number(24)) self.assertEqual(sum(sample_card.uncalled_numbers()), 188)
def test_get_path_options_simple(self): cave_map = load_map(get_test_file_path("samples/d12/small_map.txt")) self.assertListEqual(get_path_options(cave_map, ["start", "b"]), ["A", "d", "end"]) self.assertListEqual(get_path_options(cave_map, ["start", "A"]), ["c", "b", "end"]) self.assertListEqual(get_path_options(cave_map, ["start", "b"], 2), ["A", "d", "end"]) self.assertListEqual(get_path_options(cave_map, ["start", "A"], 2), ["c", "b", "end"])
def test_example(self): cave = load_cave( get_test_file_path("samples/d23/example1.txt")) ############# #AA.......AD# ###D#B#C#.### #D#B#C#D# #A#B#C#.# #.#B#C#.# ######### self.assertEqual(find_completion_cost(cave), 12521) #self.assertEqual(0, 12521) pass