exercise-loops-and-list-comprehensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c842261a",
   "metadata": {
    "papermill": {
     "duration": 0.006046,
     "end_time": "2023-05-03T10:05:26.060055",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.054009",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**This notebook is an exercise in the [Python](https://www.kaggle.com/learn/python) course.  You can reference the tutorial at [this link](https://www.kaggle.com/colinmorris/loops-and-list-comprehensions).**\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00568a1b",
   "metadata": {
    "papermill": {
     "duration": 0.005003,
     "end_time": "2023-05-03T10:05:26.070702",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.065699",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "With all you've learned, you can start writing much more interesting programs. See if you can solve the problems below.\n",
    "\n",
    "As always, run the setup code below before working on the questions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "03b2ff97",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.083824Z",
     "iopub.status.busy": "2023-05-03T10:05:26.083086Z",
     "iopub.status.idle": "2023-05-03T10:05:26.137354Z",
     "shell.execute_reply": "2023-05-03T10:05:26.136247Z"
    },
    "papermill": {
     "duration": 0.063948,
     "end_time": "2023-05-03T10:05:26.140068",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.076120",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setup complete.\n"
     ]
    }
   ],
   "source": [
    "from learntools.core import binder; binder.bind(globals())\n",
    "from learntools.python.ex5 import *\n",
    "print('Setup complete.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "657cc997",
   "metadata": {
    "papermill": {
     "duration": 0.005974,
     "end_time": "2023-05-03T10:05:26.152068",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.146094",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# 1.\n",
    "\n",
    "Have you ever felt debugging involved a bit of luck? The following program has a bug. Try to identify the bug and fix it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ad71ad35",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.166036Z",
     "iopub.status.busy": "2023-05-03T10:05:26.165568Z",
     "iopub.status.idle": "2023-05-03T10:05:26.172876Z",
     "shell.execute_reply": "2023-05-03T10:05:26.171164Z"
    },
    "papermill": {
     "duration": 0.01798,
     "end_time": "2023-05-03T10:05:26.175598",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.157618",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def has_lucky_number(nums):\n",
    "    \"\"\"Return whether the given list of numbers is lucky. A lucky list contains\n",
    "    at least one number divisible by 7.\n",
    "    \"\"\"\n",
    "    num = 10\n",
    "    for num in nums:\n",
    "        if num % 7 == 0:\n",
    "            return True\n",
    "    \n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "370bb7ff",
   "metadata": {
    "papermill": {
     "duration": 0.005393,
     "end_time": "2023-05-03T10:05:26.187090",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.181697",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Try to identify the bug and fix it in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "de1e5c4c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.200178Z",
     "iopub.status.busy": "2023-05-03T10:05:26.199747Z",
     "iopub.status.idle": "2023-05-03T10:05:26.211222Z",
     "shell.execute_reply": "2023-05-03T10:05:26.210053Z"
    },
    "papermill": {
     "duration": 0.020977,
     "end_time": "2023-05-03T10:05:26.213612",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.192635",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "14\n",
      "3\n",
      "14\n",
      "3\n",
      "21\n",
      "7\n",
      "3\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.25, \"interactionType\": 1, \"questionType\": 2, \"questionId\": \"1_EarlyExitDebugging\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct:</span> \n",
       "\n",
       "Remember that `return` causes a function to exit immediately. So our original implementation always ran for just one iteration. We can only return `False` if we've looked at every element of the list (and confirmed that none of them are lucky). Though we can return early if the answer is `True`:\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    for num in nums:\n",
       "        if num % 7 == 0:\n",
       "            return True\n",
       "    # We've exhausted the list without finding a lucky number\n",
       "    return False\n",
       "```\n",
       "\n",
       "Here's a one-line version using a list comprehension with Python's `any` function (you can read about what it does by calling `help(any)`):\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    return any([num % 7 == 0 for num in nums])\n",
       "```\n"
      ],
      "text/plain": [
       "Correct: \n",
       "\n",
       "Remember that `return` causes a function to exit immediately. So our original implementation always ran for just one iteration. We can only return `False` if we've looked at every element of the list (and confirmed that none of them are lucky). Though we can return early if the answer is `True`:\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    for num in nums:\n",
       "        if num % 7 == 0:\n",
       "            return True\n",
       "    # We've exhausted the list without finding a lucky number\n",
       "    return False\n",
       "```\n",
       "\n",
       "Here's a one-line version using a list comprehension with Python's `any` function (you can read about what it does by calling `help(any)`):\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    return any([num % 7 == 0 for num in nums])\n",
       "```"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def has_lucky_number(nums):\n",
    "    \"\"\"Return whether the given list of numbers is lucky. A lucky list contains\n",
    "    at least one number divisible by 7.\n",
    "    \"\"\"\n",
    "    num = 100\n",
    "    for num in nums:\n",
    "        print(num)\n",
    "        if num % 7 == 0:\n",
    "            return True\n",
    "      \n",
    "    return False\n",
    "\n",
    "# Check your answer\n",
    "q1.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "99a3b3b7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.227126Z",
     "iopub.status.busy": "2023-05-03T10:05:26.226761Z",
     "iopub.status.idle": "2023-05-03T10:05:26.239560Z",
     "shell.execute_reply": "2023-05-03T10:05:26.238538Z"
    },
    "papermill": {
     "duration": 0.022013,
     "end_time": "2023-05-03T10:05:26.241563",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.219550",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 2, \"questionType\": 2, \"questionId\": \"1_EarlyExitDebugging\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#3366cc\">Hint:</span> How many times does the body of the loop run for a list of length n? (If you're not sure, try adding a `print()` call on the line before the `if`.)"
      ],
      "text/plain": [
       "Hint: How many times does the body of the loop run for a list of length n? (If you're not sure, try adding a `print()` call on the line before the `if`.)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 3, \"questionType\": 2, \"questionId\": \"1_EarlyExitDebugging\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc99\">Solution:</span> Remember that `return` causes a function to exit immediately. So our original implementation always ran for just one iteration. We can only return `False` if we've looked at every element of the list (and confirmed that none of them are lucky). Though we can return early if the answer is `True`:\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    for num in nums:\n",
       "        if num % 7 == 0:\n",
       "            return True\n",
       "    # We've exhausted the list without finding a lucky number\n",
       "    return False\n",
       "```\n",
       "\n",
       "Here's a one-line version using a list comprehension with Python's `any` function (you can read about what it does by calling `help(any)`):\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    return any([num % 7 == 0 for num in nums])\n",
       "```\n"
      ],
      "text/plain": [
       "Solution: Remember that `return` causes a function to exit immediately. So our original implementation always ran for just one iteration. We can only return `False` if we've looked at every element of the list (and confirmed that none of them are lucky). Though we can return early if the answer is `True`:\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    for num in nums:\n",
       "        if num % 7 == 0:\n",
       "            return True\n",
       "    # We've exhausted the list without finding a lucky number\n",
       "    return False\n",
       "```\n",
       "\n",
       "Here's a one-line version using a list comprehension with Python's `any` function (you can read about what it does by calling `help(any)`):\n",
       "\n",
       "```python\n",
       "def has_lucky_number(nums):\n",
       "    return any([num % 7 == 0 for num in nums])\n",
       "```"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "q1.hint()\n",
    "q1.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a990668a",
   "metadata": {
    "papermill": {
     "duration": 0.006084,
     "end_time": "2023-05-03T10:05:26.254066",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.247982",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# 2.\n",
    "Look at the Python expression below. What do you think we'll get when we run it? When you've made your prediction, uncomment the code and run the cell to see if you were right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "87370eb5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.269159Z",
     "iopub.status.busy": "2023-05-03T10:05:26.268548Z",
     "iopub.status.idle": "2023-05-03T10:05:26.276345Z",
     "shell.execute_reply": "2023-05-03T10:05:26.275180Z"
    },
    "papermill": {
     "duration": 0.018391,
     "end_time": "2023-05-03T10:05:26.278760",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.260369",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in [1, 2, 3, 4] "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcc5b36a",
   "metadata": {
    "papermill": {
     "duration": 0.007135,
     "end_time": "2023-05-03T10:05:26.292930",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.285795",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "R and Python have some libraries (like numpy and pandas) compare each element of the list to 2 (i.e. do an 'element-wise' comparison) and give us a list of booleans like `[False, False, True, True]`. \n",
    "\n",
    "Implement a function that reproduces this behaviour, returning a list of booleans corresponding to whether the corresponding element is greater than n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "68813c0a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.309464Z",
     "iopub.status.busy": "2023-05-03T10:05:26.308938Z",
     "iopub.status.idle": "2023-05-03T10:05:26.317897Z",
     "shell.execute_reply": "2023-05-03T10:05:26.316841Z"
    },
    "papermill": {
     "duration": 0.020237,
     "end_time": "2023-05-03T10:05:26.320238",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.300001",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.25, \"interactionType\": 1, \"questionType\": 2, \"questionId\": \"2_ElementWiseComparison\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct:</span> \n",
       "\n",
       "Here's one solution:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    res = []\n",
       "    for ele in L:\n",
       "        res.append(ele > thresh)\n",
       "    return res\n",
       "```\n",
       "\n",
       "And here's the list comprehension version:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    return [ele > thresh for ele in L]\n",
       "```\n"
      ],
      "text/plain": [
       "Correct: \n",
       "\n",
       "Here's one solution:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    res = []\n",
       "    for ele in L:\n",
       "        res.append(ele > thresh)\n",
       "    return res\n",
       "```\n",
       "\n",
       "And here's the list comprehension version:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    return [ele > thresh for ele in L]\n",
       "```"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def elementwise_greater_than(L, thresh):\n",
    "    \"\"\"Return a list with the same length as L, where the value at index i is \n",
    "    True if L[i] is greater than thresh, and False otherwise.\n",
    "    \n",
    "    >>> elementwise_greater_than([1, 2, 3, 4], 2)\n",
    "    [False, False, True, True]\n",
    "    \"\"\"\n",
    "    return [x > thresh for x in L]\n",
    "    \n",
    "\n",
    "# Check your answer\n",
    "q2.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5dc5fd4c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.336047Z",
     "iopub.status.busy": "2023-05-03T10:05:26.335640Z",
     "iopub.status.idle": "2023-05-03T10:05:26.345632Z",
     "shell.execute_reply": "2023-05-03T10:05:26.344380Z"
    },
    "papermill": {
     "duration": 0.020574,
     "end_time": "2023-05-03T10:05:26.347980",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.327406",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 3, \"questionType\": 2, \"questionId\": \"2_ElementWiseComparison\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc99\">Solution:</span> Here's one solution:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    res = []\n",
       "    for ele in L:\n",
       "        res.append(ele > thresh)\n",
       "    return res\n",
       "```\n",
       "\n",
       "And here's the list comprehension version:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    return [ele > thresh for ele in L]\n",
       "```\n"
      ],
      "text/plain": [
       "Solution: Here's one solution:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    res = []\n",
       "    for ele in L:\n",
       "        res.append(ele > thresh)\n",
       "    return res\n",
       "```\n",
       "\n",
       "And here's the list comprehension version:\n",
       "```python\n",
       "def elementwise_greater_than(L, thresh):\n",
       "    return [ele > thresh for ele in L]\n",
       "```"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "q2.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253ab17b",
   "metadata": {
    "papermill": {
     "duration": 0.00725,
     "end_time": "2023-05-03T10:05:26.362348",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.355098",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# 3.\n",
    "\n",
    "Complete the body of the function below according to its docstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a3a4cc0b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.379518Z",
     "iopub.status.busy": "2023-05-03T10:05:26.379114Z",
     "iopub.status.idle": "2023-05-03T10:05:26.389282Z",
     "shell.execute_reply": "2023-05-03T10:05:26.388024Z"
    },
    "papermill": {
     "duration": 0.021419,
     "end_time": "2023-05-03T10:05:26.391633",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.370214",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.25, \"interactionType\": 1, \"questionType\": 2, \"questionId\": \"3_BoringMenu\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct:</span> \n",
       "\n",
       "\n",
       "\n",
       "```python\n",
       "def menu_is_boring(meals):\n",
       "    # Iterate over all indices of the list, except the last one\n",
       "    for i in range(len(meals)-1):\n",
       "        if meals[i] == meals[i+1]:\n",
       "            return True\n",
       "    return False\n",
       "```\n",
       "\n",
       "The key to our solution is the call to `range`. `range(len(meals))` would give us all the indices of `meals`. If we had used that range, the last iteration of the loop would be comparing the last element to the element after it, which is... `IndexError`! `range(len(meals)-1)` gives us all the indices except the index of the last element.\n",
       "\n",
       "But don't we need to check if `meals` is empty? Turns out that `range(0) == range(-1)` - they're both empty. So if `meals` has length 0 or 1, we just won't do any iterations of our for loop.\n"
      ],
      "text/plain": [
       "Correct: \n",
       "\n",
       "\n",
       "\n",
       "```python\n",
       "def menu_is_boring(meals):\n",
       "    # Iterate over all indices of the list, except the last one\n",
       "    for i in range(len(meals)-1):\n",
       "        if meals[i] == meals[i+1]:\n",
       "            return True\n",
       "    return False\n",
       "```\n",
       "\n",
       "The key to our solution is the call to `range`. `range(len(meals))` would give us all the indices of `meals`. If we had used that range, the last iteration of the loop would be comparing the last element to the element after it, which is... `IndexError`! `range(len(meals)-1)` gives us all the indices except the index of the last element.\n",
       "\n",
       "But don't we need to check if `meals` is empty? Turns out that `range(0) == range(-1)` - they're both empty. So if `meals` has length 0 or 1, we just won't do any iterations of our for loop."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def menu_is_boring(meals):\n",
    "    \"\"\"Given a list of meals served over some period of time, return True if the\n",
    "    same meal has ever been served two days in a row, and False otherwise.\n",
    "    \"\"\"\n",
    "    for i in range(1 , len(meals)):\n",
    "        if meals[i] == meals[i - 1]:\n",
    "            return True\n",
    "    return False\n",
    "   \n",
    "\n",
    "# Check your answer\n",
    "q3.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "60cd00bc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.410038Z",
     "iopub.status.busy": "2023-05-03T10:05:26.409319Z",
     "iopub.status.idle": "2023-05-03T10:05:26.421946Z",
     "shell.execute_reply": "2023-05-03T10:05:26.420839Z"
    },
    "papermill": {
     "duration": 0.024679,
     "end_time": "2023-05-03T10:05:26.424113",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.399434",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 2, \"questionType\": 2, \"questionId\": \"3_BoringMenu\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#3366cc\">Hint:</span> This is a case where it may be preferable to iterate over the *indices* of the list (using a call to `range()`) rather than iterating over the elements of the list itself. When indexing into the list, be mindful that you're not \"falling off the end\" (i.e. using an index that doesn't exist)."
      ],
      "text/plain": [
       "Hint: This is a case where it may be preferable to iterate over the *indices* of the list (using a call to `range()`) rather than iterating over the elements of the list itself. When indexing into the list, be mindful that you're not \"falling off the end\" (i.e. using an index that doesn't exist)."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 3, \"questionType\": 2, \"questionId\": \"3_BoringMenu\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc99\">Solution:</span> \n",
       "\n",
       "```python\n",
       "def menu_is_boring(meals):\n",
       "    # Iterate over all indices of the list, except the last one\n",
       "    for i in range(len(meals)-1):\n",
       "        if meals[i] == meals[i+1]:\n",
       "            return True\n",
       "    return False\n",
       "```\n",
       "\n",
       "The key to our solution is the call to `range`. `range(len(meals))` would give us all the indices of `meals`. If we had used that range, the last iteration of the loop would be comparing the last element to the element after it, which is... `IndexError`! `range(len(meals)-1)` gives us all the indices except the index of the last element.\n",
       "\n",
       "But don't we need to check if `meals` is empty? Turns out that `range(0) == range(-1)` - they're both empty. So if `meals` has length 0 or 1, we just won't do any iterations of our for loop.\n"
      ],
      "text/plain": [
       "Solution: \n",
       "\n",
       "```python\n",
       "def menu_is_boring(meals):\n",
       "    # Iterate over all indices of the list, except the last one\n",
       "    for i in range(len(meals)-1):\n",
       "        if meals[i] == meals[i+1]:\n",
       "            return True\n",
       "    return False\n",
       "```\n",
       "\n",
       "The key to our solution is the call to `range`. `range(len(meals))` would give us all the indices of `meals`. If we had used that range, the last iteration of the loop would be comparing the last element to the element after it, which is... `IndexError`! `range(len(meals)-1)` gives us all the indices except the index of the last element.\n",
       "\n",
       "But don't we need to check if `meals` is empty? Turns out that `range(0) == range(-1)` - they're both empty. So if `meals` has length 0 or 1, we just won't do any iterations of our for loop."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "q3.hint()\n",
    "q3.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decf9c1f",
   "metadata": {
    "papermill": {
     "duration": 0.007778,
     "end_time": "2023-05-03T10:05:26.439727",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.431949",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# 4. <span title=\"A bit spicy\" style=\"color: darkgreen \">🌶️</span>\n",
    "\n",
    "Next to the Blackjack table, the Python Challenge Casino has a slot machine. You can get a result from the slot machine by calling `play_slot_machine()`. The number it returns is your winnings in dollars. Usually it returns 0.  But sometimes you'll get lucky and get a big payday. Try running it below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "11472452",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.457706Z",
     "iopub.status.busy": "2023-05-03T10:05:26.457318Z",
     "iopub.status.idle": "2023-05-03T10:05:26.465405Z",
     "shell.execute_reply": "2023-05-03T10:05:26.463037Z"
    },
    "papermill": {
     "duration": 0.020752,
     "end_time": "2023-05-03T10:05:26.468308",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.447556",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play_slot_machine()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f8a0e9",
   "metadata": {
    "papermill": {
     "duration": 0.00775,
     "end_time": "2023-05-03T10:05:26.484312",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.476562",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "By the way, did we mention that each play costs $1? Don't worry, we'll send you the bill later.\n",
    "\n",
    "On average, how much money can you expect to gain (or lose) every time you play the machine?  The casino keeps it a secret, but you can estimate the average value of each pull using a technique called the **Monte Carlo method**. To estimate the average outcome, we simulate the scenario many times, and return the average result.\n",
    "\n",
    "Complete the following function to calculate the average value per play of the slot machine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ef8c51a0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.503359Z",
     "iopub.status.busy": "2023-05-03T10:05:26.502860Z",
     "iopub.status.idle": "2023-05-03T10:05:26.509868Z",
     "shell.execute_reply": "2023-05-03T10:05:26.508543Z"
    },
    "papermill": {
     "duration": 0.019381,
     "end_time": "2023-05-03T10:05:26.512095",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.492714",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def estimate_average_slot_payout(n_runs):\n",
    "    \"\"\"Run the slot machine n_runs times and return the average net profit per run.\n",
    "    Example calls (note that return value is nondeterministic!):\n",
    "    >>> estimate_average_slot_payout(1)\n",
    "    -1\n",
    "    >>> estimate_average_slot_payout(1)\n",
    "    0.5\n",
    "    \"\"\"\n",
    "    total_pay = 0\n",
    "    for i in range(n_runs):\n",
    "        win = play_slot_machine()\n",
    "        if win == 0:\n",
    "            pay = -1\n",
    "        else:\n",
    "            pay = win - 1\n",
    "        total_pay += pay\n",
    "    return total_pay / n_runs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca7f42ff",
   "metadata": {
    "papermill": {
     "duration": 0.007782,
     "end_time": "2023-05-03T10:05:26.528065",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.520283",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "When you think you know the expected value per spin, run the code cell below to view the solution and get credit for answering the question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e840273",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-03T10:05:26.546729Z",
     "iopub.status.busy": "2023-05-03T10:05:26.545964Z",
     "iopub.status.idle": "2023-05-03T10:05:26.554802Z",
     "shell.execute_reply": "2023-05-03T10:05:26.553929Z"
    },
    "papermill": {
     "duration": 0.022198,
     "end_time": "2023-05-03T10:05:26.558215",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.536017",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.34\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 3, \"questionType\": 4, \"questionId\": \"4_ExpectedSlotsPayout\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc99\">Solution:</span> \n",
       "    \n",
       "The exact expected value of one pull of the slot machine is 0.025 - i.e. a little more than 2 cents.  See?  Not every game in the Python Challenge Casino is rigged against the player!\n",
       "\n",
       "In order to get this answer, you'll need to implement the `estimate_average_slot_payout(n_runs)` function to simulate pulling the slot machine `n_runs` times.  It should return the payout averaged over those `n_runs`.\n",
       "\n",
       "Then, once the function is defined, in order to estimate the average slot payout, we need only call the function.\n",
       "\n",
       "Because of the high variance of the outcome (there are some very rare high payout results that significantly affect the average) you might need to run your function with a very high value of `n_runs` to get a stable answer close to the true expectation.  For instance, you might use a value for `n_runs` of 1000000.\n",
       "\n",
       "Here's an example for how the function could look:\n",
       "```python\n",
       "def estimate_average_slot_payout(n_runs):\n",
       "    # Play slot machine n_runs times, calculate payout of each\n",
       "    payouts = [play_slot_machine()-1 for i in range(n_runs)]\n",
       "    # Calculate the average value\n",
       "    avg_payout = sum(payouts) / n_runs\n",
       "    return avg_payout\n",
       "    \n",
       "estimate_average_slot_payout(10000000)\n",
       "\n",
       "```\n",
       "\n",
       "This should return an answer close to 0.025!\n",
       "            \n"
      ],
      "text/plain": [
       "Solution: \n",
       "    \n",
       "The exact expected value of one pull of the slot machine is 0.025 - i.e. a little more than 2 cents.  See?  Not every game in the Python Challenge Casino is rigged against the player!\n",
       "\n",
       "In order to get this answer, you'll need to implement the `estimate_average_slot_payout(n_runs)` function to simulate pulling the slot machine `n_runs` times.  It should return the payout averaged over those `n_runs`.\n",
       "\n",
       "Then, once the function is defined, in order to estimate the average slot payout, we need only call the function.\n",
       "\n",
       "Because of the high variance of the outcome (there are some very rare high payout results that significantly affect the average) you might need to run your function with a very high value of `n_runs` to get a stable answer close to the true expectation.  For instance, you might use a value for `n_runs` of 1000000.\n",
       "\n",
       "Here's an example for how the function could look:\n",
       "```python\n",
       "def estimate_average_slot_payout(n_runs):\n",
       "    # Play slot machine n_runs times, calculate payout of each\n",
       "    payouts = [play_slot_machine()-1 for i in range(n_runs)]\n",
       "    # Calculate the average value\n",
       "    avg_payout = sum(payouts) / n_runs\n",
       "    return avg_payout\n",
       "    \n",
       "estimate_average_slot_payout(10000000)\n",
       "\n",
       "```\n",
       "\n",
       "This should return an answer close to 0.025!\n",
       "            "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Check your answer (Run this code cell to receive credit!)\n",
    "print(estimate_average_slot_payout(100))\n",
    "\n",
    "q4.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a17e9e5",
   "metadata": {
    "papermill": {
     "duration": 0.008115,
     "end_time": "2023-05-03T10:05:26.574970",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.566855",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Keep Going\n",
    "\n",
    "Many programmers report that dictionaries are their favorite data structure. You'll get to **[learn about them](https://www.kaggle.com/colinmorris/strings-and-dictionaries)** (as well as strings) in the next lesson."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa1c6826",
   "metadata": {
    "papermill": {
     "duration": 0.008048,
     "end_time": "2023-05-03T10:05:26.591902",
     "exception": false,
     "start_time": "2023-05-03T10:05:26.583854",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*Have questions or comments? Visit the [course discussion forum](https://www.kaggle.com/learn/python/discussion) to chat with other learners.*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.10.10"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 12.589901,
   "end_time": "2023-05-03T10:05:27.522464",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2023-05-03T10:05:14.932563",
   "version": "2.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}