From 09dc047c371e7b39a76e719e56894aa81cc6d7b1 Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Tue, 10 Aug 2021 14:00:04 -0700 Subject: [PATCH] Add files via upload --- ipynb/RaceTrack.ipynb | 332 ++++++++++++++++++++++++------------------ 1 file changed, 193 insertions(+), 139 deletions(-) diff --git a/ipynb/RaceTrack.ipynb b/ipynb/RaceTrack.ipynb index 5c3ee97..92a79bc 100644 --- a/ipynb/RaceTrack.ipynb +++ b/ipynb/RaceTrack.ipynb @@ -16,21 +16,20 @@ ">\n", "> For each move you have a choice of nine possible destinations, corresponding to the 3x3 grid that surrounds the point formed by adding your current velocity vector to your current position. That is, you can maintain your current velocity, or you can alter your velocity (and hence your destination) by accelerating one grid point in any direction (horizontally, vertically or diagonally). For example, if your first move was up and to the right, then your nine possible second moves are shown below, although two of them will cause you to crash into the central circle and one of them is standing still.\n", ">\n", - "> ![](https://fivethirtyeight.com/wp-content/uploads/2021/08/Screen-Shot-2021-08-04-at-10.44.11-PM.png?w=400)\n", - ">\n", "> How quickly can you navigate the track? \n", ">\n", + "> ![](https://fivethirtyeight.com/wp-content/uploads/2021/08/Screen-Shot-2021-08-04-at-10.44.11-PM.png?w=200)\n", "\n", "\n", - "# Defining Points and Vectors\n", + "# Defining Points, Vectors, and Paths\n", "\n", "We will need to represent 2-D points on a grid, as well as 2-D vectors for velocity and acceleration. I will use the following choices:\n", "- `Point(x, y)`: a point in the 2-D plane, implemented as a complex number.\n", - "- `Vector(x, y)`: a vector in the 2-D plane, also implemented as a complex number.\n", - "- `Path`: a list of points (representing the car's positions as it moves).\n", + "- `Vector(x, y)`: a 2-D vector, also implemented as a complex number.\n", + "- `Path`: the car's history of position points as it moves, implemented as a list of Points.\n", "- `X(point)`, `Y(point)`: the x- and y-coordinates of a point, respectively.\n", - "- `zero`: a zero vector (the car's starting velocity vector).\n", - "- `accelerations`: the nine possible acceleration vectors (to change the car's velocity), mapped to the digit number that The Riddler uses to identify them.\n" + "- `zero`, `up`, `right`: vectors that stay still, move one unit up, and move one to the right, respectively.\n", + "- `accelerations`: the nine possible acceleration vectors (to change the car's velocity)." ] }, { @@ -42,31 +41,25 @@ "import matplotlib.pyplot as plt\n", "from typing import List, Tuple, Dict, Set\n", "\n", - "Point = Vector = complex\n", - "Path = List[Point]\n", + "Point = complex\n", + "Vector = complex\n", + "Path = List[Point]\n", "\n", "def X(point) -> float: \"x-coordinate\"; return point.real\n", "def Y(point) -> float: \"y-coordinate\"; return point.imag\n", "\n", - "zero = Vector(0, 0)\n", + "zero, up, right = Vector(0, 0), Vector(0, 1), Vector(1, 0)\n", "\n", - "accelerations = {Vector(-1, 1): 1, Vector(0, 1): 2, Vector(1, 1): 3, \n", - " Vector(-1, 0): 4, Vector(0, 0): 5, Vector(1, 0): 6, \n", - " Vector(-1, -1):7, Vector(0, -1):8, Vector(1, -1):9}" + "accelerations = [up-right, up, up+right, \n", + " -right, zero, right, \n", + " -up-right, -up, -up+right]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Defining the Track\n", - "\n", - "I want to solve the particular problem posed by The Riddler, but I also want some flexibility to race on differently-shaped race tracks. I'll define the class `Track` as a subclass of a `set` (of `Point`s), with some additional attributes:\n", - "- `track.start`: the single starting point.\n", - "- `track.finish`: the two endpoints of the finish line.\n", - "- `track.radius`: the radius of the central circle (whose center is defined as the origin).\n", - "\n", - "The points in the track are all those points on a 15x15 square except the ones that fall inside the circle's radius.\n" + "*Note:* I debated whether the elements of a `Path` should be just points, or (point, velocity) pairs, because that's what uniquely identifies the state of a car. I decided it was simpler to just use points. Given a path, the velocity can be easily computed:" ] }, { @@ -74,18 +67,54 @@ "execution_count": 2, "metadata": {}, "outputs": [], + "source": [ + "def velocity(path) -> Vector:\n", + " \"\"\"Velocity of the car when it is at the end of the path.\"\"\"\n", + " return zero if len(path) == 1 else path[-1] - path[-2] " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Defining the Track\n", + "\n", + "I want to solve RaceTrack games both on the particular track posed by The Riddler, and on differently-shaped race tracks. I'll define the class `Track` to be a set of points, but annotated with \n", + "attribute/value pairs (which can vary for different tracks)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "class Track(Set):\n", + " \"\"\"The set of legal points on the track, with any attributes.\"\"\"\n", " def __init__(self, items, **kwds):\n", " self.update(items)\n", - " self.__dict__.update(kwds)\n", - "\n", - "radius = 3\n", - "track = Track({Point(x, y) for x in range(-7, 8) for y in range(-7, 8) \n", - " if abs(Point(x, y)) >= radius}, \n", - " start=Point(0, -5), \n", - " finish=[Point(0, -3), Point(0, -7)], \n", - " radius=radius)" + " self.__dict__.update(kwds)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For The Riddler's track, the track points are all those points on a 15x15 square except the ones that fall inside the circle's radius. The track also has three attributes:\n", + "- `track.start`: the single starting point.\n", + "- `track.finish`: the two endpoints of the finish line.\n", + "- `track.radius`: the radius of the central circle (whose center, without loss of generality, is the origin)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "side = range(-7, 8)\n", + "points = {Point(x, y) for x in side for y in side if abs(Point(x, y)) >= 3}\n", + "track = Track(points, start=Point(0, -5), finish=[Point(0, -3), Point(0, -7)], radius=3)" ] }, { @@ -94,12 +123,12 @@ "source": [ "# Visualization\n", "\n", - "I think it will be helpful to be able to visualize paths on the track, so I'll define a function to do that now, even before attempting to find solutions:" + "It will be really helpful to be able to visualize paths on the track:" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -109,15 +138,16 @@ " plt.xticks([]); plt.yticks([])\n", " ax.set_aspect('equal')\n", " ax.add_artist(plt.Circle((0, 0), track.radius, alpha=1/3, color='k', ec='w'))\n", - " ax.plot(*XY(track), 'k,' ) # grid points\n", + " ax.plot(*XY(track), 'k,' ) # grid points\n", " ax.plot(*XY([track.start]), 'ks', ms=10) # start point\n", - " ax.plot(*XY(track.finish), 'k:') # finish line\n", - " for path in paths: # paths\n", + " ax.plot(*XY(track.finish), 'k-') # finish line\n", + " for path in paths: # paths\n", " ax.plot(*XY(path), 'o-') \n", " plt.title(f'{len(paths)} paths of {set(len(path) - 1 for path in paths)} moves')\n", " \n", "def XY(points) -> Tuple[List[float], List[float]]: \n", " \"\"\"A tuple of: (the x-coordinates of points, the y-coordinates of points).\"\"\"\n", + " # This converts points into the format that plt.plot expects \n", " return [X(p) for p in points], [Y(p) for p in points]" ] }, @@ -126,21 +156,22 @@ "metadata": {}, "source": [ "Below is my recreation of The Riddler's diagram of the first two moves. Here and throughout I'll use the convention:\n", - "- `p` is a point indicating a move\n", + "- `p` is a point indicating a move.\n", + "- `v` is the velocity of the move.\n", "- `p1` is where the next point would be if the velocity remains constant.\n", "- `p2` is where the next point actually is with acceleration applied to change the velocity.\n", "\n", - "In this example, `p` is up and right from the start to `Point(1, -4)`, so the velocity is `Vector(1, 1)`." + "In this example, `p` is up and right from the start, and from there there are 9 possible values for `p2`." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -150,8 +181,9 @@ } ], "source": [ - "p = Point(1, -4)\n", - "p1 = p + Vector(1, 1)\n", + "v = up + right\n", + "p = track.start + v\n", + "p1 = p + v\n", "p2s = [p1 + a for a in accelerations]\n", "\n", "plot([[track.start, p, p2] for p2 in p2s])" @@ -163,17 +195,14 @@ "source": [ "# Circumnavigating the Track\n", "\n", - "The goal of the race is to circumnavigate the center circle. I can test if a path goes from the fourth [quadrant](https://mathworld.wolfram.com/Quadrant.html) to the first, second, third, and back to the fourth. The predicate `is_solution(path)` does that.\n", + "What exactly does it mean to mean to \"circumnavigate the track in a counterclockwise loop\"? I'll define a circumnavigation (and thus, a *solution*) as a path goes from the plane's fourth [**quadrant**](https://mathworld.wolfram.com/Quadrant.html) to the first, second, third, and back to the fourth. (Points with an x-coordinate of exactly 0 are considered to be in the first or fourth quadrant.) \n", "\n", - "
\n", - "\n", - "\n", - "If you wanted to generalize this to other race tracks, you could change the definition of `quadrant` (there could be more than 4 \"quadrants,\" and they could have any shape), and change the `goals` in `is_solution`." + "
\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -189,26 +218,31 @@ "\n", "def quadrant(p: Point) -> int: \n", " \"\"\"What quadrant of the 2-D plane is this point in?\"\"\"\n", - " return (1 if Y(p) >= 0 else 4) if X(p) >= 0 else (2 if Y(p) >= 0 else 3)" + " if X(p) >= 0:\n", + " return 1 if Y(p) > 0 else 4\n", + " else: \n", + " return 2 if Y(p) > 0 else 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ + "To generalize this to other race tracks, you could change the definition of `quadrant` (there could be more than 4 \"quadrants,\" and they could have any shape), and change the `goals` in `is_solution`.\n", + "\n", "# Legal Moves\n", "\n", - "As stated earlier, I want to solve the specific circular track, and also make the code general enough that it can handle other tracks. I'll do that by splitting up responsibility for determining legal moves:\n", - "- `all_moves(path)` is general; it returns the points on the track that can be reached by applying the 9 accelerations.\n", - "- `circular_track_moves(path)` is specific; it limits moves in the following ways:\n", - " - It won't make moves that stay in one place (they are legal, but wasteful and not needed on this track).\n", + "As stated earlier, I want to solve the specific Riddler track, and also make the code general enough that it can handle other tracks. I'll do that by splitting up responsibility for determining legal moves:\n", + "- `all_moves(path, track)` is general; it returns track points that can be reached with any acceleration.\n", + "- `riddler_track_moves(path, track)` is specific; it limits moves in the following ways:\n", + " - It won't make moves that stay in one place (they are legal, but wasteful on this track).\n", " - It won't pass from the fourth quadrant backwards over the finish line into the third (legal, but wasteful).\n", - " - It won't let a move's line segment intersect the central circle (even if the start and end points of the move are on valid grid points outside of the circle).\n" + " - It won't let a move's line segment intersect the central circle (even if the start and end points of the move are on valid track points outside of the circle).\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -217,29 +251,25 @@ " p1 = path[-1] + velocity(path)\n", " return {(p1 + a) for a in accelerations} & track\n", " \n", - "def circular_track_moves(path, track=track) -> Set[Point]:\n", - " \"\"\"Reasonable moves on the circular track.\"\"\"\n", + "def riddler_track_moves(path, track=track) -> Set[Point]:\n", + " \"\"\"Reasonable moves on The Riddler's track.\"\"\"\n", " p = path[-1]\n", " return {p2 for p2 in all_moves(path, track)\n", " if p2 != p\n", " and not (quadrant(p) == 4 and quadrant(p2) == 3) # Don't go backwards\n", - " and not intersects_circle(p, p2, track)}\n", - "\n", - "def velocity(path) -> Vector:\n", - " \"\"\"Velocity of the car when it is at the end of the path.\"\"\"\n", - " return zero if len(path) == 1 else path[-1] - path[-2] " + " and not intersects_circle(p, p2, track)}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The math for solving for the intersection of a line segment and a circle [looks complicated](https://stackoverflow.com/questions/6091728/line-segment-circle-intersection), so instead I just define N+1 points along the line from point *p* to point *p2* and check if any of those points is within the radius of the circle (which by definition is centered on the origin). If N is too small this could miss an intersection, but that shouldn't be a problem for our uses." + "The math for solving for the intersection of a line segment and a circle [looks complicated](https://stackoverflow.com/questions/6091728/line-segment-circle-intersection), so instead I just define N+1 points along the line from point *p* to point *p2* and check if any of those points is within the radius of the circle. I chose N to be big enough that I believe this approach won't miss any intersection points on our small track." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -259,51 +289,62 @@ "source": [ "# A Frontier of Possible Paths\n", "\n", - "Now I want to expand paths by adding legal moves to the end until I find solution(s)–paths that circumnavigate the circle. I could keep all my paths in a `list`, but there will be an exponential number of them (up to 9n paths of length *n* and I estimate *n* will be around 10 to 13).\n", + "Now I want to expand paths by adding legal moves to the end until I find solution(s). I could keep *all* my paths in a `list`, but there will be an exponential number of them: O(9n) paths of length *n*. \n", "\n", - "Instead I will keep track of a *frontier*, which I define as a mapping of `{(endpoint, velocity): path}`. The idea is that there may be many paths that arrive at the some endpoint with the same velocity in the same number of moves. I only need to keep one of them, because they can all be continued in exactly the same ways.\n", + "I am not looking for all solutions, just one fastest solution (or possibly a small sampling of them). So I am willing to discard some partial paths if I can prove that they can never lead to a faster solution than another partial path.\n", " \n", - "*Note:* Before I added the limitation that moves can't pass backwards from the fourth quadrant to the third, I had **a bug**: sometimes the frontier would capture a `(endpoint, velocity)` pair for a path that was in the third quadrant but hadn't circumnavigated, and was replacing a path to the same point that had circumnavigated. That meant I was discarding some valid paths." + "The key idea is that there may be many partial paths that arrive at the some endpoint with the same velocity in the same number of moves. I only need to keep one of them, because they can all be continued in exactly the same ways.\n", + "\n", + "I will define a data structure that I call a `Frontier`, which is a dict of `{(endpoint, velocity): path}`. By the nature of dicts, this keeps only one path for each `(endpoint, velocity)` pair. \n", + " \n", + "Here's how I expand a frontier, adding one more move in all possible ways, and discarding duplicates:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "Frontier = Dict[Tuple[Point, Vector], Path]\n", "\n", - "def expand(frontier, legal_moves=circular_track_moves, track=track) -> Frontier:\n", + "def expand(frontier, legal_moves=riddler_track_moves, track=track) -> Frontier:\n", " \"\"\"The {(endpoint, velocity): path} frontier extended one move in all legal ways.\"\"\"\n", " return {(p, velocity([path[-1], p])): path + [p] \n", " for path in frontier.values() \n", " for p in legal_moves(path, track)}" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Note:* Before I added the limitation that moves can't pass backwards from the fourth quadrant to the third, it was possible that two different paths would arrive at the same point in the third quadrant with the same velocity. If the path that was discarded had circumnavigated and the path that was kept had not, that was **a bug** that discarded some valid solutions." + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Searching for the Fastest Solutions\n", "\n", - "Now all I have to do to solve the problem is repeatedly expand the frontier until one or more solutions are found. The first solutions found are guaranteed to be the fastest (i.e., they are the paths with the fewest possible moves), because we are expanding paths one move at a time, and the previous time did not find any solutions. In the end, I return a list of all the solutions in the frontier, but there may be many other paths that are not returned, because the frontier only keeps one path for each `(endpoint, velocity)` pair, and there are only so many ways to cross the finish line. " + "Now all I have to do to solve the problem is repeatedly expand the frontier until one or more solutions are found. The first solutions found are guaranteed to be the fastest (i.e., they are the paths with the fewest possible moves), because we are expanding paths one move at a time. In the end, `search` returns a list of all the solutions in the frontier, but there may be many other paths that are not returned, because the frontier only keeps one path for each `(endpoint, velocity)` pair, and there are only so many ways to cross the finish line. " ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "def search(track=track, path=None, legal_moves=circular_track_moves) -> List[Path]:\n", + "def search(track=track, path=None, legal_moves=riddler_track_moves) -> List[Path]:\n", " \"\"\"Find the shortest possible solution paths.\"\"\"\n", " if path is None: path = [track.start]\n", " frontier = {(path[-1], velocity(path)): path}\n", " solutions = []\n", " while not solutions:\n", " frontier = expand(frontier, legal_moves, track)\n", - " solutions = list(filter(is_solution, frontier.values()))\n", + " solutions = [path for path in frontier.values() if is_solution(path)]\n", " return solutions" ] }, @@ -318,12 +359,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -342,7 +383,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that the fastest solution is 12 moves, and there are at least 7 ways to get there (with perhaps other ways discarded).\n", + "We see that the fastest solution is 12 moves, and there are at least 7 ways to get there (with perhaps others discarded).\n", "\n", "# Submitting your Answer\n", "\n", @@ -354,12 +395,12 @@ "> 4 5 6\n", "> 7 8 9\n", "\n", - "I will define two functions to translate back and forth between my `Path` and The Riddler's list of `Digits`: " + "I already started the tricky work by defining the nine `accelerations` to be in this order. I finish the tricky work by defining two functions to translate back and forth between my `Path` and The Riddler's `Digits`: " ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -367,7 +408,7 @@ "\n", "def digits_from_path(path) -> Digits:\n", " \"\"\"The digits that the path represents.\"\"\"\n", - " return [accelerations[velocity(path[:i + 1]) - velocity(path[:i])]\n", + " return [1 + accelerations.index(velocity(path[:i + 1]) - velocity(path[:i])) \n", " for i in range(1, len(path))]\n", "\n", "def path_from_digits(digits, start=track.start) -> Path:\n", @@ -375,14 +416,14 @@ " v = zero # Starting velocity\n", " path = [start]\n", " for d in digits:\n", - " v += next(a for a in accelerations if accelerations[a] == d)\n", + " v += accelerations[d - 1]\n", " path.append(v + path[-1])\n", " return path" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -397,7 +438,7 @@ " [3, 3, 1, 7, 7, 5, 7, 8, 9, 9, 3, 3]]" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -412,17 +453,17 @@ "source": [ "# Alternative Solutions\n", "\n", - "I have identified six different opening sequences of moves that each lead to solutions with the fastest possible time of 12 moves. I don't understand why every plot has exactly 7 solution paths; I suppose it is just because the finish line is crowded and there are only so many ways to get there." + "I have identified six different opening sequences of moves that each lead to solutions with the fastest possible time of 12 moves. I don't understand exactly why in each case there exactly 7 solution paths are reported; I suppose it is just because the finish line is crowded and there are only so many ways to get there." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -432,7 +473,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -442,7 +483,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -452,7 +493,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -462,7 +503,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -472,7 +513,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -494,12 +535,12 @@ "source": [ "# Visualizations and Tests\n", "\n", - "To gain more confidence in the code, here are some visualizations and unit tests:" + "To gain more confidence in the code, here are some additional visualizations and unit tests:" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -512,12 +553,12 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -537,12 +578,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -562,12 +603,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -577,7 +618,7 @@ } ], "source": [ - "# Waypoints on a line segment that are checked to see if they are outside the circle\n", + "# Waypoints on a line segment\n", "p, q = Point(-7, 7), Point(7, 0)\n", "plot([waypoints(p, q)])\n", "assert not intersects_circle(p, q)" @@ -588,17 +629,17 @@ "metadata": {}, "source": [ "Here's a visualization for `expand(frontier)` showing the first six expansions.\n", - "Note that the growth in number of paths is much slower then O(9n). After 6 moves there are only 1,107 paths, or just 0.2% of 96 = 531,441." + "Note that the growth in number of paths is much slower then O(9n). After 6 moves there are only 1,107 paths, which is 500 times fewer than 96 = 531,441." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -608,7 +649,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -618,7 +659,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -628,7 +669,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -671,29 +712,17 @@ "source": [ "# A Different Track\n", "\n", - "Although the code here is not ready to handle large, arbitrary-shaped tracks, it can handle some small variations as is, and other variations with some tweaking. Here I define `track2` to be a track with a larger central circle, and a circular ring of valid points around the circle rather than a full rectangular grid:" + "Although the code here is not ready to handle large, arbitrary-shaped tracks, it can handle some minor track variations. Here I define `track2` to be a track with a larger central circle, and a circular ring of valid points rather than a full rectangular grid:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "[[6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 6, 3, 3],\n", - " [6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 3, 6, 6],\n", - " [6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 3, 6, 3]]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -704,16 +733,40 @@ ], "source": [ "radius2 = 10\n", - "track2 = Track({Point(x, y) for x in range(-14, 15) for y in range(-14, 15) \n", - " if radius2 <= abs(Point(x, y)) < 13}, \n", - " start=Point(0, -12), \n", - " finish=[Point(0, -radius2), Point(0, -12)], \n", - " radius=radius2)\n", + "side2 = range(-14, 15)\n", + "start2 = Point(0, -radius2 - 2)\n", + "track2 = Track({Point(x, y) for x in side2 for y in side2 \n", + " if radius2 <= abs(Point(x, y)) <= radius2 + 3}, \n", + " radius=radius2, start=start2, \n", + " finish=[Point(0, -radius2), Point(0, -radius2 - 3)])\n", "\n", "solutions2 = search(track2)\n", " \n", - "plot(solutions2, track=track2)\n", - "\n", + "plot(solutions2, track=track2)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 3, 9, 3],\n", + " [6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 6, 3, 3],\n", + " [6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 3, 6, 9],\n", + " [6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 3, 6, 6],\n", + " [6, 6, 3, 1, 1, 2, 4, 7, 4, 7, 7, 8, 9, 9, 9, 9, 5, 3, 3, 6, 3],\n", + " [6, 3, 3, 2, 1, 7, 4, 7, 1, 7, 8, 8, 7, 9, 9, 9, 9, 3, 3, 3, 3]]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "[digits_from_path(path) for path in solutions2]" ] }, @@ -721,12 +774,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Additional tests:" + "# Additional tests" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -735,38 +788,39 @@ "'tests pass'" ] }, - "execution_count": 20, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "path1 = [track.start, Point(1, -4)] # First move\n", + "start = track.start\n", + "path1 = [start, Point(1, -4)] # First move\n", "\n", - "assert track.start == Point(0, -5) == 0-5j\n", - "assert X(track.start) == 0 and Y(track.start) == -5 \n", - "assert velocity([track.start]) == 0\n", + "assert start == Point(0, -5) == 0-5j\n", + "assert X(start) == 0 and Y(start) == -5 \n", + "assert velocity([start]) == 0\n", "assert velocity(path1) == Vector(1, 1)\n", "assert XY(path1) == ([0, 1], [-5, -4])\n", "\n", - "assert quadrant(track.start) == 4\n", - "assert quadrant(Point(1, 2)) == 1\n", + "assert quadrant(Point(1, -4)) == 4 == quadrant(start)\n", + "assert quadrant(Point(1, 2)) == 1\n", "assert quadrant(Point(-5, 4)) == 2\n", - "assert quadrant(Point(-1, -1)) == 3\n", + "assert quadrant(Point(-1, -1))== 3\n", "\n", - "assert waypoints(0, 10, 10) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "assert waypoints(0, 100, 10) == [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n", "assert waypoints(zero, Point(10, 20), 10) == [\n", " 0j,1+2j,2+4j,3+6j,4+8j,5+10j,6+12j,7+14j,8+16j,9+18j,10+20j]\n", "\n", "# There are 9 moves from the start point\n", - "assert all_moves([track.start]) == {\n", + "assert all_moves([start]) == {\n", " -1-4j, -1-5j, -1-6j, \n", " 0-4j, 0-5j, 0-6j, \n", " 1-4j, 1-5j, 1-6j}\n", "\n", "# But 3 moves are backwards and 1 stays in the same place; those are disallowed\n", - "assert circular_track_moves([track.start]) == {0-6j, 1-6j, 1-5j, 0-4j, 1-4j}\n", - "assert expand({(track.start, zero): [track.start]}) == {\n", + "assert riddler_track_moves([start]) == {0-6j, 1-6j, 1-5j, 0-4j, 1-4j}\n", + "assert expand({(start, zero): [start]}) == {\n", " (0-6j, 0-1j): [0-5j, 0-6j],\n", " (1-6j, 1-1j): [0-5j, 1-6j],\n", " (1-5j, 1+0j): [0-5j, 1-5j],\n",