\n",
@@ -5857,9 +5865,9 @@
" /* Instantiate the Animation class. */\n",
" /* The IDs given should match those used in the template above. */\n",
" (function() {\n",
- " var img_id = \"_anim_imgf3ce28f81b944cba91930deeb91dbb03\";\n",
- " var slider_id = \"_anim_sliderf3ce28f81b944cba91930deeb91dbb03\";\n",
- " var loop_select_id = \"_anim_loop_selectf3ce28f81b944cba91930deeb91dbb03\";\n",
+ " var img_id = \"_anim_img4e94c9293ab842dbbc3f168d91a7d500\";\n",
+ " var slider_id = \"_anim_slider4e94c9293ab842dbbc3f168d91a7d500\";\n",
+ " var loop_select_id = \"_anim_loop_select4e94c9293ab842dbbc3f168d91a7d500\";\n",
" var frames = new Array(1);\n",
" \n",
" frames[0] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA8AAAALQCAYAAABfdxm0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
@@ -6537,17 +6545,17 @@
" /* set a timeout to make sure all the above elements are created before\n",
" the object is initialized. */\n",
" setTimeout(function() {\n",
- " animf3ce28f81b944cba91930deeb91dbb03 = new Animation(frames, img_id, slider_id, 200.0,\n",
+ " anim4e94c9293ab842dbbc3f168d91a7d500 = new Animation(frames, img_id, slider_id, 200.0,\n",
" loop_select_id);\n",
" }, 0);\n",
" })()\n",
"\n"
],
"text/plain": [
- ""
+ ""
]
},
- "execution_count": 140,
+ "execution_count": 139,
"metadata": {},
"output_type": "execute_result"
}
@@ -6569,17 +6577,17 @@
},
{
"cell_type": "code",
- "execution_count": 142,
+ "execution_count": 141,
"id": "75434bc8-35ae-4d8b-b747-01d773472541",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "Puzzle 14.2: 1.8866 seconds, answer 6876 ok"
+ "Puzzle 14.2: 1.8721 seconds, answer 6876 ok"
]
},
- "execution_count": 142,
+ "execution_count": 141,
"metadata": {},
"output_type": "execute_result"
}
@@ -6589,6 +6597,399 @@
" most_clustered_time(robots, range(7000)))"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "08cae29b-9b07-4e8d-b2d1-f3798f6c7cd0",
+ "metadata": {},
+ "source": [
+ "# [Day 15](https://adventofcode.com/2024/day/15): Warehouse Woes\n",
+ "\n",
+ "Today's input is in two parts: the first part is a grid map describing a warehouse with walls (`#`) and boxes (`O`) and one robot (`@`). The second part is a set of instructions for how the robot moves (arrows). I'll parse the two parts into paragraphs, then parse each paragraph:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 143,
+ "id": "20be45ec-f6fc-472c-9b49-872b7334528c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+ "Puzzle input ➜ 71 strs:\n",
+ "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+ "##################################################\n",
+ "#..OO..O.O....O...O..O...O.......O...OO##....O.OO#\n",
+ "#O.#..#OOO#..O..OO...O.O.....OO..O#O#.OOO.....#..#\n",
+ "#.....O.......OO.#OO....#O.OO.O..OO.O.O.O..##....#\n",
+ "#.O....O...O#...#...OO..#..O........#O..#..O..O..#\n",
+ "#O....O...O.O..OO..OO..#OO.#OO.O......##..O..O...#\n",
+ "#..O.##..#O...O...#.#.O.O..O.#......O..#.#...O...#\n",
+ "#O.O.........O..O........OO....OO......O.....O#..#\n",
+ "...\n",
+ "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+ "Parsed representation ➜ 2 strs:\n",
+ "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+ "##################################################\n",
+ "#..OO..O.O....O...O..O...O.......O...OO##.... ...\n",
+ ">><^v><>^v<vv><<^^>>>>^^><>^<^^vvv>>><><>v^^^^<<^<^><>>>v><>>>^>><>v>v>^v>>v>>>v ...\n"
+ ]
+ }
+ ],
+ "source": [
+ "warehouse_woes = parse(15, sections=paragraphs)\n",
+ "warehouse = Grid(parse(warehouse_woes[0]))\n",
+ "arrows = cat(parse(warehouse_woes[1]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9a4aed93-5205-4946-b04c-637f3b095e4b",
+ "metadata": {},
+ "source": [
+ "### Part 1: What is the sum of all boxes' GPS coordinates after moving?\n",
+ "\n",
+ "The robot attempts to follow each instruction arrow (for example, moving East when the instruction is `>`). The robot is strong enough to push a box or a line of boxes around; that's its job. However, if a push is blocked by a wall, then neither the robot nor any boxes will move.\n",
+ "\n",
+ "The **GPS coordinate** of a box at (*x*, *y*) is *x* + 100*y*.\n",
+ "\n",
+ "I'll implement `warehouse_movement` to make the moves on a copy of the warehouse. It works by finding all boxes that might move (and the robot) with `moveables`, then if they wouldn't push into a wall, they all move (as implemented in `make_movement`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 145,
+ "id": "248d51c0-424e-4bbb-bbf4-37cdc18313e1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def gps_coordinate(box: Point) -> int: return X_(box) + 100 * Y_(box)\n",
+ "\n",
+ "def warehouse_movement(warehouse: Grid, arrows: str) -> Grid:\n",
+ " \"\"\"Return a grid in which the robot has followed `arrows`, pushing boxes around.\"\"\"\n",
+ " grid = warehouse.copy()\n",
+ " robot_pos = the(grid.findall('@'))\n",
+ " for arrow in arrows:\n",
+ " dir = arrow_direction[arrow]\n",
+ " robot_and_boxes = moveables(grid, robot_pos, dir)\n",
+ " if make_movement(grid, robot_and_boxes, dir):\n",
+ " robot_pos = add2(robot_pos, dir)\n",
+ " return grid\n",
+ "\n",
+ "def moveables(grid, start_pos: Point, dir: Vector) -> List[Point]:\n",
+ " \"\"\"The positions of moveable things (the robot and maybe boxes) going in direction from the start.\"\"\"\n",
+ " def moveable(pos): return grid[pos] in ('@', 'O')\n",
+ " return list(takewhile(moveable, grid.follow_line(start_pos, dir)))\n",
+ "\n",
+ "def make_movement(grid, to_move: List[Point], dir: Vector) -> bool:\n",
+ " \"\"\"Try to move the objects in the `to_move` positions in direction `dir`; return True if they move.\"\"\"\n",
+ " if grid[add2(to_move[-1], dir)] == '#':\n",
+ " return False\n",
+ " else:\n",
+ " for p in reversed(to_move):\n",
+ " grid[add2(p, dir)] = grid[p]\n",
+ " grid[p] = '.'\n",
+ " return True\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 146,
+ "id": "52e93218-6ac2-4cf7-aced-f4f3a3df77b5",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Puzzle 15.1: .0250 seconds, answer 1563092 ok"
+ ]
+ },
+ "execution_count": 146,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "answer(15.1, 1563092, lambda:\n",
+ " sum(map(gps_coordinate, warehouse_movement(warehouse, arrows).findall('O'))))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "84dcd7fd-0f4a-4377-b61e-22bd5a0a51a9",
+ "metadata": {},
+ "source": [
+ "### Part 2: What is the sum of all boxes' final GPS coordinates on the double-wide grid?\n",
+ "\n",
+ "In Part 2, there is another warehouse that is similar to the first, but twice as wide. Each position in each row is replaced by two copies of the contents, except that the robot is replaced by `@.` and a box, `#`, is replaced by `[]`, indicating the two halves of a box. The rules for movement are the same, except that when the robot is moving North or South and is pushing a box, that box, since it is two positions wide, can push *two* boxes if they are lined up right. (Presumably, those two boxes could then push three boxes in the next row, and so on, although the problem description did not explicitly specify that). Finally, the GPS coordinates are taken for the `[` part of the box.\n",
+ "\n",
+ "So this is mostly the same as Part 1, but the criteria of what to move is different. Here are the changes I'll make:\n",
+ "- I'll need to make the double-wide grid, which I call `warehouse2`.\n",
+ "- I'll redefine `make_movement` to check for a wall in front of *any* of the boxes, not just the last box in a line, and to handle different characters for boxes.\n",
+ "- I'll redefine `moveables` to deal with double-wide boxes.\n",
+ "\n",
+ "The redefinition s are backwards-comnpatible, which I'll demonstrate by re-running Part 1."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 148,
+ "id": "2d9afbc1-75b2-479d-81fc-fbab69d25753",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def doublewide(text: str) -> str:\n",
+ " \"\"\"Make the grid twice as wide.\"\"\"\n",
+ " return text.replace('#', '##').replace('O', '[]').replace('.', '..').replace('@', '@.')\n",
+ " \n",
+ "warehouse2 = Grid(parse(doublewide(warehouse_woes[0])))\n",
+ "\n",
+ "def make_movement(grid, to_move: Collection[Point], dir: Vector) -> bool:\n",
+ " \"\"\"Try to move the objects in the `to_move` positions in direction `dir`; return True if they move.\"\"\"\n",
+ " def go(p): return add2(p, dir)\n",
+ " if any(grid[go(p)] == '#' for p in to_move):\n",
+ " return False\n",
+ " else:\n",
+ " updates = {go(p): grid[p] for p in to_move}\n",
+ " grid.update({p: '.' for p in to_move})\n",
+ " grid.update(updates)\n",
+ " return True\n",
+ "\n",
+ "def moveables(grid, start_pos, dir) -> Set[Point]:\n",
+ " \"\"\"The positions of moveable things (robot and maybe boxes) going in direction from the start.\"\"\" \n",
+ " ahead = add2(start_pos, dir)\n",
+ " if dir in (East, West) or grid[ahead] == 'O': # Single line push\n",
+ " def moveable(pos): return grid[pos] in ('@', 'O', '[', ']')\n",
+ " return set(takewhile(moveable, grid.follow_line(start_pos, dir)))\n",
+ " else: # Potential non-linear push\n",
+ " results = {start_pos}\n",
+ " if grid[ahead] in ('[', ']'): results |= moveables(grid, ahead, dir) \n",
+ " if grid[ahead] == '[': results |= moveables(grid, add2(ahead, East), dir)\n",
+ " if grid[ahead] == ']': results |= moveables(grid, add2(ahead, West), dir)\n",
+ " return results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 149,
+ "id": "7af49bbf-dd10-4221-9096-6f548dec44c0",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Puzzle 15.1: .0292 seconds, answer 1563092 ok"
+ ]
+ },
+ "execution_count": 149,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "answer(15.1, 1563092, lambda:\n",
+ " sum(map(gps_coordinate, warehouse_movement(warehouse, arrows).findall('O'))))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 150,
+ "id": "99246602-a51e-41aa-a7e9-7cdbc8d449ca",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Puzzle 15.2: .0419 seconds, answer 1582688 ok"
+ ]
+ },
+ "execution_count": 150,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "answer(15.2, 1582688, lambda:\n",
+ " sum(map(gps_coordinate, warehouse_movement(warehouse2, arrows).findall('['))))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90cfbc5d-a701-4fc4-b46c-00fdcb78703b",
+ "metadata": {},
+ "source": [
+ "I had a frustrating time **debugging** this one; this was by far my worst performance of the year. First I had a copy/paste error in the two similar branches of `moveables2`; then I was mitakenly summing the GPS coordinates of both sides of the boxes when I should have been summing just the left sides."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b4132fb-6365-4aed-bd11-aedf560933e1",
+ "metadata": {},
+ "source": [
+ "# [Day 16](https://adventofcode.com/2024/day/16): Reindeer Maze\n",
+ "\n",
+ "Today's input is yet another 2D grid, this one a maze that reindeer run through:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 153,
+ "id": "03255fd5-95d9-4a90-b1bb-abdf6bbf1d85",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+ "Puzzle input ➜ 141 strs:\n",
+ "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+ "################################################################################################ ...\n",
+ "#.................#.................#.............#.......#...................#.......#......... ...\n",
+ "#.#.###############.#####.#####.###.#.#########.###.#.###.#.#################.#.#####.#.#.#####. ...\n",
+ "#.#.#.....#.........#...#.#...#.#.#.#.........#.....#.#...#.....#...#.........#.#.......#.#..... ...\n",
+ "###.#.###.#.#########.#.###.#.#.#.#.###.#############.#.###.###.#.###.#########.#.#####.#.###### ...\n",
+ "#...#...#...#...#...#.#.#...#...#.....#.#...#.........#...#...#.#.#...#.......#.#...#.....#..... ...\n",
+ "#.#####.#####.###.#.#.#.#.###.#######.###.#.#.###########.#####.#.#.###.#####.#.###.#.#.###.#### ...\n",
+ "#.......#...#...#.#.#.#...#...#...#.................................#...#...#...#...#.#.#.....#. ...\n",
+ "...\n"
+ ]
+ }
+ ],
+ "source": [
+ "maze = Grid(parse(16))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "74e37bd1-f994-4e98-b6ed-8469ca7f3805",
+ "metadata": {},
+ "source": [
+ "### Part 1: What is the lowest score a Reindeer could possibly get?\n",
+ "\n",
+ "The race through the maze starts at the `S` position and ends at the `E`. A reindeer is allowed to take a step forward (as long as there isn't a `#` wall there) or to turn 90 degrees right or left (the reindeer is initially facing East). The **score** for a path is one point for every forward step and 1000 points for every turn.\n",
+ "\n",
+ "We're asked to find the path with the minimmum score. My [AdventUtils](AdventUtils.ipynb) notebook already contains an `A_star_search` function for finding least-cost paths, and a `GridProblem` class. By default, a `GridProblem` counts one point for a move in any direction, so we'll have to create a subclass, `MazeSearchProblem`. This is straightforward but a bit tedious; at first I had **two bugs**: I thought that the default `is_goal` and `h` methods would work, but they assume the state is just a position; we need the state to contain the facing direction as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 155,
+ "id": "6f9aa64c-29c2-4b12-9ecf-4ed7a2efe9f9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Puzzle 16.1: .1464 seconds, answer 103512 ok"
+ ]
+ },
+ "execution_count": 155,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "State = namedtuple('State', 'pos, facing')\n",
+ "\n",
+ "def reindeer_path(maze) -> Node:\n",
+ " \"\"\"The lowest-cost path through the maze.\"\"\"\n",
+ " start, end = the(maze.findall('S')), the(maze.findall('E'))\n",
+ " problem = MazeSearchProblem(grid=maze, initial=State(start, East), goal=end)\n",
+ " return A_star_search(problem)\n",
+ "\n",
+ "class MazeSearchProblem(GridProblem):\n",
+ " \"\"\"A GridProblem where a turn costs 1000 points, a step ahead 1.\"\"\"\n",
+ " \n",
+ " def actions(self, state):\n",
+ " ahead = add2(state.pos, state.facing)\n",
+ " return ['L', 'R'] + ([ahead] if self.grid[ahead] != '#' else [])\n",
+ " \n",
+ " def result(self, state, action) -> State:\n",
+ " if action in ('L', 'R'):\n",
+ " return State(state.pos, make_turn(state.facing, action))\n",
+ " else:\n",
+ " return State(add2(state.pos, state.facing), state.facing)\n",
+ " \n",
+ " def action_cost(self, s1, action, s2) -> int: return 1000 if action in ('L', 'R') else 1\n",
+ "\n",
+ " def is_goal(self, state) -> bool: return self.grid[state.pos] == 'E'\n",
+ "\n",
+ " def h(self, node) -> int: return taxi_distance(node.state.pos, self.goal)\n",
+ "\n",
+ "answer(16.1, 103512, lambda:\n",
+ " reindeer_path(maze).path_cost)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "030e5786-cd2a-405f-b4d4-460cefab7e32",
+ "metadata": {},
+ "source": [
+ "### Part 2: How many tiles are part of at least one of the best paths through the maze?\n",
+ "\n",
+ "In Part 2 we're asked to find the total number of positions that are part of *any* best path from start to end. I'll rewrite `best_first_search` to yield all the paths on the frontier that have the same cost as the best path. I thought this was straightforward, but I had **another bug** where I forgot to change the `<` to a `<=` in the third-to-last line of `all_paths_best_first_search`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 157,
+ "id": "692abfea-f9c8-477c-8369-386cdd2a7606",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def reindeer_best_positions(maze) -> Node:\n",
+ " \"\"\"All the positions on any best path from start to end.\"\"\"\n",
+ " start, end = the(maze.findall('S')), the(maze.findall('E'))\n",
+ " problem = MazeSearchProblem(grid=maze, initial=State(start, East), goal=end)\n",
+ " paths = list(all_paths_best_first_search(problem, f=lambda n: n.path_cost + problem.h(n)))\n",
+ " return union({state.pos for state in path_states(path)} for path in paths)\n",
+ " \n",
+ "def all_paths_best_first_search(problem, f) -> 'Node':\n",
+ " \"Search nodes with minimum f(node) value first, return all paths with minimum cost.\"\n",
+ " node = Node(problem.initial)\n",
+ " frontier = PriorityQueue([node], key=f)\n",
+ " reached = {problem.initial: node}\n",
+ " while frontier:\n",
+ " node = frontier.pop()\n",
+ " if problem.is_goal(node.state):\n",
+ " yield node\n",
+ " while frontier:\n",
+ " path = frontier.pop()\n",
+ " if path.path_cost == node.path_cost and problem.is_goal(path.state):\n",
+ " yield path\n",
+ " return\n",
+ " for child in expand(problem, node):\n",
+ " s = child.state\n",
+ " if s not in reached or child.path_cost <= reached[s].path_cost:\n",
+ " reached[s] = child\n",
+ " frontier.add(child)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 158,
+ "id": "ea9bf9f3-0e6b-4949-a641-6b3db2fd9d32",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Puzzle 16.2: .8586 seconds, answer 554 ok"
+ ]
+ },
+ "execution_count": 158,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "answer(16.2, 554, lambda:\n",
+ " len(reindeer_best_positions(maze)))"
+ ]
+ },
{
"cell_type": "markdown",
"id": "c3317844-2b4a-4756-8a59-b765aa467445",
@@ -6596,12 +6997,12 @@
"source": [
"# Summary\n",
"\n",
- "So far, I've solved all the puzzles. Most of them run in well under a second, but four of them take over a second."
+ "So far, I've solved all the puzzles. Most of them run in well under a second (the median is less than a hundreth of a second), but four of them take over a second."
]
},
{
"cell_type": "code",
- "execution_count": 144,
+ "execution_count": 160,
"id": "34813fc9-a000-4cd8-88ae-692851b3242c",
"metadata": {},
"outputs": [
@@ -6612,38 +7013,44 @@
"Puzzle 1.1: .0002 seconds, answer 1830467 ok\n",
"Puzzle 1.2: .0001 seconds, answer 26674158 ok\n",
"Puzzle 2.1: .0004 seconds, answer 257 ok\n",
- "Puzzle 2.2: .0023 seconds, answer 328 ok\n",
- "Puzzle 3.1: .0006 seconds, answer 156388521 ok\n",
+ "Puzzle 2.2: .0021 seconds, answer 328 ok\n",
+ "Puzzle 3.1: .0005 seconds, answer 156388521 ok\n",
"Puzzle 3.2: .0004 seconds, answer 75920122 ok\n",
- "Puzzle 4.1: .0338 seconds, answer 2401 ok\n",
- "Puzzle 4.2: .0274 seconds, answer 1822 ok\n",
+ "Puzzle 4.1: .0331 seconds, answer 2401 ok\n",
+ "Puzzle 4.2: .0260 seconds, answer 1822 ok\n",
"Puzzle 5.1: .0007 seconds, answer 5762 ok\n",
"Puzzle 5.2: .0009 seconds, answer 4130 ok\n",
- "Puzzle 6.1: .0015 seconds, answer 5329 ok\n",
- "Puzzle 6.2: 2.0299 seconds, answer 2162 ok\n",
- "Puzzle 7.1: .0217 seconds, answer 1985268524462 ok\n",
- "Puzzle 7.2: 1.1304 seconds, answer 150077710195188 ok\n",
- "Puzzle 8.1: .0028 seconds, answer 220 ok\n",
- "Puzzle 8.2: .0030 seconds, answer 813 ok\n",
- "Puzzle 9.1: .0209 seconds, answer 6332189866718 ok\n",
- "Puzzle 9.2: 2.8353 seconds, answer 6353648390778 ok\n",
+ "Puzzle 6.1: .0017 seconds, answer 5329 ok\n",
+ "Puzzle 6.2: 1.9609 seconds, answer 2162 ok\n",
+ "Puzzle 7.1: .0214 seconds, answer 1985268524462 ok\n",
+ "Puzzle 7.2: 1.0813 seconds, answer 150077710195188 ok\n",
+ "Puzzle 8.1: .0027 seconds, answer 220 ok\n",
+ "Puzzle 8.2: .0031 seconds, answer 813 ok\n",
+ "Puzzle 9.1: .0196 seconds, answer 6332189866718 ok\n",
+ "Puzzle 9.2: 2.7301 seconds, answer 6353648390778 ok\n",
"Puzzle 10.1: .0049 seconds, answer 744 ok\n",
- "Puzzle 10.2: .0060 seconds, answer 1651 ok\n",
- "Puzzle 11.1: .0015 seconds, answer 194482 ok\n",
- "Puzzle 11.2: .0608 seconds, answer 232454623677743 ok\n",
- "Puzzle 12.1: .0310 seconds, answer 1402544 ok\n",
- "Puzzle 12.2: .0434 seconds, answer 862486 ok\n",
+ "Puzzle 10.2: .0059 seconds, answer 1651 ok\n",
+ "Puzzle 11.1: .0016 seconds, answer 194482 ok\n",
+ "Puzzle 11.2: .0606 seconds, answer 232454623677743 ok\n",
+ "Puzzle 12.1: .0302 seconds, answer 1402544 ok\n",
+ "Puzzle 12.2: .0424 seconds, answer 862486 ok\n",
"Puzzle 13.1: .0002 seconds, answer 29598 ok\n",
"Puzzle 13.2: .0004 seconds, answer 93217456941970 ok\n",
"Puzzle 14.1: .0001 seconds, answer 216027840 ok\n",
- "Puzzle 14.2: 1.8866 seconds, answer 6876 ok\n",
+ "Puzzle 14.2: 1.8721 seconds, answer 6876 ok\n",
+ "Puzzle 15.1: .0292 seconds, answer 1563092 ok\n",
+ "Puzzle 15.2: .0419 seconds, answer 1582688 ok\n",
+ "Puzzle 16.1: .1464 seconds, answer 103512 ok\n",
+ "Puzzle 16.2: .8586 seconds, answer 554 ok\n",
"\n",
- "Total time 8.1471 seconds, Mean time 0.2910 seconds\n"
+ "Correct: 32/32\n",
+ "\n",
+ "Time in seconds: 0.0054 median, 0.2806 mean, 8.9796 total.\n"
]
}
],
"source": [
- "report(answers)"
+ "summary(answers)"
]
}
],
diff --git a/ipynb/AdventUtils.ipynb b/ipynb/AdventUtils.ipynb
index 541107d..70ef884 100644
--- a/ipynb/AdventUtils.ipynb
+++ b/ipynb/AdventUtils.ipynb
@@ -22,7 +22,7 @@
"from collections import Counter, defaultdict, namedtuple, deque, abc\n",
"from dataclasses import dataclass, field\n",
"from itertools import permutations, combinations, cycle, chain, islice\n",
- "from itertools import count as count_from, product as cross_product\n",
+ "from itertools import count as count_from, product as cross_product, takewhile\n",
"from typing import *\n",
"from statistics import mean, median\n",
"from math import ceil, floor, factorial, gcd, log, log2, log10, sqrt, inf, atan2\n",
@@ -168,7 +168,7 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 78,
"metadata": {},
"outputs": [],
"source": [
@@ -200,17 +200,13 @@
" f' WRONG; expected answer is {self.solution}')\n",
" return f'Puzzle {self.puzzle:4.1f}: {secs} seconds, answer {self.got:<15}{comment}'\n",
"\n",
- "def report(answers):\n",
+ "def summary(answers):\n",
+ " \"\"\"Print a report that summarizes the answers.\"\"\"\n",
" for d in sorted(answers):\n",
" print(answers[d])\n",
- " secs = sum(answers[d].secs for d in answers)\n",
- " print(f'\\nTotal time {secs:.4f} seconds, Mean time {secs/len(answers):.4f} seconds')\n",
- "\n",
- "def test_answer():\n",
- " print(answer(0.1, unknown))\n",
- " print(answer(0.2, 2**39, lambda: 2**39))\n",
- " print(answer(0.3, 2**39, lambda: 2**39+1))\n",
- " print(answer(10.4, unknown, lambda: 2 + 2))"
+ " times = [answers[d].secs for d in answers]\n",
+ " print(f'\\nCorrect: {quantify(answers[d].ok for d in answers)}/{len(answers)}')\n",
+ " print(f'\\nTime in seconds: {median(times):.4f} median, {mean(times):.4f} mean, {sum(times):.4f} total.')"
]
},
{
@@ -581,6 +577,8 @@
" \"\"\"Print a representation of the grid.\"\"\"\n",
" for row in self.to_rows(xrange, yrange):\n",
" print(*row, sep=sep)\n",
+ "\n",
+ " def __str__(self): return cat(self.to_rows())\n",
" \n",
" def plot(self, markers={'#': 's', '.': ','}, figsize=(14, 14), **kwds):\n",
" \"\"\"Plot a representation of the grid.\"\"\"\n",