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
