numberphile_candles_with_a_knife.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "numberphile_candles_with_a_knife.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOCZS4OjOX0HC8ntojy9FgR",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GregSym/Numberphile_Follow_Alongs/blob/spoon/numberphile_candles_with_a_knife.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Candles with a knife\n",
        "\n",
        "Numberphile Video:\n",
        "\n",
        "Part 1:\n",
        "https://youtu.be/FkVe8qrT0LA\n",
        "\n",
        "Part 2:\n",
        "https://youtu.be/l5gUrDg01cQ\n",
        "\n",
        "## The easy part\n",
        "\n",
        "The simple case laid out in the video is one of a cake (excellent) with two randomly positioned candles, either exactly in the centre along the breadth or in negligible Y-axis positions, and with randomly assigned positions along the length.\n",
        "\n",
        "The cake is sliced (hip hip) randomly (OHSA who?) and the resultant cake has two slices, with the two candles either both on one side or split up on either side.\n",
        "\n",
        "This most distributed of cases is the target in the simple version of the question (we'll set that up first)\n",
        "\n",
        "## The Hard Part TM\n",
        "\n",
        "The hard part, and the challenge for this code, is to determine what happens when the cake goes at _least_ two dimensional"
      ],
      "metadata": {
        "id": "2fOHMP_1eDUs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The Easy Part\n",
        "### I never remember exactly how the random module works\n",
        "It's literally the easiest thing but I look it up every time!"
      ],
      "metadata": {
        "id": "UtN7JHY8XnZ8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YICfB6H3Twxt",
        "outputId": "c93a0c5d-ec5e-41e6-f732-f308147f8d90"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.09469998381560318"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import random\n",
        "\n",
        "random.random()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "gonna leave this here because it's worth going over how the RNG everything depends on is going to work.\n",
        "\n",
        "There are better randomness and cryptography libraries available, but random.random is fine for this purpose"
      ],
      "metadata": {
        "id": "Ot0ShM-_gYlq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "help(random.random)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JRcbCUYrUJKo",
        "outputId": "45cfabce-62e0-4b28-fc21-a30812156c68"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on built-in function random:\n",
            "\n",
            "random(...) method of random.Random instance\n",
            "    random() -> x in the interval [0, 1).\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dataclasses have a handy initialisation option to call lambdas for you by default. (could do this in a manual \\_\\_init\\_\\_, but it also looks neater this way)"
      ],
      "metadata": {
        "id": "oGQMeQWJX6EE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Modelling Cake"
      ],
      "metadata": {
        "id": "Th955bY6gJb5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from dataclasses import dataclass, field\n",
        "\n",
        "@dataclass\n",
        "class Cake:\n",
        "  c1: float = field(default_factory=random.random)\n",
        "  \"\"\"one of the candles (1)\"\"\"\n",
        "  c2: float = field(default_factory=random.random)\n",
        "  \"\"\"one of the candles (2)\"\"\"\n",
        "  cut: float = field(default_factory=random.random)\n",
        "  \"\"\"the cut TM (with a k?)\"\"\"\n",
        "\n",
        "  @property\n",
        "  def candle_per_side(self):\n",
        "    \"\"\" does each side have a candle? \"\"\"\n",
        "    return (self.c1 < self.cut and self.c2 > self.cut) or (self.c2 < self.cut and self.c1 > self.cut)\n",
        "\n",
        "Cake().candle_per_side"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lww2dnbGUTdb",
        "outputId": "bb0efe93-f6cb-41db-86e6-917f9352646e"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Monte Cakeo"
      ],
      "metadata": {
        "id": "jvwc0zrdgAeK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import collections\n",
        "\n",
        "def monte_cakeo(size: int = 100000):\n",
        "  tally = collections.Counter()  # a bit like a defaultdict but specifically for counting\n",
        "  for i in range(size):\n",
        "    tally[Cake().candle_per_side] += 1\n",
        "  return tally\n",
        "\n",
        "monte = monte_cakeo()\n",
        "monte"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XvKFKj2oVI6D",
        "outputId": "4891c022-9db8-4daa-df65-5d4067cc9ea8"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Counter({False: 66660, True: 33340})"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rate_of_condition = monte[True] / (monte[True] + monte[False])\n",
        "rate_of_condition "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TBVMsHswWkOI",
        "outputId": "cae04418-1209-42b8-aa0a-bc3b309deca5"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.3334"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The Hard Part??"
      ],
      "metadata": {
        "id": "yC7Yeqcsg6zi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "R3tJen2KXSxT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}