03-conditional-executions-and-while-loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming Design\n",
    "\n",
    "> Conditional executions and while loops\n",
    "\n",
    "Yao-Jen Kuo <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is control flow?\n",
    "\n",
    "> In computer science, control flow (or flow of control) is the order in which individual statements, instructions or function calls of an imperative program are executed or evaluated. The emphasis on explicit control flow distinguishes an imperative programming language from a declarative programming language.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Control_flow>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Control flow in short\n",
    "\n",
    "- Conditional executions\n",
    "- Iterations\n",
    "    - `while` loop\n",
    "    - `for` loop\n",
    "- Handling exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We will talk about conditional executions and while loop in this chapter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional Executions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a conditional execution?\n",
    "\n",
    "> In computer science, conditional statements are features of a programming language, which perform different computations or actions depending on whether a programmer-specified boolean condition evaluates to true or false.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Conditional_(computer_programming)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use condition and indentation to create a conditional execution\n",
    "\n",
    "- A condition is an expression that can be evaluated as `bool`.\n",
    "- Indentation is necessary since Python does not use curly braces for code blocks.\n",
    "- Conditional execution turns `bool` into other data types.\n",
    "\n",
    "```python\n",
    "if CONDITION:\n",
    "    # statements to be executed if CONDITION is evaluated as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Most programming languages use braces `{ }` to define a code block\n",
    "\n",
    "- Python, however, uses **indentation**.\n",
    "- A code block starts with indentation and ends with the first unindented line.\n",
    "- The amount of indentation is flexible, but it must be consistent throughout that block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use relational or logical operators to produce a `bool` for condition\n",
    "\n",
    "- `==`, `!=`, `>`, `<`, `>=`, `<=`, `in`, `not in`\n",
    "- `and`, `or`, `not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `if` for conditional executions\n",
    "\n",
    "```python\n",
    "if CONDITION:\n",
    "    # statements to be executed if CONDITION is evaluated as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use a code-visualization tool to help you understand the behavior of conditional executions\n",
    "\n",
    "We can use [pythontutor.com](https://www.pythontutor.com) to explore the execution of our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def return_msg_if_positive(x: int) -> str:\n",
    "    if x > 0:\n",
    "        return f\"{x} is positive.\"\n",
    "\n",
    "print(return_msg_if_positive(5566))\n",
    "print(return_msg_if_positive(-5566))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `if` and `else` to perform alternative executions\n",
    "\n",
    "Since the condition must be true or false, exactly one of the alternatives will run.\n",
    "\n",
    "```python\n",
    "if CONDITION:\n",
    "    # statements to be executed if CONDITION is evaluated as True.\n",
    "else:\n",
    "    # statements to be executed if CONDITION is evaluated as False.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is not positive.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_or_not(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = f\"{x} is positive.\"\n",
    "    else:\n",
    "        msg = f\"{x} is not positive.\"\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_or_not(5566))\n",
    "print(return_msg_whether_positive_or_not(-5566))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `if`, `elif`, and `else` to perform chained conditionals\n",
    "\n",
    "The `else` clause makes our conditionals collectively exhaustive.\n",
    "\n",
    "```python\n",
    "if CONDITION_A:\n",
    "    # statements to be executed if CONDITION_A is evaluated as True.\n",
    "elif CONDITION_B:\n",
    "    # statements to be executed if CONDITION_A is evaluated as False and CONDITION_B is evaluated as True.\n",
    "elif CONDITION_C:\n",
    "    # statements to be executed if CONDITION_A and CONDITION_B are both evaluated as False and CONDITION_C is evaluated as True.\n",
    "else:\n",
    "    # statements to be executed if CONDITION_A, CONDITION_B, and CONDITION_C are all evaluated as False.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_negative_or_neutral(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = f\"{x} is positive.\"\n",
    "    elif x < 0:\n",
    "        msg = f\"{x} is negative.\"\n",
    "    else:\n",
    "        msg = f\"{x} is neutral.\"\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_negative_or_neutral(5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(-5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We can break down alternative/chained conditionals once our conditions are mutually exclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_negative_or_neutral(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = f\"{x} is positive.\"\n",
    "    if x < 0:\n",
    "        msg = f\"{x} is negative.\"\n",
    "    if x == 0:\n",
    "        msg = f\"{x} is neutral.\"\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_negative_or_neutral(5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(-5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We can also nest conditionals within other conditionals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_negative_or_neutral(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = f\"{x} is positive.\"\n",
    "    else:\n",
    "        if x < 0:\n",
    "            msg = f\"{x} is negative.\"\n",
    "        else:\n",
    "            msg = f\"{x} is neutral.\"\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_negative_or_neutral(5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(-5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If conditions are NOT mutually exclusive in a chained condition\n",
    "\n",
    "- Still, exactly one of the alternatives will run.\n",
    "- But order matters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Take the famous `FizzBuzz` for example\n",
    "\n",
    "Fizz buzz (often spelled FizzBuzz in this context) has been used as an interview screening device for computer programmers. Writing a program to output the first 100 FizzBuzz numbers is a trivial problem for any would-be computer programmer, so interviewers can easily filter out those with insufficient programming ability.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Fizz_buzz>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fizz Buzz\n"
     ]
    }
   ],
   "source": [
    "# chained conditionals\n",
    "def fizz_buzz(x: int) -> str:\n",
    "    if x % 15 == 0:\n",
    "        ans = \"Fizz Buzz\"\n",
    "    elif x % 3 == 0:\n",
    "        ans = \"Fizz\"\n",
    "    elif x % 5 == 0:\n",
    "        ans = \"Buzz\"\n",
    "    else:\n",
    "        ans = x\n",
    "    return ans\n",
    "\n",
    "print(fizz_buzz(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fizz Buzz\n"
     ]
    }
   ],
   "source": [
    "# non-chained conditionals\n",
    "def fizz_buzz(x: int) -> str:\n",
    "    if x % 3 == 0:\n",
    "        ans = \"Fizz\"\n",
    "    if x % 5 == 0:\n",
    "        ans = \"Buzz\"\n",
    "    if x % 15 == 0:\n",
    "        ans = \"Fizz Buzz\"\n",
    "    if (x % 15 != 0) and (x % 3 != 0) and (x % 5 != 0):\n",
    "        ans = x\n",
    "    return ans\n",
    "\n",
    "print(fizz_buzz(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## While loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We can utilize two type of iterations\n",
    "\n",
    "- `while` loop\n",
    "- `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The essentials of iteration\n",
    "\n",
    "- start: when does the iteration start?\n",
    "- stop: when does the iteration stop?\n",
    "- step: how does the iteration go from start to stop?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The `while` loop is used to repeat one or more code statements as long as the condition is evaluated as `True`\n",
    "\n",
    "```python\n",
    "i = 0 # start\n",
    "while CONDITION: # stop\n",
    "    # repeated statements\n",
    "    i += 1 # step\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Assignment operators are commonly used in writing loops\n",
    "\n",
    "- `i += 1` as in `i = i + 1` \n",
    "- `i -= 1` as in `i = i - 1` \n",
    "- `i *= 1` as in `i = i * 1` \n",
    "- `i /= 1` as in `i = i / 1` \n",
    "- ...etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Imgur](https://i.imgur.com/KNhPttU.png?1)\n",
    "\n",
    "Source: [A Beginners Guide to Python 3 Programming](https://www.amazon.com/Beginners-Programming-Undergraduate-Computer-Science-ebook/dp/B07W4THQB6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use a code-visualization tool to help you understand the behavior of loops\n",
    "\n",
    "We can use [pythontutor.com](https://www.pythontutor.com) to explore the execution of our code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Printing out the first 5 integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "i = 0 # start\n",
    "while i < 5: # stop\n",
    "    print(i)\n",
    "    i += 1 # step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Printing out the first 5 odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 1 # start\n",
    "while i < 11: # stop\n",
    "    print(i)\n",
    "    i += 2 # step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common task: summations/counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "summation = 0\n",
    "counts = 0\n",
    "i = 1\n",
    "while i <= 100:\n",
    "    summation += i  # summation = summation + 1\n",
    "    counts += 1     # counts = counts + 1\n",
    "    i += 1\n",
    "\n",
    "print(summation)\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common task: summations/counts with conditional executions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1050\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "summation = 0\n",
    "counts = 0\n",
    "i = 1\n",
    "while i <= 100:\n",
    "    if i % 5 == 0:\n",
    "        summation += i  # summation = summation + 1\n",
    "        counts += 1     # counts = counts + 1\n",
    "    i += 1\n",
    "\n",
    "print(summation)\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Early stop or skipping certain steps in an iteration task\n",
    "\n",
    "- Use keyword `break` to early break an iteration\n",
    "- Use keyword `continue` to skip certain steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "525\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "summation = 0\n",
    "counts = 0\n",
    "i = 1\n",
    "while i <= 100:\n",
    "    if i % 5 == 0:\n",
    "        summation += i  # summation = summation + 1\n",
    "        counts += 1     # counts = counts + 1\n",
    "    i += 1\n",
    "    if summation >= 500:\n",
    "        break\n",
    "\n",
    "print(summation)\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1050\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "summation = 0\n",
    "counts = 0\n",
    "i = 1\n",
    "while i <= 100:\n",
    "    if i % 5 != 0:\n",
    "        i += 1\n",
    "        continue\n",
    "    summation += i  # summation = summation + 1\n",
    "    counts += 1     # counts = counts + 1\n",
    "    i += 1\n",
    "\n",
    "print(summation)\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use control flow to play a round of Rock paper scissors in your terminal\n",
    "\n",
    "```python\n",
    "from random import choice\n",
    "\n",
    "print(\"Let's play Rock paper scissors!\")\n",
    "print(\"What shape are you going to form? Press 1, 2, or 3 and hit Enter:\")\n",
    "your_shape_input = int(input(\"1. Rock.\\n2. Paper.\\n3. Scissors.\\n\"))\n",
    "shapes = [\"Rock\", \"Paper\", \"Scissors\"]\n",
    "your_shape = shapes[your_shape_input - 1]\n",
    "computers_shape = choice(shapes)\n",
    "message_for_winner = f\"You formed {your_shape} against computer's {computers_shape}, You win!\"\n",
    "message_for_loser = f\"You formed {your_shape} against computer's {computers_shape}, You lose!\"\n",
    "message_for_even = f\"You formed {your_shape} against computer's {computers_shape}, Let's call it even!\"\n",
    "if your_shape == computers_shape:\n",
    "    print(message_for_even)\n",
    "elif (your_shape, computers_shape) == (\"Paper\", \"Rock\") or (your_shape, computers_shape) == (\"Rock\", \"Scissors\") or (your_shape, computers_shape) == (\"Scissors\", \"Paper\"):\n",
    "    print(message_for_winner)\n",
    "else:\n",
    "    print(message_for_loser)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use control flow to play several rounds of Rock paper scissors in your terminal\n",
    "\n",
    "```python\n",
    "from random import choice\n",
    "\n",
    "number_of_wins, number_of_losses, number_of_evens = 0, 0, 0\n",
    "while True:\n",
    "    print(\"Let's play Rock paper scissors!\")\n",
    "    print(\"What shape are you going to form? Press 1, 2, or 3 and hit Enter:\")\n",
    "    your_shape_input = int(input(\"1. Rock.\\n2. Paper.\\n3. Scissors.\\n\"))\n",
    "    shapes = [\"Rock\", \"Paper\", \"Scissors\"]\n",
    "    your_shape = shapes[your_shape_input - 1]\n",
    "    computers_shape = choice(shapes)\n",
    "    message_for_winner = f\"You formed {your_shape} against computer's {computers_shape}, You win!\"\n",
    "    message_for_loser = f\"You formed {your_shape} against computer's {computers_shape}, You lose!\"\n",
    "    message_for_even = f\"You formed {your_shape} against computer's {computers_shape}, Let's call it even!\"\n",
    "    if your_shape == computers_shape:\n",
    "        print(message_for_even)\n",
    "        number_of_evens += 1\n",
    "    elif (your_shape, computers_shape) == (\"Paper\", \"Rock\") or (your_shape, computers_shape) == (\"Rock\", \"Scissors\") or (your_shape, computers_shape) == (\"Scissors\", \"Paper\"):\n",
    "        print(message_for_winner)\n",
    "        number_of_wins += 1\n",
    "    else:\n",
    "        print(message_for_loser)\n",
    "        number_of_losses += 1\n",
    "    print(\"Do you want to play another round?\")\n",
    "    play_again_or_not = input(\"Press y and hit Enter to continue playing, press n and hit Enter to quit:\")\n",
    "    if play_again_or_not == \"n\":\n",
    "        break\n",
    "print(f\"Here is your records: {number_of_wins} wins, {number_of_losses} losses and {number_of_evens} evens!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `while` versus `for` when dealing with iterations?\n",
    "\n",
    "- Use `for` to iterate over lists, dictionaries, and other iterables\n",
    "- Use `while` if our operations involve randomness or uncertainty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random integer: 78; Final guess: 78\n",
      "Random integer: 15; Final guess: 15\n",
      "Random integer: 41; Final guess: 41\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "def binary_search(low: int=1, high: int=100) -> list:\n",
    "    guess = (low + high) // 2\n",
    "    rand_int = randint(low, high)\n",
    "    while guess != rand_int:\n",
    "        if guess > rand_int:\n",
    "            high = guess\n",
    "            guess = (low + high) // 2\n",
    "        elif guess < rand_int:\n",
    "            low = guess\n",
    "            guess = (low + high) // 2 + 1\n",
    "    return f\"Random integer: {rand_int}; Final guess: {guess}\"\n",
    "\n",
    "print(binary_search())\n",
    "print(binary_search())\n",
    "print(binary_search())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "def int_to_bin_str(x: int) -> str:\n",
    "    if x < 2:\n",
    "        return str(x)\n",
    "    binary_str = \"\"\n",
    "    while x > 0:\n",
    "        modulo = x % 2\n",
    "        binary_str = str(modulo) + binary_str\n",
    "        x //= 2\n",
    "    return binary_str\n",
    "\n",
    "print(int_to_bin_str(2)) # bin(2)\n",
    "print(int_to_bin_str(3)) # bin(3)\n",
    "print(int_to_bin_str(4)) # bin(4)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}