Monty Hall Problem.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Monty Hall Problem\n",
    "\n",
    "The Monty Hall problem is a somewhat confusing one. From [Wikipedia](https://en.wikipedia.org/wiki/Monty_Hall_problem), it can be described as the following:\n",
    "\n",
    "\n",
    "> Suppose you’re on a game show, and you’re given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what’s behind the doors, opens another door, say No. 3, which has a goat. He then says to you, “Do you want to pick door No. 2?” Is it to your advantage to switch your choice?\n",
    "\n",
    "Instead of simply giving you the answer, let's model this so you can find out for yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "## Here we'll define one instance of the problem\n",
    "def runOnce():\n",
    "    # First, there are three doors\n",
    "    doors = [1,2,3]\n",
    "    # We randomly select the successful door\n",
    "    # We also randomly select the door you choose\n",
    "    successDoor = random.randint(1,3)\n",
    "    chosenDoor = random.randint(1,3)\n",
    "\n",
    "    # The failing doors are the ones that are in the list after removing\n",
    "    # the success state door\n",
    "    doors.remove(successDoor)\n",
    "    failDoors = doors\n",
    "\n",
    "    # Calculate the door that the host shows you\n",
    "    # If the chosen door is a failure then the door shown is the other one\n",
    "    # But if the chosen door is correct the door shown is randomly selected\n",
    "    # between the remaining two\n",
    "    if chosenDoor in failDoors:\n",
    "        failDoors.remove(chosenDoor)\n",
    "        doorShown = failDoors[0]\n",
    "    else:\n",
    "        doorShown = failDoors[random.randint(0,1)]\n",
    "\n",
    "    # Record data depending on what was initially chosen\n",
    "    # If you chose correctly, we return that as 1 and switching as 0\n",
    "    # if you chose incorrectly, we return switching as 1 and chosen as 0\n",
    "    if chosenDoor == successDoor:\n",
    "        chosenSuccess = 1\n",
    "        switchSuccess = 0\n",
    "    else:\n",
    "        chosenSuccess = 0\n",
    "        switchSuccess = 1\n",
    "\n",
    "    # Return all data that may be needed for later analysis\n",
    "    return [chosenSuccess, switchSuccess, chosenDoor, successDoor, doorShown]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You initially chose door 3, the host showed you door 1 and suggested you switch.\n",
      "The successful door was door 2.\n",
      "You should have switched!\n"
     ]
    }
   ],
   "source": [
    "thisRun = runOnce()\n",
    "print(\"You initially chose door {}, the host showed you door {} and suggested you switch.\".format(thisRun[2], thisRun[4]))\n",
    "print(\"The successful door was door {}.\".format(thisRun[3]))\n",
    "if thisRun[0]:\n",
    "    print(\"You chose correctly!\")\n",
    "else:\n",
    "    print(\"You should have switched!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So that just models one time you're at the show so the results can't really tell us which strategy is better. Should you switch? Or should you stick to your choice?\n",
    "\n",
    "Well, to find out we can run this model many times and see over 10,000 times which strategy is more successful.\n",
    "\n",
    "The same logic applies when we flip a coin. Flipping a coin once and getting heads doesn't mean you should always choose heads. You should flip the coin many many times in order to find out if it's fair.\n",
    "\n",
    "Let's start by modeling the coin to explain how that works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def coinFlip():\n",
    "    # Let's assume that 0 is tails and 1 is heads\n",
    "    return random.randint(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Heads!\n"
     ]
    }
   ],
   "source": [
    "c = coinFlip()\n",
    "if c:\n",
    "    print(\"Heads!\")\n",
    "else:\n",
    "    print(\"Tails!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nFlips(n):\n",
    "    return [coinFlip() for i in range(n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There were 10000 flips with 5004 heads and 4996 tails.\n",
      "We get heads 50.03999999999999% of the time.\n",
      "That's close to a 50:50 chance.\n"
     ]
    }
   ],
   "source": [
    "n = 10000\n",
    "flips = nFlips(n)\n",
    "\n",
    "print(\"There were {} flips with {} heads and {} tails.\".format(n,sum(flips), len(flips)-sum(flips)))\n",
    "print(\"We get heads {}% of the time.\".format(sum(flips)/n*100))\n",
    "\n",
    "print(\"That's close to a 50:50 chance.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nRuns(n):\n",
    "    return [runOnce() for i in range(n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There were 10000 runs where you chose successfully 3307 times, and you should have switched 6693 times.\n",
      "That means that you were right 33.07% of the time and you should have switched 66.93% of the time.\n"
     ]
    }
   ],
   "source": [
    "n = 10000\n",
    "allRuns = nRuns(n)\n",
    "\n",
    "chosenSuccessful = [r[0] for r in allRuns]\n",
    "switchSuccessful = [r[1] for r in allRuns]\n",
    "chosenDoors = [r[2] for r in allRuns]\n",
    "successDoors = [r[3] for r in allRuns]\n",
    "shownDoors = [r[4] for r in allRuns]\n",
    "\n",
    "print(\"There were {} runs where you chose successfully {} times, and you should have switched {} times.\".format(len(allRuns), sum(chosenSuccessful), sum(switchSuccessful)))\n",
    "print(\"That means that you were right {}% of the time and you should have switched {}% of the time.\".format(sum(chosenSuccessful)*100/len(allRuns),sum(switchSuccessful)*100/len(allRuns)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that switching is the better strategy. Next time you're on a show and they give you the chance to switch doors, you should switch!"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [conda env:py35]",
   "language": "python",
   "name": "conda-env-py35-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}