Add files via upload

ipynb/ClimbingWall.ipynb

@@ -8,15 +8,13 @@
     "\n",
     "# Climbing Wall\n",
     "\n",
-    "From the 538 Riddler's [23 July 2021 issue](https://fivethirtyeight.com/features/can-you-hop-across-the-chessboard/):\n",
+    "From the 538 Riddler on [23 July 2021](https://fivethirtyeight.com/features/can-you-hop-across-the-chessboard/) (slightly rephrased):\n",
     "\n",
-    ">Today marks the beginning of the Summer Olympics! One of the brand-new events this year is sport climbing, in which competitors try their hands (and feet) at lead climbing, speed climbing and bouldering.\n",
+    ">Today marks the beginning of the Summer Olympics! One of the brand-new events this year is [sport climbing](https://olympics.com/tokyo-2020/en/sports/sport-climbing/).\n",
     ">\n",
-    ">Suppose the event’s organizers accidentally forgot to place all the climbing holds on and had to do it last-minute for their 10-meter wall (the regulation height for the purposes of this riddle). Climbers won’t have any trouble moving horizontally along the wall. However, climbers can’t move between holds that are more than 1 meter apart vertically.\n",
-    ">\n",
-    ">In a rush, the organizers place climbing holds randomly until there are no vertical gaps between climbing holds (including the bottom and top of the wall). Once they are done placing the holds, how many will there be on average (not including the bottom and top of the wall)?\n",
+    ">Suppose the organizers place climbing holds randomly on the 10-by-10 meter square climbing wall until there are no vertical gaps more than 1 meter between climbing holds (including the bottom and top of the wall). The climbers can handle horizontal gaps of any size. On average, how many holds have to be placed (not including the bottom and top of the wall)?\n",
     "\n",
-    "I'll define `place_holds` as a Monte Carlo simulation that selects uniform random hold locations until no gap is more than 1:"
+    "A hold can be represented by a single number, the vertical height off the ground (the horizontal position of the hold doesn't matter). I'll define `place_holds` as a Monte Carlo simulation that selects random hold heights (uniformly from 0 to 10 meters) until no gap is more than 1 meter and returns the list of holds:"
    ]
   },
   {
@@ -26,20 +24,20 @@
    "outputs": [],
    "source": [
     "import random\n",
-    "from typing import List\n",
+    "from typing import List, Tuple, Iterable\n",
     "from statistics import mean\n",
     "\n",
     "def place_holds(top=10) -> List[float]:\n",
-    "    \"\"\"Place holds on wall until no gap is more than 1.\"\"\"\n",
+    "    \"\"\"Randomly place holds on wall until no gap is more than 1.\"\"\"\n",
     "    holds = [0, top]\n",
     "    while max(gaps(holds)) > 1:\n",
     "        holds.append(random.uniform(0, top))\n",
     "        holds.sort()\n",
     "    return holds[1:-1] # (not including the bottom and top of the wall)\n",
     "        \n",
-    "def gaps(numbers) -> List[float]:\n",
+    "def gaps(numbers) -> Iterable[float]:\n",
     "    \"\"\"The differences between adjacent pairs of sorted numbers.\"\"\"\n",
-    "    return [numbers[i] - numbers[i - 1] for i in range(1, len(numbers))]"
+    "    return (numbers[i + 1] - numbers[i] for i in range(len(numbers) - 1))"
    ]
   },
   {
@@ -57,20 +55,11 @@
     {
      "data": {
       "text/plain": [
-       "[0.2174318085529534,\n",
-       " 0.3246749454836446,\n",
-       " 0.6326268620662914,\n",
-       " 0.6381873992245448,\n",
-       " 0.6579032162296619,\n",
-       " 0.7250061911052263,\n",
-       " 1.0515460945502828,\n",
-       " 1.5119309951687048,\n",
-       " 2.15396033960555,\n",
-       " 2.7599575760459114,\n",
-       " 3.2936277160533924,\n",
-       " 3.2997054391317278,\n",
-       " 3.7149308611754135,\n",
-       " 3.803685937586361]"
+       "[0.8490771290915906,\n",
+       " 1.043223518543252,\n",
+       " 1.7988034611180812,\n",
+       " 2.5516167786335906,\n",
+       " 2.590651506408302]"
       ]
      },
      "execution_count": 2,
@@ -79,7 +68,7 @@
     }
    ],
    "source": [
-    "place_holds(4)"
+    "place_holds(3)"
    ]
   },
   {
@@ -90,19 +79,10 @@
     {
      "data": {
       "text/plain": [
-       "[0.10724313693069121,\n",
-       " 0.30795191658264676,\n",
-       " 0.005560537158253442,\n",
-       " 0.019715817005117042,\n",
-       " 0.06710297487556449,\n",
-       " 0.32653990344505646,\n",
-       " 0.46038490061842197,\n",
-       " 0.6420293444368452,\n",
-       " 0.6059972364403614,\n",
-       " 0.533670140007481,\n",
-       " 0.0060777230783353176,\n",
-       " 0.41522542204368573,\n",
-       " 0.08875507641094771]"
+       "[0.1941463894516613,\n",
+       " 0.7555799425748293,\n",
+       " 0.7528133175155094,\n",
+       " 0.03903472777471162]"
       ]
      },
      "execution_count": 3,
@@ -111,14 +91,14 @@
     }
    ],
    "source": [
-    "gaps(_)"
+    "list(gaps(_))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now the Monte Carlo algorithm computes the mean number of holds over repeated simulations:"
+    "The Monte Carlo algorithm computes the expected number of holds created by `place_holds`:"
    ]
   },
   {
@@ -127,7 +107,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def monte_carlo(fn, *args, repeat=10_000, key=len) -> float:\n",
+    "def monte_carlo(fn, *args, repeat=50_000, key=len) -> float:\n",
     "    \"\"\"Mean value of key(fn(*args)), repeated `repeat` times.\"\"\"\n",
     "    return mean(key(fn(*args)) for _ in range(repeat))"
    ]
@@ -140,7 +120,7 @@
     {
      "data": {
       "text/plain": [
-       "43.014"
+       "43.05824"
       ]
      },
      "execution_count": 5,
@@ -156,19 +136,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Answer:** The expected number of holds is about **43** (which I found surprisingly large).\n",
+    "**Answer: The expected number of holds is about 43** (which I found surprisingly large).\n",
     "\n",
     "# Extra Credit\n",
     "\n",
-    "> Now suppose climbers find it just as difficult to move horizontally as vertically, meaning they can’t move between any two holds that are more than 1 meter apart in any direction. Suppose also that the climbing wall is a 10-by-10 meter square. If the organizers again place the holds randomly, how many have to be placed on average until it’s possible to climb the wall?\n",
+    "> Now suppose horizontal gaps *do* matter. The organizers randomly place climbing holds until there is a path from the bottom to a hold, and then to successive holds, and finally to the top, where each step in the path is no more than 1 meter distance. On average, how many holds have to be placed?\n",
     "\n",
-    "I'll again do a Monte Carlo simulation, placing holds at uniform random locations on a 10-by-10 meter wall, until there is a path from the bottom to top. To help determine if there is a path, I'll keep track, for every hold, of the highest hold that can be reached from that hold. The data structure `Wall` will be a mapping of `{hold: highest_reachable_hold}`. When a new hold is added to the wall, we update highest reachable holds as follows: \n",
-    "- Find all holds `hold2` that are within 1 meter of the new `hold`.\n",
-    "- We can now `merge` the holds reachable (transitively) from `hold` and those reachable from `hold2`.\n",
-    "- Let `new_max_hold` be the highest hold reachable by `hold` or `hold2`\n",
-    "- Update all the holds that are reachable from either `hold` or `hold2` to now reach `new_max_hold`.\n",
-    "- If we find a hold `h` that is within 1 meter of the bottom and can reach a hold within one meter of the top, add `h` to the `starts` set.\n",
-    "\n"
+    "This time a hold is represented by a point in 2-D space: an `(x, y)` tuple of two numbers:"
    ]
   },
   {
@@ -177,45 +151,24 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# A 2-D point is an (X, Y) tuple:\n",
+    "Hold = Point = Tuple[float, float]\n",
     "def X_(point): return point[0]\n",
     "def Y_(point): return point[1]\n",
     "\n",
-    "class Wall(dict):\n",
-    "    \"\"\"A Wall is a mapping of {hold: highest_reachable_hold}.\n",
-    "    Also keep track of `starts`: a set of holds that are within 1 \n",
-    "    of the bottom, and can reach to a hold within 1 of the top.\"\"\"\n",
-    "    def __init__(self, top=10): \n",
-    "        self.top = top\n",
-    "        self.starts = set()\n",
-    "    \n",
-    "    def add(self, hold):\n",
-    "        \"\"\"Add hold to this `Wall`, and merge groups if needed.\"\"\"\n",
-    "        self[hold] = hold\n",
-    "        for hold2 in self:\n",
-    "            if hold is not hold2 and distance(hold, hold2) <= 1:\n",
-    "                self.merge(hold, hold2)\n",
-    "\n",
-    "    def merge(self, hold1, hold2):\n",
-    "        \"\"\"Update the highest reachable hold for hold1, hold2, and all they can reach.\"\"\"\n",
-    "        old_max_holds = self[hold1], self[hold2]\n",
-    "        new_max_hold = max(old_max_holds, key=Y_)\n",
-    "        for h in self:\n",
-    "            if self[h] in old_max_holds:\n",
-    "                self[h] = new_max_hold\n",
-    "                if self.top - Y_(new_max_hold) <= 1 and Y_(h) < 1:\n",
-    "                    self.starts.add(h)\n",
-    "    \n",
-    "def distance(A, B): return abs(complex(*A) - complex(*B))"
+    "def distance(A: Point, B: Point) -> float: \n",
+    "    return abs(complex(*A) - complex(*B))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "*Note*: This could be made more efficient with a [kd-tree](https://en.wikipedia.org/wiki/K-d_tree) to see what holds are near each other, and a [union-find forest](https://en.wikipedia.org/wiki/Disjoint-set_data_structure) to merge groups. But since the number of hold points is small, I opted for simplicity, not efficiency.\n",
-    "\n",
-    "Now, we just need to keep adding random holds to the wall until there are one or more `wall.starts` holds: holds that are within 1 meter of the bottom and can attain a hold within 1 meter of the top. Then we can do a Monte Carlo simulation and find the mean number of holds."
+    "To make it easier to determine if there is a path from bottom to top, I'll keep track, for every hold, of the highest hold that can be reached from that hold (in any number of steps). The data structure `Wall` will be a mapping of `{hold: highest_reachable_hold}`. When a new `hold` is added to the wall, we update the mapping as follows: \n",
+    "- Find all holds that are within 1 meter of the new `hold`.\n",
+    "- For each of those holds, look up the highest hold they can reach. Call that set of holds `reachable_holds`.\n",
+    "- Any hold on the wall that can reach one of these `reachable_holds` can reach all of them, and thus the highest of them.\n",
+    "- So update each such hold to reflect the fact that it can reach the `highest_hold`.\n",
+    "- Also, if the `highest_hold` is within a meter of the top, and a hold `h` that can reach it is within a meter of the bottom, update the `paths` attribute of the wall to include the path `{h: highest_hold}`."
    ]
   },
   {
@@ -224,49 +177,96 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def place_holds_2d(top=10) -> Wall:\n",
-    "    \"\"\"Randomly place holds on wall until there is a path from bottom to top.\"\"\"\n",
-    "    wall = Wall(top)\n",
-    "    while not wall.starts:\n",
-    "        wall.add((random.uniform(0, top), random.uniform(0, top)))\n",
-    "    return wall"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "143.004"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "monte_carlo(place_holds_2d, repeat=1000)"
+    "class Wall(dict):\n",
+    "    \"\"\"A Wall is a mapping of {hold: highest_reachable_hold}.\n",
+    "    Also keep track of `wall.paths`: a map of {start_hold: end_hold}\n",
+    "    where there is a path from start to end, and start is within 1 \n",
+    "    of the bottom, and end is within 1 of the top.\"\"\"\n",
+    "    def __init__(self, top=10): \n",
+    "        self.top = top\n",
+    "        self.paths = {} # Paths of the form {hold_near_bottom: hold_near_top}\n",
+    "    \n",
+    "    def add(self, hold: Point):\n",
+    "        \"\"\"Add hold to this Wall, and merge groups of holds.\"\"\"\n",
+    "        self[hold] = hold # A hold is always reachable from itself\n",
+    "        self.merge({self[h] for h in self if distance(hold, h) <= 1})\n",
+    "\n",
+    "    def merge(self, reachable_holds):\n",
+    "        \"\"\"If you can reach one of these holds, you can reach the highest of them.\"\"\"\n",
+    "        if len(reachable_holds) > 1:\n",
+    "            highest_hold = max(reachable_holds, key=Y_)\n",
+    "            for h in self:\n",
+    "                if self[h] in reachable_holds:\n",
+    "                    self[h] = highest_hold\n",
+    "                    if Y_(h) <= 1 and self.top - Y_(highest_hold) <= 1:\n",
+    "                        self.paths[h] = highest_hold"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Answer:** The expected number of holds is about **143** (which I found surprisingly small).\n",
+    "*Note: This could be made more efficient with a [kd-tree](https://en.wikipedia.org/wiki/K-d_tree) to quickly find holds that are near each other, and a [union-find forest](https://en.wikipedia.org/wiki/Disjoint-set_data_structure) to merge groups of holds. But since the expected number of points is small, I opted for simplicity, not efficiency.*\n",
     "\n",
-    "# Visualization\n",
-    "\n",
-    "To get an idea what random walls look like, and to gain confidence in this program, I'll plot some walls, with red dots indicating the random holds, and dotted lines indicating possible paths from bottom to top."
+    "I'll again do a Monte Carlo simulation, defining `place_holds_2d` to build a climbable wall:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def place_holds_2d(top=10) -> Wall:\n",
+    "    \"\"\"Randomly place holds on wall until there is a path from bottom to top.\"\"\"\n",
+    "    wall = Wall(top)\n",
+    "    while not wall.paths:\n",
+    "        wall.add((random.uniform(0, top), random.uniform(0, top)))\n",
+    "    return wall"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we can estimate the expected number of holds:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "143.0992"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "monte_carlo(place_holds_2d, repeat=5000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Answer: The expected number of holds is about 143** (which I found surprisingly small).\n",
+    "\n",
+    "# Visualization\n",
+    "\n",
+    "To get an idea what random climbing walls look like, and to gain confidence in this program, I'll plot some climbing walls, with green dots indicating the random climbing holds, and yellow lines indicating possible paths from bottom to top."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
@@ -274,32 +274,32 @@
     "def plot_wall(wall):\n",
     "    \"\"\"Plot the holds on the wall, and the paths from bottom to top.\"\"\"\n",
     "    plt.gca().set_aspect('equal', adjustable='box')\n",
-    "    ends = {wall[h] for h in wall.starts}\n",
+    "    ends = set(wall.paths.values())\n",
     "    for h in wall:\n",
     "        if wall[h] in ends:\n",
-    "            if Y_(h) <= 1:\n",
-    "                plot_points([h, (X_(h), 0)], 'k:')\n",
-    "            if wall.top - Y_(h) <= 1:\n",
-    "                plot_points([h, (X_(h), wall.top)], 'k:')\n",
+    "            if Y_(h) <= 1: # Plot vertical line from bottom\n",
+    "                plot_points([h, (X_(h), 0)], 'y-')\n",
+    "            if wall.top - Y_(h) <= 1: # Plot vertical line to top\n",
+    "                plot_points([h, (X_(h), wall.top)], 'y-')\n",
     "            for h2 in wall:\n",
     "                if distance(h, h2) <= 1:\n",
-    "                    plot_points([h, h2], 'k:')\n",
-    "    plot_points(wall, 'r.')\n",
-    "    plt.title(f'holds: {len(wall)}; start points: {len(wall.starts)}')\n",
+    "                    plot_points([h, h2], 'y-') # Plot path\n",
+    "    plot_points(wall, 'g.') # Plot all holds\n",
+    "    plt.title(f'holds: {len(wall)}     starts: {len(wall.paths)}')\n",
     "\n",
     "def plot_points(points, fmt):\n",
-    "    \"\"\"Plot (X, Y) points with given format.\"\"\"\n",
+    "    \"\"\"Plot (x, y) points with given format.\"\"\"\n",
     "    plt.plot([X_(p) for p in points], [Y_(p) for p in points], fmt)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -311,7 +311,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPkAAAEICAYAAACd9lKYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd3hURdfAf7ObbAoBKaEjoUeqlAgEXkkIoAgIIhj4RJovINgAQQQsYAEsCIiKiPBSRURRBATpAZKNiDQp0nuRHkraZnfP98duYggJhGQ3u5vc3/PcJ9l75945t5wpZ86cUSKChoZG/kXnagE0NDSci6bkGhr5HE3JNTTyOZqSa2jkczQl19DI52hKrqGRz8m3Sq6UOqGUap3Dc0UpVS2LY32UUtG5k04jpyil9imlwl0thyeRb5Xc3VFKRSqljEqpBKVUVIZjNZRSvyilLimlriqlViulgtMd762U2q6UuqGUOqOU+lgp5eUAmeYopT7I5TWcWgiKSG0RicqmLDku6DO51stKqT+VUslKqTmZHPdXSk1TSl1WSl1XSm12RL6OQFNy13EVmAJ8mMmxosAyIBgoDfwB/JLuuD8wBAgEmgCtgOHOFDY7OKKgcWPOAR8A/8vi+AygOFDT/ndoHsl1b0QkX27ACWwf/l/AdeB7wDfd8f7AEWzKtgwol+6YANXs/5ewH7+BTdneB6LtxxQwGbhoz+MvoM59ytkPiLpHmuJ2mUpkcfw1YHm639OAaVmkzVRmYACQApiAW6nXA0YCR4GbwH6gc7pr9QFi7Ne7CiwBkgCL/RpxWcgQBUywP8/r2Aqw4umOdwT2AXH2tDUzvNfW9v/HAouBeXb59gEh9mPzASuQaJdlBOALLACu2K+9DSh9n+/rA2BOhn3B9u+jiKu/+0xldrUATrsx28fwB1DOriR/AwPtxyKAy0BDwAf4HNic7tz0Sr7I/iEVsivD2XRK/jiwHVvNq7CV4mXtx54F/sqGnNlR8qeA83c5vhT4MJvP5W4yzwE+yJD+Gfsz1AHdgPh06fsAZuAVwAvws++LvocMUfbnWMf+XJcAC+zHatjzaAN425XzCGBI917TK3kS0A7QYys4fs/wDbRO9/sFYDm2lpAeaJSqmNgKsxXZeH6ZKXkvYA+2wu6y/f8urtaB1C2/N9enisg5EbmK7eXWt+/vAfxPRHaISDIwCghVSlVKf7JSSg90Ad4RkXgR2QvMTZckBSgMPAQoEflbRM4DiMhCEamX2xtQSlUAvsRWW2d2vC8QAkzM5iWzlDkzROQH+zO0isj3wGGgcbok50TkcxExi0hiNmUAmC8ie0UkHngbiLQ/727AryKyVkRS7PflBzTL4jrRIrJSRCzYau+H75JnCraWWTURsYjIdhG5Yb/PD0Wkw33In54K2Aqs69gKxJeBuUqpmjm8nkPJ70r+T7r/E4AA+//lgJOpB0TkFrYmXPkM55fEVkOdTrcv/XkbgC+wKeEFpdQMpVQRRwmvlCoJrMHW9P4uk+NPYevTPyEil7NzzfuVWSnVSym1SykVp5SKw/YxB6ZLcjqLU+9Fxmfqbb9uxndjtafN+G5SyfiOfe9iG5gPrAYWKaXO2Q2W3jmUPz2J2AqQD0TEJCKbgI3AYw64dq7J70qeFeeAoNQfSqlC2Er4sxnSXcLWHH0w3b6K6ROIyFQRaQTUxtbUfN0RAiqlimFT8GUiMi6T422Bb4AnRWTP/Vz7LjLfNiVRKRVkz+NlbPaAosBebM18Mjsnk99ZkfGZpmBr6mZ8N8qeNuO7yQ63ySIiKSLyrojUwtYy6ICtqZ1b/nLANZxGQVXyhUBfpVR9pZQPMB7YKiIn0ieyNwF/Asbah0hqAb1TjyulHlFKNbHXBvH8a3S6J0opvVLKF1tLQaeU8k2tVew162ogRkRGZnJuBPAttn7fH5kcn5PZME82ZL4AVEmXvBA2RblkP7cvtpr8blwAKiilDPdI95xSqpZSyh94D/jR/rwXA+2VUq3sMg4DkgHjPa6XlSxp96OUaqmUqmvvFtzAVrBk93152d+XHtDb31dqi2EzcAoYZU/XHAjH9g5dj6uNAs7auNPoMha7ccf+eyA2q/FVYAVQId2x9Ia3kvbjmVnXW2ErxW9hq4W+BQLsx3oA++4iXx97Pum3OfZjve2/4+3XTt0q2o9vxNbCSH9sVbprrwf6Z5Hv3WSuDuzCZnleat83zv6MLgOTgE1Av3T3EJ3h+gbg19RzspAhin+t6zew2UsC0x3vjM2Sf92eX+3M3msm77SS/bl52X93wqZ8cdhGWv4POGh/rheAqenSjk7/DDOReWwm72tsuuO1gVj7tW8bhXD1puwCauQT7DXobqCe2AxXbofd+WeBiMx0tSwFgfzsvFAgERETtmExDQ2g4PbJNTQKDFpzXUMjn6PV5Boa+Zw87ZMHBgZKpUqV8jJLDY0Cw/bt2y+LSMmM+/NUyStVqsSff/6Zl1lqaBQYlFInM9uvNdc1NPI5mpJraORzNCXX0MjnaEquoZHP0ZRcQyOfc08lV0r9Tyl1USm1N92+4kqptUqpw/a/xZwrpoaGRk7JTk0+B2ibYd9IYL2IVMc24+mO6ZAa+YTYWJgwwfZXwyO55zi5iGzOGBYJ2xS+cPv/c7FNHXzDgXJpuAOxsVhatkRvNoPBAOvXQ2ioq6XSuE9y2icvLf/GMjsPlMoqoVJqgD1e9Z+XLl3KYXaeT0JCAgkJCTk+/6effuKnn37K8fnh4eGEh4dnez/AtwMGIMnJYLGAyQRRUTnO363J562VbE1QsdfkK0Skjv13nNhCAaUevyYi9+yXh4SESH71ePv1rbcoc+AAjYYNc0ptl6qIUXZFS1X4p59+OlvnpxYw/v7+t+1PSbFNOV++fDkAjRs35sMPP6R9+/aUOX6c4Jdewkcp9L6++bMmj42FVq1shZiHt1aUUttFJCTj/py6tV5QSpUVkfNKqbLYYni7lthYW00THp73Lyk2llYTJuBltZKybBnemzbdIcOCBQsAeO6553KUxS+//HLb76lTpwLZV/KMyp2Kt7d32vVEhJiYGCwWCxcvXqRVq1aUWLSICkePQsuWHvvx35WoKJuCp2+t5LP7zKmSL8MWouhD+99f7p7cybi6NI6KwgdbdEOL2ZzphzJzpi0ISk6V/IEHHrjtd0alvxdZFTLLR4/m6s8/075mTXpPn07//v3x8/Nj7NixNGjQgLOvv857772XI5k9gvBw2zeT+u1k0XXxaLIRK+074Dy2oHdngP9ii2y6HlsM7vWkW/3iblujRo3EKYwfL6LXi4Dt7/jxzsknK4xGET8/ser1In5+IkajDBs2TCZMmJCWxGQyiclkynEWixYtkkWLFuX4/LCwMAkLC7tt35kffpB4kBSQeJBtU6emHXvppZekbNmycu7cuRzn6TEYjbZvxmh0tSS5AvhTMtPhzHY6a3OaktuVTNIpWZ6T7kOxWCwSEBAgRYoUEYvF4pDLZ1TS+1X69IWMxWKR559/Xr4KCpIUEAExKyW7u3dPS79582b5/PPPHSK7Rg7IQcGTv5VcxO1K4ytXrsiuXbtEROTMmTPyTps28meXLjmWLz4+XuLj49N+Z1YzZ4ft27fLU089JXq9XloXKiRJer2YQBJ1OhlUv76IiEycOFG6dOkiSUlJOZLVbXGzbyRLclhp5X8ld2MG1K2b1ixO8fZ2yEeWUenvxYKXXpKJgYHSo0oVqVy5sgwdOlTi4uLk2sqVEv/WW5K4YYPEx8eLyWSSDh06yJNPPplrGd0Kd2jtZZccdj+zUnItWmseMKljR3z27EHPv4a542XKsGbNGvr3749Od293hYyGs6ys5emxWCzo9XpeCQnho+3bMQDmq1cxrVxJkccfB8Dcpg07AwMpWbIklfz92bBhAytWrGDFihU5vl+3JLdW9LwcvXG0MTAzzXfWVlBr8vSGOau9FunWrZsA8uOPP4qI3LNpnLF5Pn/+fJk/f36maffs2SOhoaFSokQJiYuLk68rV07re6fAbTVDQkKCABIaGirz5s2TXbt2yd9//+0wW4LbkJua3BWtAK1P7oFkeGmnT5+WYcOGidVqFRGRRo0aSeHChSU5OTnT0zNa59MrfWJiokydOlWeeOIJ2bt3r8yZM0cACQoKkjNnzohp0yaxphYyvr4iRqMcOHAg7VplypSRwMBAqV+/vgCyePFiJz0EF5PTPrmrR2+yiabkbk7fvn3lkUceSfvdqlUrGTVqVJbpz507J59++qkYjUa5fPmyKKXE399fli1bJgkJCVKuXDl5//33/z0h3Qe+e/du0el0Eh4eLlarVa5duybJyckSGRkpjz322H319QsEOanJXWDk05Tcg0hISBBvb29p2LChiIhYrVZ5p00b2fzEE3Jk/nyxWq0SFBQkBoNBBg4cKCIiVatWFaWUXLly5Z7XN5lM8p///EdGjx4tIjbr/8KFC6Vv374yduxY592YJ3M/SusiI19WSq4Z3twQPz8/EhISuHr1KgAbx4/njbVrMQApq1Zxq1QpBtWvT6CXFx2feAKAl156ia1bt+Lr63vP63t7e7NlyxZEBKvVyhNPPEGhPXt4uU4devTv78xb81xCQ7NvcHMzV1lNyd0ULy8vSpWyTe5rZjLhxb8v66+RI3ll506btfypp3ivbVuOly7NoUOHWL16NT/88AP+/v7s2LGD9957jzlz5lCiRAm2bdvGhAkTmDZtGuXKlWPr1q0MHz6cQnv2sB4w7N1rcw9250karpyjkF3czFVWC//kAfi2bYtZp8MMePn5UahQIQzYlN6gFCE3b1KyZEkqVKhAoUKFKFWqFCVKlKBChQr4+/tTunTptN9+fn6UKVOG4sWLU6FCBSpXrsyLtWrho5StEHHnKaWpcxTeftv2112nhoaG2grK9993jwIzsza8szatT55ztnz8sWzv2lXEaJTJkZELine truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -323,7 +323,7 @@
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -335,7 +335,7 @@
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -347,7 +347,7 @@
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -359,7 +359,7 @@
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -371,7 +371,7 @@
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -383,7 +383,31 @@
     },
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -395,8 +419,8 @@
     }
    ],
    "source": [
-    "for i in range(8):\n",
-    "    plot_wall(place_holds_2d())\n",
+    "for i in range(10):\n",
+    "    plot_wall(place_holds_2d(10))\n",
     "    plt.show()"
    ]
   },
@@ -406,12 +430,14 @@
    "source": [
     "# Different Size Walls\n",
     "\n",
-    "What if the wall had a size other than 10 meters? I would expect that the number of holds goes up roughly linearly on the 1-D wall, and roughly quadratically on the 2-D wall. I can plot expected number of holds for different wall heights, and fit a quadratic polynomial to the data: "
+    "What if the wall had a size other than 10 meters? \n",
+    "\n",
+    "My guess would be that the expected number of required holds goes up roughly linearly on the 1-D wall, and roughly quadratically on the 2-D wall. I can plot expected number of holds for different wall heights, and fit a quadratic polynomial to the data (using `np.polyfit` and `np.poly1d`): "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -427,31 +453,32 @@
     "    plt.legend()\n",
     "    return coefs\n",
     "\n",
-    "def poly_name(parms) -> str:\n",
+    "def poly_name(coefs, ndigits=2) -> str:\n",
     "    \"\"\"A str representing a polynomial.\"\"\"\n",
-    "    degree = len(parms) - 1\n",
-    "    return ' + '.join(term(coef, degree - i) for i, coef in enumerate(parms))\n",
+    "    degree = len(coefs) - 1\n",
+    "    return ' + '.join(term(round(coef, ndigits), degree - i) \n",
+    "                      for i, coef in enumerate(coefs))\n",
     "\n",
     "def term(coef, d) -> str: \n",
     "    \"\"\"A str representing a term in a polynomial.\"\"\"\n",
-    "    return f'{coef:.2f}' + ('' if d == 0 else 'x' if d == 1 else f'x^{d}')"
+    "    return f'{coef}' + ('' if d == 0 else 'x' if d == 1 else f'x^{d}')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First 1-D walls—we see the best-fit quadratic is almost a straight line with slope 4.5, but has a slight upward bend."
+    "First 1-D walls—we see the best-fit quadratic is almost a straight line, but has a slight upward bend:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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 truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -463,7 +490,7 @@
     }
    ],
    "source": [
-    "fit(range(1, 31), place_holds);"
+    "fit(range(1, 41), place_holds);"
    ]
   },
   {
@@ -480,7 +507,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3hUVf7H8feZkkJL6KYAoQUihCQkhGZBWQUsFBXECopiwRXX1RV1167ooqusAv5QpCiC9KJgUIqFZiChBGIAqUmQnoSSZNr5/TFDlkBIAkwyycz39Tw8mbn3ztzvdcZPbs499xyltUYIIYR3MXi6ACGEEO4n4S6EEF5Iwl0IIbyQhLsQQnghCXchhPBCJk8XANCgQQMdERHh6TKEEKJa2bhx41GtdcOS1lWJcI+IiGDDhg2eLkMIIaoVpdS+i62TZhkhhPBCEu5CCOGFJNyFEMILVYk295JYrVYyMzMpKCjwdCnCRwUEBBAeHo7ZbPZ0KUJcsiob7pmZmdSuXZuIiAiUUp4uR/gYrTXHjh0jMzOT5s2be7ocIS5ZlQ33goICCXbhMUop6tevz5EjRzxdivBSC1KzGJOUQXZOPqHBgTzfqw3948Lc9v5VNtwBCXbhUfL9ExVlQWoWL87bSr7VDkBWTj4vztsK4LaAlwuqQghRycYkZRQF+1n5VjtjkjLctg8JdyGEqGTZOfkAdFQ7eNK4kI5qR7Hl7uA14b4gNYvu766g+ajv6P7uChakZlXYvnr06FHhd9SuWrWK22677ZJec7G6pkyZwlNPPXVJ7/XDDz8QHx9PdHQ08fHxrFixosTtLue9hfB1DWv701HtYLrfOzxrms10v3foqHYQGhzotn1U6Tb38qqM9itf06BBAxYvXkxoaChpaWn06tWLrKyK+4UphK+w2h34GRRdDNsxY8OkHKBtXGP+nRa9BrltP9Ui3F9fvI3t2XkXXZ+6PweL3VFsWb7Vzj/mbGHGb/tLfM3VoXV49fZ2pe5379699O7dm86dO5OamkpkZCTTpk0rts0TTzxBcnIy+fn53HXXXbz++usAJCcnM3LkSE6fPo2/vz/Lly+nRo0ajBo1ilWrVlFYWMiIESN47LHHLrr/U6dOcdddd5GWlkZ8fDxfffUVSimWL1/Oc889h81mo1OnTkyYMAF/f/9ir508eTKjR48mJCSEyMjIovWzZ8/m9ddfx2g0EhQUxM8//1zivuPi4ooet2vXjoKCAgoLC/H397/oewshyvbJil3ceGoh9wRtw3bGBNqGTZmIv64v1/tKb5nyOj/Yy1p+KTIyMpg0aRLdu3fn4YcfZvz48cXWv/3229SrVw+73U7Pnj3ZsmULbdu25e677+abb76hU6dO5OXlERgYyKRJkwgKCiI5OZnCwkK6d+/OzTfffNF+1KmpqWzbto3Q0FC6d+/O6tWrSUhIYOjQoSxfvpzIyEgefPBBJkyYwDPPPFP0uoMHD/Lqq6+yceNGgoKCuOGGG4rC+o033iApKYmwsDBycnLK9d9g7ty5xMXF4e/vX+p7CyFKt/lADp+s3MXopg1pUq8VdP4P7F+NKeJarm+S6NZ9VYtwL+sMu/u7K8gq4UJEWHAg3zzW9Yr23aRJE7p37w7A/fffz3//+99i62fNmsXEiROx2WwcPHiQ7du3o5QiJCSETp06AVCnTh0Ali1bxpYtW5gzZw4Aubm57Ny586LhnpiYSHh4OACxsbHs3buX2rVr07x5cyIjIwEYMmQI48aNKxbu69evp0ePHjRs6BwJ9O6772bHDucFm+7duzN06FAGDRrEHXfcUebxb9u2jRdeeIFly5aV+d5CiIvLt9j52zepNKrtT68hoyDABEpBsy4Vsr9qEe5leb5Xm2Jt7gCBZiPP92pzxe99fl/nc5/v2bOH999/n+TkZOrWrcvQoUMpKChAa11iH2mtNR9//DG9evUq177Pbe4wGo3YbDa01pdV91mffvop69ev57vvviM2NpZNmzZRv379ErfNzMxkwIABTJs2jZYtW5b53kKIi/vouw2MzhtF4M2vEhRY8UNaeEVvmf5xYYy+I5qw4EAUzjP20XdEu+Vi6v79+1m7di0AM2bM4Jprrilal5eXR82aNQkKCuLQoUMsXboUgLZt25KdnU1ycjIAJ0+exGaz0atXLyZMmIDVagVgx44dnD59+pLqadu2LXv37mXXrl0AfPnll1x//fXFtuncuTOrVq3i2LFjWK1WZs+eXbTujz/+oHPnzrzxxhs0aNCAAwcOlLifnJwcbr31VkaPHl30l0tZ7y2EKNnqXUf57rd0ImpY6BBWu1L26RVn7uAM+IroGRMVFcXUqVN57LHHaN26NU888QSLFy8GICYmhri4ONq1a0eLFi2KQtDPz49vvvmGv/71r+Tn5xMYGMiPP/7II488wt69e+nYsSNaaxo2bMiCBQsuqZ6AgAAmT57MwIEDiy6oPv7448W2CQkJ4bXXXqNr166EhITQsWNH7HbnXzXPP/88O3fuRGtNz549iYmJKXE/n3zyCbt27eLNN9/kzTffBJzNSqW9txDiQrn5Vp6bvZnABhHUGbEeAvwqZb+qvH/mV6SEhAR9fv/s9PR0oqKiPFSR0969e7nttttIS0vzaB3Cc6rC91BUb9Mn/pv8A5tIeORjYpuV3AR6uZRSG7XWCSWt85ozdyGEqGqWbj3Imf2p9K53iCbhdSp13xLupYiIiKjws/atW7fywAMPFFvm7+/P+vXrK3S/ZyUlJfHCCy8UW9a8eXPmz59fKfsXwlsdPlnAS/O3Et54BEOHdwRj5c4LIOHuYdHR0WzatMlj++/Vq1e5e+8IIcpHW86w89MhBFtu48O778DsX6PSa/CK3jJCCFGVLPv5F9qdWs2L8ZpWjSqnd8z55MxdCCHcaP+xMzz7syYxdBqT+vX0WB0S7kII4Sb29CUs/H4jBpXIm3d3w2Dw3A1/0ixTiocffphGjRrRvn37MrdNTk7GaDQWDS0AzrtKY2NjiY2NpW/fvuXe72OPPUbNmjUvGGb3P//5D1dffTUdOnSgZ8+e7Nu3r/wHU04bN24kOjqaVq1a8fTTT5d4R+z06dPp0KEDHTp0oFu3bmzevBlwTo2YmJhITEwM7dq149VXX3V7fecaPXo0rVq1ok2bNiQlJZW4zSeffEKrVq1QSnH06NGi5SdOnGDAgAF06NCBxMRE6e4qrsiC1CyGvzOe3TP+Tu8TX9O3Q0PC61Z+O3sxWmuP/4uPj9fn2759+wXLKttPP/2kN27cqNu1a1fqdjabTd9www26T58+evbs2UXLa9asecn7fPPNN/XAgQP11q1bddu2bfXmzZuL1q1YsUKfPn1aa631+PHj9aBBg0p9r5UrV+ohQ4Zc0v47deqk16xZox0Oh+7du7desmTJBdusXr1aHz9+XGut9ZIlS3RiYqLWWmuHw6FPnjyptdbaYrHoxMREvXbt2kva/1nNmjUrdf22bdt0hw4ddEFBgd69e7du0aKFttlsF2yXkpKi9+zZo5s1a6aPHDlStPy5557Tr732mtZa6/T0dH3jjTeWuJ+q8D0UVdv8lEw9+J9j9ZlXGmjrK8E6/5X6evA/P9LzUzIrfN/ABn2RXPWuM/cDv8EvHzh/usF1111HvXr1ytzu448/5s4776RRo0Zlbpubm0ubNm3IyHBOp3XPPffw2WefATB16lTS0tL4+uuvad++PYsWLeLRRx8tGiLghhtuoEYN59lAly5dyMzMvNxDK9HBgwfJy8uja9euKKV48MEHS7yDtlu3btStW/eCOpRS1KpVCwCr1YrVakUpVeoxX66FCxcyePBg/P39ad68Oa1ateK33y783OPi4oiIiLhg+fbt2+nZ09keenZIh0OHDl1RTcI3jf1+C0/zNWasmJQDE3biHNvcOmXe5ag+4T75Vkid7nxstzqfb/7G+dxyBj69FqbcAivehqm3O59vX+Rcf/qYc/sM59gvnHTf/8RZWVnMnz//giEAwNlMkZCQQJcuXYpCMigoiE8++YShQ4cyc+ZMTpw4waOPPgo4R3icOXMmJpPzUkjr1q1Zv349TZo0ueC9J02aRJ8+fdx2HGeP5ewolADh4eFlTtBxfh12u53Y2FgaNWrETTfdROfOnUs95iup9dz/LuWp9VwxMTHMmzcPgN9++419+/a5/Zel8A1NT6bSyZCBHSM2bcCKiXWOKLdOmXc5vOeCakEu2G2ABrvreSV45plneO+99zAajRes279/P6GhoezevZsbb7yR6OhoWrZsyU033cTs2bMZMWJEUXv1pfjqq6/YsGEDP/30U4nrO3fuTGFhIadOneL48ePExsYC8N5775Xap12X0L5e2giQK1euZNKkSfz6669Fy4xGI5s2bSInJ4cBAwaQlpZG+/bty3XMI0aMYPXq1QBkZ2cX1T1w4EBefvnlK6r1fKNGjWLkyJHExsYSHR1NXFxc0S9VIcrrcF4Bq4mlh+VDGnGCLoZ01jmiSNGRhLlxyrzLUa5vs1Lqb8AjgAa2Ag8BIcBMoB6QAjygtbYopfyBaUA8cAy4W2u994orfei7/z02mos/96sBd34OU/uC3QJGP+fzs4Pf16xffPvaja+4nLM2bNjA4MGDATh69ChLlizBZDLRv39/QkNDAWjRogU9evQgNTWVli1b4nA4SE9PJzAwkOPHjxc7Wy7Ljz/+yNtvv81PP/100RmQzt7dumrVKqZMmcKUKVNK3M5utxMfHw9A3759eeKJJ4qdvWZmZhYdw/m2bNnCI488wtKlS0scMjg4OJgePXrw/fff0759+3Id87hx44oeR0RElHpzV3h4eLERLUurtSR16tRh8uTJgPMXRfPmzS86rr4QJcld9xVv/HwapZpw2NCYTFtDUuzOeRbcNeT4lSizWUYpFQY8DSRordsDRmAw8B7woda6NXACGOZ6yTDghNa6FfCLine truncated
+      "image/png": "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 truncated
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]