daviddoji/pytudes
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add files via upload

Browse Source
This commit is contained in:
Peter Norvig authored and GitHub committed 2020-04-15 20:20:37 -07:00
1 parent 5de6713d8b
commit 554e9c9fe1
2 files changed
+243 -129
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

ipynb/Cheryl.ipynb
+6 -5
View File
@@ -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()"
]
ipynb/Maze.ipynb
+237 -124
View File
@@ -6,7 +6,7 @@
"source": [
"<div align=\"right\" style=\"text-align: right\"><i>Peter Norvig<br>March 2018</i></div> \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": [
"<Figure size 360x180 with 1 Axes>"
]
@@ -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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 truncated
"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": [
"<Figure size 360x180 with 1 Axes>"
]
},
"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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 truncated
"text/plain": [
"<Figure size 1008x1008 with 1 Axes>"
]
},
"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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 truncated
"text/plain": [
"<Figure size 1008x1008 with 1 Axes>"
]
@@ -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**&mdash;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**&mdash;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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 truncated
"image/png": "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 truncated
"text/plain": [
"<Figure size 1008x1008 with 1 Axes>"
]
},
"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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 truncated
"text/plain": [
"<Figure size 1008x1008 with 1 Axes>"
]
@@ -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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 truncated
"image/png": "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 truncated
"text/plain": [
"<Figure size 1008x1008 with 1 Axes>"
]
},
"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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 truncated
"text/plain": [
"<Figure size 1008x1008 with 1 Axes>"
]
@@ -431,7 +544,7 @@
}
],
"source": [
"plot_maze(random_maze(70, 70, poprandom))"
"show(poprandom)"
]
},
{