From 554e9c9fe13ca6ffeed7083f625706f248b4f743 Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Wed, 15 Apr 2020 20:20:37 -0700 Subject: [PATCH] Add files via upload --- ipynb/Cheryl.ipynb | 11 +- ipynb/Maze.ipynb | 361 +++++++++++++++++++++++++++++---------------- 2 files changed, 243 insertions(+), 129 deletions(-) diff --git a/ipynb/Cheryl.ipynb b/ipynb/Cheryl.ipynb index 7d66155..87c7cde 100644 --- a/ipynb/Cheryl.ipynb +++ b/ipynb/Cheryl.ipynb @@ -261,7 +261,7 @@ "source": [ "The function `statement3` takes as input a single possible birthdate and returns `True` if Albert's statement is true for that birthdate. How do we go from Albert's English statement to a Python function? Let's paraphrase it in a form that uses the concepts we have defined:\n", "\n", - "> **Albert**: After Cheryl **told** me the **month** of her birthdate, my **belief set** was such that I didn't **know** her birthday. I do know that Bernard does not know. How do I know that? I can see that for **all** the possible dates in my **belief set**, if Bernard was **told** the **day** of that date, he would **not know** Cheryl's birthday.\n", + "> **Albert**: After Cheryl **told** me the **month** of her birthdate, my **belief set** was such that I didn't **know** her birthday. And I know that Bernard does not know; in other words he could not make the statement that he knows. How do I know that? I can see that for all the possible dates in my **belief set**, if Bernard was **told** the **day** of that date, he would **not know** Cheryl's birthday.\n", "\n", "That I can translate directly into code:" ] @@ -275,9 +275,9 @@ "def statement3(date) -> bool:\n", " \"\"\"Albert: I don't know when Cheryl's birthday is, but I know that Bernard does not know too.\"\"\"\n", " albert_beliefs = told(month(date))\n", - " return (not know(albert_beliefs) \n", - " and all(not know(told(day(d))) \n", - " for d in albert_beliefs))" + " return not know(albert_beliefs) and not satisfy(albert_beliefs, bernard_knows)\n", + "\n", + "def bernard_knows(date) -> bool: return know(told(day(date))) " ] }, { @@ -481,7 +481,8 @@ } ], "source": [ - "dates = '06:32, 06:43, 06:50, 07:17, 07:46, 08:19, 08:32, 09:17, 09:19, 09:50'.replace(':', ' ').split(', ')\n", + "times = '06:32 06:43 06:50 07:17 07:46 08:19 08:32 09:17 09:19 09:50'.split()\n", + "dates = [t.replace(':', ' ') for t in times]\n", "\n", "cheryls_birthday()" ] diff --git a/ipynb/Maze.ipynb b/ipynb/Maze.ipynb index 535c59c..070990b 100644 --- a/ipynb/Maze.ipynb +++ b/ipynb/Maze.ipynb @@ -6,7 +6,7 @@ "source": [ "
Peter Norvig
March 2018
\n", "\n", - "# Maze Generation\n", + "# Making and Solving Mazes\n", "\n", "Let's make some mazes! I'm thinking of mazes like this one, which is a rectangular grid of squares, with walls on some of the sides of squares, and openings on other sides. The goal is to get from the red arrow to the green arrow.\n", "\n", @@ -51,7 +51,7 @@ " o o--o--o--o--o--o--o--o--o--o\n", " | A b c| | | | | | | |\n", " o o--o o--o--o--o--o--o--o--o\n", - " | B| e| d| | N| | | | | |\n", + " | B| e d| | N| | | | | |\n", " o o--o--o--o o--o--o--o--o--o\n", " | C D| | | M| | | | | |\n", " o--o o--o--o o--o--o--o--o--o\n", @@ -60,23 +60,23 @@ " | G H I J| | | | | | |\n", " o--o--o--o--o--o--o--o--o--o o\n", " \n", - "Continue like this until every square in the grid has been added to the tree. \n", + "Continue like this until every square in the grid has been added to the tree. At that point there will be a path from start to goal. Some walls will remain; some will be knocked down.\n", "\n", "\n", - "# Implementing Random Trees\n", + "# Making Random Trees\n", "\n", "I'll make the following implementation choices:\n", "\n", - "- A tree will be represented as a list of edges.\n", - "- An `Edge` is a tuple of two nodes. Edges are bidirectional, so to avoid confusion we will always us the tuple that is in sorted order: always `(1, 2)`, never `(2, 1)`. The constructor `edge` enforces that.\n", - "- A node in a tree can be anything: a number, a letter, a square, ...\n", + "- A tree will be represented as a set of edges.\n", + "- An `Edge` is a tuple of two nodes. Edges are bidirectional, so to avoid confusion we will always us the tuple that is in sorted order: always `(A, B)`, never `(B, A)`. The constructor `edge` enforces that.\n", + "- A node in a tree can be anything: a number, a letter, ... In this notebook we will make trees where the nodes are squares in a grid, but the function `random_tree` accepts nodes of any type.\n", "- The algorithm for `random_tree(nodes, neighbors, pop)` works as follows:\n", " * The arguments are:\n", " - `nodes`: a collection of nodes.\n", " - `neighbors`: a function such that `neighbors(node)` returns a set of nodes.\n", " - `pop`: a function such that `pop(frontier)` removes and returns an element from `frontier`.\n", " * The function keeps track of three collections:\n", - " - `tree`: a list of edges that constitutes the tree.\n", + " - `tree`: a set of edges that constitutes the tree.\n", " - `nodes`: the set of nodes that have not yet been added to the tree, but will be.\n", " - `frontier`: a queue of nodes in the tree that are eligible to have an edge added.\n", " * On each iteration:\n", @@ -97,11 +97,11 @@ "from collections import deque, namedtuple\n", "\n", "Edge = tuple\n", - "Tree = list\n", + "Tree = set\n", "\n", "def edge(A, B) -> Edge: return Edge(sorted([A, B]))\n", "\n", - "def random_tree(nodes, neighbors, pop=deque.pop) -> [Edge]:\n", + "def random_tree(nodes, neighbors, pop=deque.pop) -> Tree:\n", " \"\"\"Repeat: pop a node and add edge(node, nbr) until all nodes have been added to tree.\"\"\"\n", " tree = Tree()\n", " nodes = set(nodes)\n", @@ -112,7 +112,7 @@ " nbrs = neighbors(node) & nodes\n", " if nbrs:\n", " nbr = random.choice(list(nbrs))\n", - " tree.append(edge(node, nbr))\n", + " tree.add(edge(node, nbr))\n", " nodes.remove(nbr)\n", " frontier.extend([node, nbr])\n", " return tree" @@ -122,13 +122,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Implementing Random Mazes\n", + "# Making Random Mazes\n", "\n", - "Now let's use `random_tree` to implement `random_maze`. Some more choices:\n", + "Now let's use `random_tree` to implement `random_maze`. Basically, we just create a collection of `(x, y)` squares, pass these to `random_tree`, and let it do the work. Note that:\n", "\n", - "* A `Maze` is a named tuple with three fields: the `width` and `height` of the grid, and a list of `edges` between squares. \n", + "* A `Maze` is a named tuple with three fields: the `width` and `height` of the grid, and a set of `edges` between squares. \n", "* A square is denoted by an `(x, y)` tuple of integer coordinates.\n", - "* The function `neighbors4` gives the four surrounding squares." + "* The function `neighbors4(square)` gives the four surrounding squares." ] }, { @@ -146,17 +146,23 @@ " (x, y) = square\n", " return {(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)}\n", "\n", - "def squares(width, height) -> {Square}: \n", + "def grid(width, height) -> {Square}: \n", " \"\"\"All squares in a grid of these dimensions.\"\"\"\n", " return {(x, y) for x in range(width) for y in range(height)}\n", "\n", "def random_maze(width, height, pop=deque.pop) -> Maze:\n", - " \"\"\"Generate a random maze, using rrandom_tree.\"\"\"\n", - " nodes = squares(width, height)\n", - " tree = random_tree(nodes, neighbors4, pop)\n", + " \"\"\"Generate a random maze, using random_tree.\"\"\"\n", + " tree = random_tree(grid(width, height), neighbors4, pop)\n", " return Maze(width, height, tree)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I'll make a 10x5 maze, as in the diagram at the top of this notebook:" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -165,7 +171,7 @@ { "data": { "text/plain": [ - "Maze(width=10, height=5, edges=[((6, 3), (7, 3)), ((6, 3), (6, 4)), ((5, 4), (6, 4)), ((4, 4), (5, 4)), ((4, 3), (4, 4)), ((3, 3), (4, 3)), ((2, 3), (3, 3)), ((1, 3), (2, 3)), ((0, 3), (1, 3)), ((0, 2), (0, 3)), ((0, 1), (0, 2)), ((0, 0), (0, 1)), ((0, 0), (1, 0)), ((1, 0), (1, 1)), ((1, 1), (2, 1)), ((2, 1), (3, 1)), ((3, 1), (3, 2)), ((2, 2), (3, 2)), ((1, 2), (2, 2)), ((3, 2), (4, 2)), ((4, 2), (5, 2)), ((5, 2), (5, 3)), ((5, 2), (6, 2)), ((6, 2), (7, 2)), ((7, 1), (7, 2)), ((6, 1), (7, 1)), ((5, 1), (6, 1)), ((4, 1), (5, 1)), ((4, 0), (4, 1)), ((4, 0), (5, 0)), ((5, 0), (6, 0)), ((6, 0), (7, 0)), ((7, 0), (8, 0)), ((8, 0), (9, 0)), ((9, 0), (9, 1)), ((9, 1), (9, 2)), ((9, 2), (9, 3)), ((9, 3), (9, 4)), ((8, 4), (9, 4)), ((8, 3), (8, 4)), ((8, 2), (8, 3)), ((8, 1), (8, 2)), ((7, 4), (8, 4)), ((3, 0), (4, 0)), ((2, 0), (3, 0)), ((0, 3), (0, 4)), ((0, 4), (1, 4)), ((1, 4), (2, 4)), ((2, 4), (3, 4))])" + "Maze(width=10, height=5, edges={((2, 1), (3, 1)), ((5, 0), (5, 1)), ((8, 3), (8, 4)), ((6, 2), (6, 3)), ((6, 4), (7, 4)), ((8, 0), (8, 1)), ((5, 3), (6, 3)), ((5, 4), (6, 4)), ((0, 2), (1, 2)), ((1, 0), (2, 0)), ((4, 3), (4, 4)), ((0, 2), (0, 3)), ((2, 0), (2, 1)), ((2, 1), (2, 2)), ((7, 0), (7, 1)), ((7, 4), (8, 4)), ((6, 0), (7, 0)), ((8, 0), (9, 0)), ((6, 1), (6, 2)), ((0, 3), (1, 3)), ((2, 3), (2, 4)), ((7, 1), (7, 2)), ((0, 4), (1, 4)), ((3, 2), (3, 3)), ((8, 1), (9, 1)), ((9, 1), (9, 2)), ((4, 2), (5, 2)), ((7, 3), (8, 3)), ((4, 0), (4, 1)), ((2, 4), (3, 4)), ((1, 0), (1, 1)), ((3, 1), (4, 1)), ((1, 1), (1, 2)), ((3, 3), (3, 4)), ((0, 0), (1, 0)), ((5, 1), (5, 2)), ((5, 0), (6, 0)), ((3, 4), (4, 4)), ((0, 0), (0, 1)), ((0, 3), (0, 4)), ((9, 2), (9, 3)), ((1, 3), (2, 3)), ((9, 3), (9, 4)), ((3, 0), (4, 0)), ((5, 3), (5, 4)), ((7, 2), (8, 2)), ((3, 2), (4, 2)), ((6, 0), (6, 1)), ((8, 2), (9, 2))})" ] }, "execution_count": 3, @@ -174,7 +180,7 @@ } ], "source": [ - "random_maze(10,5)" + "random_maze(10, 5)" ] }, { @@ -183,87 +189,40 @@ "source": [ "That's not very pretty to look at. I'm going to need a way to visualize a maze.\n", "\n", - "# Printing a maze\n", + "# Plotting a maze\n", "\n", - "Here's a function to print a maze:" + "I will use `matplotlib` to plot the walls of a maze. I'm going to look ahead to when we have a *solution path,* and allow that to be plotted as well." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "o o--o--o--o--o--o--o--o--o--o\n", - "| | | |\n", - "o--o--o--o o o--o o o--o o\n", - "| | | | | | |\n", - "o o o o--o--o o o--o o o\n", - "| | | | | |\n", - "o o--o o o--o--o--o--o--o o\n", - "| | | | | | |\n", - "o o o--o--o--o o o o o o\n", - "| | | | |\n", - "o--o--o--o--o--o--o--o--o--o o\n" - ] - } - ], - "source": [ - "def print_maze(maze, dot='o', bar='|', sp1=' ', sp2=' ', lin='--'):\n", - " \"\"\"Print maze in ASCII.\"\"\"\n", - " exit = edge((maze.width-1, maze.height-1), (maze.width-1, maze.height))\n", - " edges = set(maze.edges) | {exit}\n", - " print(dot + sp2 + lin.join(dot * maze.width)) # Top line, including entrance\n", - " def vert_wall(x, y): return (sp1 if edge((x, y), (x+1, y)) in edges else bar)\n", - " def horz_wall(x, y): return (sp2 if edge((x, y), (x, y+1)) in edges else lin)\n", - " for y in range(maze.height):\n", - " print(bar + cat(sp2 + vert_wall(x, y) for x in range(maze.width)))\n", - " print(dot + cat(horz_wall(x, y) + dot for x in range(maze.width)))\n", - " \n", - "cat = ''.join\n", - " \n", - "print_maze(random_maze(10, 5))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "*Much better!* But can I do better still?\n", - "\n", - "# Plotting a maze\n", - "\n", - "I'll use `matplotlib` to plot lines where the edges aren't:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", - "def plot_maze(maze, figsize=None):\n", + "def plot_maze(maze, figsize=None, path=None):\n", " \"\"\"Plot a maze by drawing lines between adjacent squares, except for pairs in maze.edges\"\"\"\n", " w, h = maze.width, maze.height\n", " plt.figure(figsize=figsize or (w/5, h/5))\n", " plt.axis('off')\n", " plt.gca().invert_yaxis()\n", " exits = {edge((0, 0), (0, -1)), edge((w-1, h-1), (w-1, h))}\n", - " edges = set(maze.edges) | exits\n", - " for sq in squares(w, h):\n", + " edges = maze.edges | exits\n", + " for sq in grid(w, h):\n", " for nbr in neighbors4(sq):\n", " if edge(sq, nbr) not in edges:\n", " plot_wall(sq, nbr)\n", - " plt.show()\n", + " if path: # Plot the solution (or any path) as a red line through the maze\n", + " X, Y = transpose((x + 0.5, y + 0.5) for (x, y) in path)\n", + " plt.plot(X, Y, 'r-', linewidth=2)\n", + " \n", + "def transpose(matrix): return list(zip(*matrix))\n", "\n", "def plot_wall(s1, s2):\n", - " \"\"\"Plot a thick black line between squares s1 and s2.\"\"\"\n", + " \"\"\"Plot a wall: a black line between squares s1 and s2.\"\"\"\n", " (x1, y1), (x2, y2) = s1, s2\n", " if x1 == x2: # horizontal wall\n", " y = max(y1, y2)\n", @@ -271,24 +230,24 @@ " else: # vertical wall\n", " x = max(x1, x2)\n", " X, Y = [x, x], [y1, y1+1]\n", - " plt.plot(X, Y, 'k-', linewidth=3.0)" + " plt.plot(X, Y, 'k-', linewidth=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's compare the two visualization functions:" + "Let's see what it looks like:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAACWCAYAAACYTp4YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAACwklEQVR4nO3dUUrDUBBA0Ubc/5bjn/hhKZH05U48ZwG1bfAyI8hs+74/ACo+rn4DAD+JEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQMrnmS+2bdv3P9Lt+76d+dq//Qyg5Yzfe5MSkCJKQMqp69sK71oLr7B63b3Td/cuvq/jzv6TikkJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIGXfN5IpjlK5avLb6uUx/Ji7ZPGdSAlJECUgZt76tGkNXrCOTRuojVqwj3JdJCUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUsYdDrjilpUjAkw36eiCSQlIESUgZdz6tsqKdWrSSP3KXdbPu3yOx2PunzdMSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQMroayarroG4bPLa6vc//fta4YrDrWcwKQEpogSkjF7f3jmSrlgPJo3UR9z1c53J+vmcSQlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgZfc1kFZcnGu76HO76uf7KpASkiBKQMm59W3Xo0EHFYxzv5CwmJSBFlIAUUQJSRAlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUkQJSBElIOVt10wc2Pu/PPueSZdgTEpAiigBKdu+m7SBDpMSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAyhdya3k/PuCAlAAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAACWCAYAAACYTp4YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAACuklEQVR4nO3dQU7cQBRFUTvK/rdcGSFlQCSi2MWtn3MWALS7uTxG/15rXQAVP777BwD4nSgBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSk/Hzyi933va7rutZa95Nf97PvAbQ89XtvKQEpjy6lHd5cYRPtWK+7THotkzz934ulBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkHLciaWJxygnnAzaef5o0mdgx+HW0z5flhKQctxS+nBa/fl3k97zSWvvaZYSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQcuw1E9cgmqa8L5Mup5zGUgJSjl1K/pJ9ze7l4n35Gs/pzywlIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAlGNPLL1t52miSed2phyj5PtYSkDKcUtp96qYtGLe5Dn9nY9F+eZzO3W1WkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpx51YOvVszGd2vpZJz43ZLCUg5biltOvo4Y5l4YAjbzr182UpASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpLxyYmnS4cNJr4X/02mnliwlIOVeyxAAOiwlIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAFFECUn4BAo5mOYT9KpYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -297,53 +256,163 @@ "needs_background": "light" }, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "o o--o--o--o--o--o--o--o--o--o\n", - "| | | | |\n", - "o o--o o o o--o o o o o\n", - "| | | | | | | | |\n", - "o o o--o o o o o o o--o\n", - "| | | | | | |\n", - "o o--o o--o o--o--o--o o o\n", - "| | | | | | |\n", - "o o o--o--o--o o--o--o--o o\n", - "| | |\n", - "o--o--o--o--o--o--o--o--o--o o\n" - ] } ], "source": [ "M = random_maze(10, 5)\n", - "\n", - "plot_maze(M, (5, 2.5)) \n", - "print_maze(M)" + "plot_maze(M, figsize=(5, 2.5)) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# `pop` strategies\n", + "# Solving Mazes\n", "\n", - "Now I want to compare how the maze varies based on theree different choices for the `pop` parameter. \n", - "\n", - "# `deque.pop`\n", - "\n", - "The default pop method means that the tree is created **depth-first**; we always select the `node` at the end of the `frontier`, so the tree follows a single branch along a randomly-twisted path until the path doubles back on itself and there are no more neighbors; at that point we select the most recent square for which there are neighbors. The maze with `deque.pop` looks pretty good. Reminds me of those [cyber brain](https://www.vectorstock.com/royalty-free-vector/cyber-brain-vector-3071965) images:" + "Now it is time to show how to solve a maze. I'll use breadth-first search, which guarantees that the solution will be the shortest possible (although for mazes with only one solution, the guarantee doesn't matter). The function `breadth_first_search` maintains a `frontier` of unexplored squares, and on each iteration removes a square from the frontier that is at the shallowest path depth, and adds to the frontier all the neighbors of that square that are not blocked by walls and have not been seen previously. The dictionary of `{square: [square,...]}` called `paths` has two purposes: it prevents us from creating loops in a path, and at the end it tells us the path from start to goal, e.g. `[(0, 0), (0, 1), (1, 1), (2, 1), ...]`." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def breadth_first_search(maze):\n", + " \"\"\"Find a shortest sequence of states from start to the goal.\"\"\"\n", + " start = (0, 0)\n", + " goal = (maze.width - 1, maze.height - 1)\n", + " frontier = deque([start]) # A queue of states to consider\n", + " paths = {start: [start]} # start has a one-square path\n", + " while frontier:\n", + " s = frontier.popleft()\n", + " if s == goal:\n", + " return paths[s]\n", + " for s2 in neighbors4(s):\n", + " if s2 not in paths and edge(s, s2) in maze.edges:\n", + " frontier.append(s2)\n", + " paths[s2] = paths.get(s, []) + [s2]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "text/plain": [ + "[(0, 0),\n", + " (0, 1),\n", + " (0, 2),\n", + " (0, 3),\n", + " (1, 3),\n", + " (1, 2),\n", + " (2, 2),\n", + " (3, 2),\n", + " (3, 3),\n", + " (2, 3),\n", + " (2, 4),\n", + " (3, 4),\n", + " (4, 4),\n", + " (5, 4),\n", + " (6, 4),\n", + " (7, 4),\n", + " (8, 4),\n", + " (9, 4)]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "solution = breadth_first_search(M)\n", + "solution" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAACWCAYAAACYTp4YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAADQ0lEQVR4nO3dwW7TQBRAURvxdfC99PfMhlRdtFJCnPGd6Tl7mthOLw+U0duP49gAKn5c/QYAPhIlIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIESUgRZSAlJ9n/rB9349t27bjOPYzf+5nrwG0nPV7b1ICUk6dlEZ45RS2ohHT6ygrXctKzv7Xi0kJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSRAlIuT5K+35szrMB/1wfJYAPRAlIESUgRZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlICU6VYsrbiMcoWVQSPXH630GRixuHW2z5dJCUiZblK6ma3+PG+lZ77StHc2kxKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAy7TYT2yCaVnkuK21OmY1JCUiZdlLyN9l9Rk8unst93KevmZSAFFECUkQJSBElIEWUgBRRAlJECUgRJSBFlIAUUQJSpj1m8pB9/7Nt26+r38aJ3rbj+H31m4BX2I/jvKNRt3NWD53ruZ3NuvPPPPUaK3nl/foPo16H+8367L/HpHSzwi/MioGFD/yfEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkPK9vtH9gJGriVY6mrHKMkquY1ICUqablEZPFStNMa/kPj1mxGHZWadWkxKQIkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkBK55jJpF+Jf7fewku4RGFSelvkdUYGadQ9g+Gu35Ab9fC1PLjpd5SVnslKRh7InW1DbmFSAngnSkCKKAEpogSkiBKQIkpAiigBKaIEpIgSkNI5+3anWdfGfGbktax031ibSQlImW5SGnWGa8Rk4TwarzTr58ukBKSIEpAiSkCKKAEpogSkiBKQIkpAiigBKaIEpEz3je48Z8xYwYXfBjcpnccuNjiBvW9fWOla4JXsfQOWJkpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkDKSw7krrT4cKVr4Xua7aiUSQlIOfVALsCzTEpAiigBKaIEpIgSkCJKQIooASmiBKSIEpAiSkCKKAEpogSk/AUI/MVbhV/bNgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_maze(M, figsize=(5, 2.5), path=solution)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Strategies for the `pop` parameter of `random_maze`\n", + "\n", + "Now I want to compare how the maze varies based on three different choices for the `pop` parameter. \n", + "\n", + "# `pop=deque.pop`\n", + "\n", + "The default pop method, `deque.pop`, means that the tree is created **depth-first**; we always select the `node` at the **end** of the `frontier`, so the tree follows a single branch along a randomly-twisted path until the path doubles back on itself and there are no more neighbors. At that point we select the most recent square for which there are neighbors and continue from there. The maze with `deque.pop` looks pretty good. Reminds me of those [cyber brain](https://www.vectorstock.com/royalty-free-vector/cyber-brain-vector-3071965) images. I'll `show` the maze without and then with the solution path." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def show(pop):\n", + " \"\"\"Using this `pop` parameter, show a 70x70 maze, first without and then with the solution path.\"\"\"\n", + " M = random_maze(70, 70, pop)\n", + " plot_maze(M)\n", + " plt.show()\n", + " solution = breadth_first_search(M)\n", + " plot_maze(M, path=[(0, -1)] + solution + [(M.width - 1, M.height)])\n", + " return len(solution)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "1179" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -355,26 +424,48 @@ } ], "source": [ - "plot_maze(random_maze(70, 70, deque.pop))" + "show(deque.pop)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# `deque.popleft`\n", + "# `pop=deque.popleft`\n", "\n", - "This creates the maze roughly **breadth-first**—we start at some root square , add an edge to it, and from then on we always select first a parent edge before we select a child edge. The net result is a design that appears to radiate out in concentric layers from the root (which is chosen by `random_tree` and is not necessarily the top-left square; below it looks like the root is in the lower-right quadrant). The `deque.popleft` maze is interesting as a design, but to me it doesn't work well as a maze. It is too easy to say: follow the path from the start to the center point, then consider the path from the end to the center point, and see how they match up." + "This creates the maze roughly **breadth-first**—we start at some root square , add an edge to it, and from then on we always select first a parent edge before we select a child edge. The net result is a design that appears to radiate out in concentric layers from the root (which is chosen by `random_tree` and is not necessarily the top-left square; below it appears the root is in the lower-right quadrant). The `deque.popleft` maze is interesting as a design, but to me it doesn't work well as a maze. It is too easy to solve: follow the path from the start to the root, then consider the path from the end to the root, and see how they match up." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "139" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -386,22 +477,22 @@ } ], "source": [ - "plot_maze(random_maze(70, 70, deque.popleft))" + "show(deque.popleft)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# `poprandom`\n", + "# `pop=poprandom`\n", "\n", - "We can select a cell at random by shuffling the frontier before popping an element off of it.\n", - "This is an interesting compromise: it has some structure, but still works nicely as a maze, in my opinion." + "We can select a cell at random fromthe frontier.\n", + "This is an interesting compromise: it has some structure, and looks rather nice as a maze, in my opinion. However, I have to say that I was surprised that the path is almost as straight and short as in `pop=popleft`; not nearly as twisty as in `pop=deque.pop`." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -414,12 +505,34 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "143" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -431,7 +544,7 @@ } ], "source": [ - "plot_maze(random_maze(70, 70, poprandom))" + "show(poprandom)" ] }, {