src/Python Bootcamp.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "99869441",
   "metadata": {},
   "source": [
    "# Python Bootcamp (SU - 23)\n",
    "\n",
    "This notebook documents all the exercises that were practiced upon on *RIOT ROBOTICS SU - 22 Python Bootcamp*. It should be noted that the bookcamp served as an introduction for students of the student chapter of the Python 3 programming languange.\n",
    "\n",
    "As such all the questions that were discussed during the aformentioned workshop are as follows:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7ac644fd",
   "metadata": {},
   "source": [
    "## 1 The Very Basics\n",
    "\n",
    "The following questions tackle the very fundamentals of any programming language, that is: handling words, nuumbers and types.\n",
    "\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "eaaf2e69",
   "metadata": {},
   "source": [
    "**Question 1:** Write a Python 3 program that outputs the result of the mathematical equation **5 + 27** using the Jupyter Notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "a75157e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 27"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "09f08cef",
   "metadata": {},
   "source": [
    "**Question 2:** Write an enhanced version of the previous code using Python 3's **print** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "99a93ba0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "print(5 + 27)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0ce7bc95",
   "metadata": {},
   "source": [
    "**Question 3:** Create two variables, namely: **x** and **y**, and assign the values of **5** and **27** to each of them, respectively. Using the *print* function, output the following sentence: **The equation x + y = z**, where x, y and z are the values of variable x, variable y and the result of the addition of the forementioned variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2214c7a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The equation 5 + 27 = 32.\n"
     ]
    }
   ],
   "source": [
    "x, y = 5, 27\n",
    "print(\"The equation {a} + {b} = {c}.\".format(a = x, b = y, c = x+y))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8a09d2b3",
   "metadata": {},
   "source": [
    "**Question 4:** Using the *print** function, output the words **Hello World!** to the *Terminal* screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e5ed5599",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1d6ab056",
   "metadata": {},
   "source": [
    "**Question 5:** Find the type of the words **Hello World!** using the **type** function found within Python 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4c84be6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"Hello World!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a2b2b752",
   "metadata": {},
   "source": [
    "**Question 6:** You are given the mathematical equation of **3 + 4j**, and are tasked with finding the *type* of itslef. (Note: Use the **type** function found within Python 3, and the result should be **'complex'**.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5861aad9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3 + 4j)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5195837c",
   "metadata": {},
   "source": [
    "**Question 7:** You are given the mathematical equation of **1 + 1**, and are tasked with finding the *type* of itslef. (Note: Use the **type** function found within Python 3, and the result should be **'int'**.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7bc51a4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1 + 1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a9476872",
   "metadata": {},
   "source": [
    "**Question 8:** You are given the mathematical equation of **2 + 3.5**, and are tasked with finding the *type* of itslef. (Note: Use the **type** function found within Python 3, and the result should be **'float'**.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e163bd37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2 + 3.5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d694a9c0",
   "metadata": {},
   "source": [
    "**Question 9:** You are given the term **True**, and are tasked with finding the *type* of itslef. (Note: Use the **type** function found within Python 3, and the result should be **'bool'**.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "76cd91bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "399a5226",
   "metadata": {},
   "source": [
    "**Question 10:** Output the result of the following euqation using the *print** function.\n",
    "\n",
    "$$P = {2}^3$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ddc5eca8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The result of P is 8.\n"
     ]
    }
   ],
   "source": [
    "print(\"The result of P is {a}.\".format(a=2**3))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ec853a68",
   "metadata": {},
   "source": [
    "**Question 11:** Solve the equation using the *print* function.\n",
    "$$Q = 3 \\% 3$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3e7565c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The relsult of Q is 0.\n"
     ]
    }
   ],
   "source": [
    "print(\"The relsult of Q is {a}.\".format(a=3%3))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5997843b",
   "metadata": {},
   "source": [
    "## 2 Mid - Way\n",
    "\n",
    "In this next part of the bootcamp the student will learn how to create variables, handle comparators, if - else and for statments to name a few.\n",
    "\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "14678a87",
   "metadata": {},
   "source": [
    "**Question 1:** You are given two *strings*, these being: **First String** and **Second String**. Using the *print* function found withing Python 3, output the strings in the following manner:\n",
    "\n",
    "1. Variable 1: First String\n",
    "2. Variable 2: Second String\n",
    "\n",
    ", then invert the order of the list. (**Note:** Do not change the manner in which the *print* function handles the output, use a new variable, namely: **tmp**.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9cc3b528",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The old order of strings are: \n",
      "1. V1 = First String\n",
      "2. V2 = Second String\n",
      "The new order of strings are: \n",
      "1. V1 = Second String\n",
      "2. V2 = First String\n"
     ]
    }
   ],
   "source": [
    "v1 = \"First String\"\n",
    "v2 = \"Second String\"\n",
    "\n",
    "print(\"The old order of strings are: \\n1. V1 = {a}\\n2. V2 = {b}\".format(a = v1, b = v2))\n",
    "tmp = v1\n",
    "v1 = v2\n",
    "v2 = tmp\n",
    "print(\"The new order of strings are: \\n1. V1 = {a}\\n2. V2 = {b}\".format(a = v1, b = v2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "da4b94d4",
   "metadata": {},
   "source": [
    "**Question 2:** You are given the following variables:\n",
    "\n",
    "* *a = 3*,\n",
    "* *b = 7*,\n",
    "* *c = 427*, and\n",
    "* *op = [\"<\", \"<=\", \">\", \">=\", \"==\", \"!=\"]*.\n",
    "\n",
    "Create a program that ouputs the following using conditional statments.\n",
    "\n",
    "1. **a < b = True.**\n",
    "2. **a <= c = True.**\n",
    "3. **b > a = True.**\n",
    "4. **b >= c = False.**\n",
    "5. **c == a = False.**\n",
    "6. **c != b = True.**\n",
    "7. **(a > c) and (b > a) = False.**\n",
    "8. **(a > c) or (b > a) = True.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "72520fba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "These are the outputs of the problem:\n",
      "1. 3 < 7 = True.\n",
      "2. 3 <= 427 = True.\n",
      "3. 7 > 3 = True.\n",
      "4. 7 >= 427 = False.\n",
      "5. 427 == 3 = False.\n",
      "6. 427 != 7 = True.\n",
      "7. (3 > 427) and (7 > 3) = False.\n",
      "8. (3 > 427) or (7 > 3) = True.\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = 7\n",
    "c = 427\n",
    "op = [\"<\", \"<=\", \">\", \">=\", \"==\", \"!=\"]\n",
    "\n",
    "print(\"These are the outputs of the problem:\")\n",
    "print(\"1. {a} {b} {c} = {d}.\".format(a = a, c = b, b = op[0], d = a < b))\n",
    "print(\"2. {a} {b} {c} = {d}.\".format(a = a, c = c, b = op[1], d = a <= c))\n",
    "print(\"3. {a} {b} {c} = {d}.\".format(a = b, c = a, b = op[2], d = b > a))\n",
    "print(\"4. {a} {b} {c} = {d}.\".format(a = b, c = c, b = op[3], d = b >= c))\n",
    "print(\"5. {a} {b} {c} = {d}.\".format(a = c, c = a, b = op[4], d = c == a))\n",
    "print(\"6. {a} {b} {c} = {d}.\".format(a = c, c = b, b = op[5], d = c != b))\n",
    "\n",
    "print(\"7. ({a} {b} {c}) and ({d} {e} {f}) = {g}.\".format(a = a, b = op[2], c = c, d = b, e = op[2], f = a, g = (a > c) and (b > a)))\n",
    "print(\"8. ({a} {b} {c}) or ({d} {e} {f}) = {g}.\".format(a = a, b = op[2], c = c, d = b, e = op[2], f = a, g = (a > c) or (b > a)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "25832d26",
   "metadata": {},
   "source": [
    "**Question 3:** Use **Python 3's IF STATEMENT** to create the following algorithm:\n",
    "\n",
    "1. Three variables: *a*, *b* and *c* with the respective values of *10*, *20* and *30*.\n",
    "2. In the event that *a* is greater than **3** or *b* is less than *c*, then output the value for *c* which is given by:\n",
    "$$c = c^2$$\n",
    "3. Else, output:\n",
    "$$c = \\sqrt{a^2 + b ^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a6933651",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The computed value of c is: 900\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 10, 20, 30\n",
    "\n",
    "if a > 3 or b < c:\n",
    "    c = c ** 2\n",
    "else:\n",
    "    c = (a**2 + b **c)**0.5\n",
    "print(\"The computed value of c is: {a}\".format(a = c))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f0516bb3",
   "metadata": {},
   "source": [
    "**Question 4:** Using **Python 3's IF STATEMENT** verify if a person is under or equal the speed limit if the **Speed Limit** is *65* and **mySpeed** is *55*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "9db86712",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are currently driving at a speed of 55 MPH... As such, you are inside the speed limits denoted by law.\n"
     ]
    }
   ],
   "source": [
    "limitSpeed = 65\n",
    "mySpeed = 55\n",
    "\n",
    "if(abs(mySpeed) <= limitSpeed):\n",
    "    print(\"You are currently driving at a speed of {a} MPH... As such, you are inside the speed limits denoted by law.\".format(a = mySpeed))\n",
    "else:\n",
    "    print(\"You are driving at a speed of {a} MPH, which is out of the bounds designated by law! SLOW DOWN!\".format(a = mySpeed))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9e34150f",
   "metadata": {},
   "source": [
    "**Question 5:** Using **Python 3's IF STATEMENT** check whether a person is overweight or not using the **BIM** equation which is:\n",
    "$$BIM = {{703 \\times weight_{lb}} \\over {{height_{in}}^2}}$$\n",
    "\n",
    "and denotes that an individual is overweight if his or her *BIM* is greater than or equal to 25.\n",
    "\n",
    "The person is **Pancho** who has a weight of **180 pounds** and a height of **6 feet**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "642efd94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The magnitude of Pancho's BIM is 24.41; hence, he is not overweight.\n"
     ]
    }
   ],
   "source": [
    "name = \"Pancho\"\n",
    "altura_in = 6*12\n",
    "peso_lbs = 180\n",
    "\n",
    "bim = round((703*peso_lbs)/(altura_in**2),2)\n",
    "if bim < 25:\n",
    "    print(\"The magnitude of {a}'s BIM is {b}; hence, he is not overweight.\".format(a = name, b = bim))\n",
    "else:\n",
    "    print(\"The magnitude of {a}'s BIM is {b} so he is overweight.\".format(a = name, b = bim))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "56e08126",
   "metadata": {},
   "source": [
    "**Question 6:** Create a **Python 3's FUNCTION** that would accept two (2) parameters **x** and **y** and will return the addition of such values. For the first case, the values of *x* and *y* are *2* and *3*, respectively; for the second case, they are *45* and *23*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "ac8fa7f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Addition' function equals: 5\n",
      "'Addition' function equals: 68\n"
     ]
    }
   ],
   "source": [
    "def addition (x, y):\n",
    "    return x + y\n",
    "\n",
    "print(\"'Addition' function equals: {a}\".format(a = addition(2,3)))\n",
    "print(\"'Addition' function equals: {a}\".format(a = addition(45,23)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ce579c57",
   "metadata": {},
   "source": [
    "**Question 7:** Use the previous question **(Question 5)** and create a function for the problem. This function must only output whether the person is overweight or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "40a15717",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pancho is not overweight.\n"
     ]
    }
   ],
   "source": [
    "def BIM_calc(name, altura_in, peso_lbs):\n",
    "    bim = 703*peso_lbs/(altura_in**2)\n",
    "    if(bim < 25):\n",
    "        print(name, \"is not overweight.\")\n",
    "    else:\n",
    "        print(name, \"is overweight.\")\n",
    "\n",
    "BIM_calc(\"Pancho\", 6*12, 180)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b0b0afba",
   "metadata": {},
   "source": [
    "**Question 8:** Create a function for converting from **Celsius** temperature to **Farenheit**. The current temperature is **100** celsius."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "9d862cd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If the temperature is 100 C, then such a value is Farenheit is 212.0 F.\n"
     ]
    }
   ],
   "source": [
    "def cTof_converter(celsius):\n",
    "    return celsius*(9/5) + 32\n",
    "\n",
    "print(\"If the temperature is {a} C, then such a value is Farenheit is {b} F.\".format(a = 100, b = cTof_converter(100)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "63c53be5",
   "metadata": {},
   "source": [
    "**Question 9:** Python, like many other programming languages, can use already existing programming code of other individuals. These peices of code are found in what is known as **Libraries**. For this problem compute the area of a circle using both a radius *r* of 20 meters and the **math** Python 3 library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "3e510d62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of a circle with a radius of 20 m is 2513.27.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def areaCircle(radius):\n",
    "    return 2*math.pi*pow(radius,2)\n",
    "\n",
    "print(\"The area of a circle with a radius of {a} m is {b}.\".format(a = 20, b = round(areaCircle(20),2)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9ef83e73",
   "metadata": {},
   "source": [
    "**Question 10:** Using Python 3's *math* library, prove that:\n",
    "$$sin(x)^2 + cos(x)^2 = 1$$\n",
    ", if *x* can be 0, 90 and 180 + 275."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b54e27e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All of the following values must equat to '1' since sin(x)^2 + cos(x)^2 = 1:\n",
      "1. For sin(0)^2 + cos(0)^2 = 1.0\n",
      "2. For sin(90)^2 + cos(90)^2 = 1.0\n",
      "3. For sin(455)^2 + cos(455)^2 = 1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "val1 = 0\n",
    "val2 = 90\n",
    "val3 = 180\n",
    "val4 = 275\n",
    "\n",
    "print(\"All of the following values must equat to '1' since sin(x)^2 + cos(x)^2 = 1:\")\n",
    "print(\"1. For sin({a})^2 + cos({a})^2 = {b}\".format(a = val1, b=pow(math.sin(val1),2)+pow(math.cos(val1),2)))\n",
    "print(\"2. For sin({a})^2 + cos({a})^2 = {b}\".format(a = val2, b=pow(math.sin(val2),2)+pow(math.cos(val2),2)))\n",
    "print(\"3. For sin({a})^2 + cos({a})^2 = {b}\".format(a = val3 + val4, b=pow(math.sin(val3 + val4),2)+pow(math.cos(val3 + val4),2)))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ea2f0fc1",
   "metadata": {},
   "source": [
    "**Question 11:** Use **Python 3's FOR LOOPS** to output a list of five (5) random numbers from 1 to 100. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "39a58344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list of five (5) random integers from 1 to 100 are: 57, 4, 25, 59, 17.\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "tmp = []\n",
    "\n",
    "for i in range(5):\n",
    "    tmp.append(randint(1,100))\n",
    "\n",
    "print(\"The list of five (5) random integers from 1 to 100 are: {a}.\".format(a=str(tmp)[1:-1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b18f5a66",
   "metadata": {},
   "source": [
    "**Question 12:** Generate this output: **This list contains: [10, 8, 6, 4]**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "329f2c5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This list contains: [10, 8, 6, 4].\n"
     ]
    }
   ],
   "source": [
    "list2 = [*range(10,2,-2)]\n",
    "print(\"This list contains: {a}.\".format(a=list2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "46e88629",
   "metadata": {},
   "source": [
    "**Question 13:** You have two (2) words: **Amazon** and **Prime**. First find the length of these words, then unite them into a sentence and find the length of this sentence, as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "adc618a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first string is Amazon and it has 6 characters.\n",
      "The second string is Prime and it has 5 characters.\n",
      "The third string is Amazon Prime and it has 12 characters.\n"
     ]
    }
   ],
   "source": [
    "string1 = \"Amazon\"\n",
    "string2 = \"Prime\"\n",
    "\n",
    "print(\"The first string is\", string1, \"and it has\", len(string1), \"characters.\" )\n",
    "print(\"The second string is\", string2, \"and it has\", len(string2), \"characters.\" )\n",
    "print(\"The third string is\", string1 + \" \" + string2, \"and it has\", len(string1 + \" \" + string2), \"characters.\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1dd8f473",
   "metadata": {},
   "source": [
    "**Question 14:** Output the following code:\n",
    "\n",
    "```\n",
    "maxIter = 80\n",
    "k = 1;\n",
    "dot = \".\"\n",
    "\n",
    "for i in range(maxIter):\n",
    "    print(dot)\n",
    "    if i >= k*0 and i < k*20:\n",
    "        dot = \" \" + dot\n",
    "    elif(i*k >= 20 and i*k % 40 != 0):\n",
    "        dot = dot[1:]\n",
    "    else:\n",
    "        k = k + 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "05cd3b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\n",
      " .\n",
      "  .\n",
      "   .\n",
      "    .\n",
      "     .\n",
      "      .\n",
      "       .\n",
      "        .\n",
      "         .\n",
      "          .\n",
      "           .\n",
      "            .\n",
      "             .\n",
      "              .\n",
      "               .\n",
      "                .\n",
      "                 .\n",
      "                  .\n",
      "                   .\n",
      "                    .\n",
      "                   .\n",
      "                  .\n",
      "                 .\n",
      "                .\n",
      "               .\n",
      "              .\n",
      "             .\n",
      "            .\n",
      "           .\n",
      "          .\n",
      "         .\n",
      "        .\n",
      "       .\n",
      "      .\n",
      "     .\n",
      "    .\n",
      "   .\n",
      "  .\n",
      " .\n",
      ".\n",
      ".\n",
      " .\n",
      "  .\n",
      "   .\n",
      "    .\n",
      "     .\n",
      "      .\n",
      "       .\n",
      "        .\n",
      "         .\n",
      "          .\n",
      "           .\n",
      "            .\n",
      "             .\n",
      "              .\n",
      "               .\n",
      "                .\n",
      "                 .\n",
      "                  .\n",
      "                   .\n",
      "                  .\n",
      "                 .\n",
      "                .\n",
      "               .\n",
      "              .\n",
      "             .\n",
      "            .\n",
      "           .\n",
      "          .\n",
      "         .\n",
      "        .\n",
      "       .\n",
      "      .\n",
      "     .\n",
      "    .\n",
      "   .\n",
      "  .\n",
      " .\n",
      ".\n"
     ]
    }
   ],
   "source": [
    "maxIter = 80\n",
    "k = 1;\n",
    "dot = \".\"\n",
    "\n",
    "for i in range(maxIter):\n",
    "    print(dot)\n",
    "    if i >= k*0 and i < k*20:\n",
    "        dot = \" \" + dot\n",
    "    elif(i*k >= 20 and i*k % 40 != 0):\n",
    "        dot = dot[1:]\n",
    "    else:\n",
    "        k = k + 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7d1a1af5",
   "metadata": {},
   "source": [
    "**Question 15:** There is a Python 3 library called **NUMPY** which can be used to create lists in addition to the form which they have been created in Python until now. Run the following code to see the similarities and differences between the two outputs. **Do you see any difference?**\n",
    "\n",
    "```\n",
    "import numpy as np\n",
    "\n",
    "someArray_x = np.arange(0,1,0.1)\n",
    "someList_y = list(someArray_x)\n",
    "print(\"List generated with numpy:\",someArray_x)\n",
    "print(\"List generated without numpy:\",someList_y)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "75907b99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List generated with numpy: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n",
      "List generated without numpy: [0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "someArray_x = np.arange(0,1,0.1)\n",
    "someList_y = list(someArray_x)\n",
    "print(\"List generated with numpy:\",someArray_x)\n",
    "print(\"List generated without numpy:\",someList_y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "07ad9287",
   "metadata": {},
   "source": [
    "## 3 Final - Points\n",
    "\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0df4a580",
   "metadata": {},
   "source": [
    "**Question 1:** Python can be used to find multiples of given numbers. Find the numbers, of a list of **100** numbers, which are multiples of **3**, **5**, **both**, and **either**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "96b4991b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are, respectively, about 33, 20, 6 and 47 numbers which are multiples of 3, 5, both and inclusive.\n",
      "\n",
      "The list of numbers which are multiples of 3 is the following: [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99].\n",
      "The list of numbers which are multiples of 5 is as follows: [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100].\n",
      "The list which include numbers which are both multiples of 3 and 5 is: [15, 30, 45, 60, 75, 90].\n",
      "The list which include numbers which are either multiples of 3 or 5 is: [3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24, 25, 27, 30, 33, 35, 36, 39, 40, 42, 45, 48, 50, 51, 54, 55, 57, 60, 63, 65, 66, 69, 70, 72, 75, 78, 80, 81, 84, 85, 87, 90, 93, 95, 96, 99, 100].\n"
     ]
    }
   ],
   "source": [
    "someList = list(range(0,100))\n",
    "multiple3 = []\n",
    "multiple5 = []\n",
    "multipleBoth = []\n",
    "multipleInclusive = []\n",
    "\n",
    "for number in someList:\n",
    "    if((number+1) % 3 == 0):\n",
    "        multiple3.append(number+1)\n",
    "    if((number+1) % 5 == 0):\n",
    "        multiple5.append(number+1)\n",
    "    if((number+1) % 3 == 0 and (number+1) % 5 == 0):\n",
    "        multipleBoth.append(number+1)\n",
    "    if((number+1) % 3 == 0 or (number+1) % 5 == 0):\n",
    "        multipleInclusive.append(number+1)\n",
    "        \n",
    "print(\"There are, respectively, about {a}, {b}, {c} and {d} numbers which are multiples of 3, 5, both and inclusive.\\n\".format(a = len(multiple3), b = len(multiple5), c = len(multipleBoth), d = len(multipleInclusive)))\n",
    "print(\"The list of numbers which are multiples of 3 is the following: {a}.\".format(a = multiple3))\n",
    "print(\"The list of numbers which are multiples of 5 is as follows: {a}.\".format(a = multiple5))\n",
    "print(\"The list which include numbers which are both multiples of 3 and 5 is: {a}.\".format(a = multipleBoth))\n",
    "print(\"The list which include numbers which are either multiples of 3 or 5 is: {a}.\".format(a = multipleInclusive))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1b5ff818",
   "metadata": {},
   "source": [
    "**Question 2:** Little can any program do if it is not able to accept user input. Try the following lines of code:\n",
    "```\n",
    "i = None\n",
    "\n",
    "while (i == None):\n",
    "    i = input(\"SYSTEM FAILURE! PRESS A KEY!!!\")\n",
    "print(\"The problem has been fixed!!!!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "dc75994f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The problem has been fixed!!!!\n"
     ]
    }
   ],
   "source": [
    "i = None\n",
    "\n",
    "while (i == None):\n",
    "    i = input(\"SYSTEM FAILURE! PRESS A KEY!!!\")\n",
    "print(\"The problem has been fixed!!!!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0b8d1290",
   "metadata": {},
   "source": [
    "**Question 3:** Using programming logic, a Python 3 program can be written to generate  random list of numbers of random length, and find the addition of numbers which are positive and the addition of those which are not. Take that the length of the list can be from **1** to **500** and the possible value of each digit in such a list can lie betwen **-100** and **100**. Write a program that achieve what has been already stated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "d81828ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The generated list of numbers is the following: [-100, -61, -53, -25, -7, -4, -4, 23, 35, 51, 55, 63, 93, 94, 98]\n",
      "The sum of the positive numbers is: 512.\n",
      "The sum of the negative numbers is: -254.\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "n = randint(0,500)\n",
    "someList = []\n",
    "sumPos = 0\n",
    "sumNeg = 0\n",
    "\n",
    "for i in range(1,n):\n",
    "    someList.append(randint(-100,100))\n",
    "someList.sort()\n",
    "\n",
    "for element in someList:\n",
    "    if(element >= 0):\n",
    "        sumPos = sumPos + element\n",
    "    else:\n",
    "        sumNeg = sumNeg + element\n",
    "print(\"The generated list of numbers is the following: {a}\".format(a = someList))\n",
    "print(\"The sum of the positive numbers is: {a}.\".format(a = sumPos))\n",
    "print(\"The sum of the negative numbers is: {a}.\".format(a = sumNeg))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d8986f42",
   "metadata": {},
   "source": [
    "**Question 4:** Create a Python 3 Program which simulates the process of using two (2) dies. Setting a random number of usess from **1** to **10000**, find the average of value obtained of sum of each side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "214b6ba1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average of the acquired values for the sides of two (2) die is the following: 7.025358324145535. \n",
      "Peronal Note: If I remember correctly such a value must be near the number 7.\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "n = randint(1, 10000)\n",
    "someDieSides1 = []\n",
    "someDieSides2 = []\n",
    "avg = 0\n",
    "\n",
    "for i in range(0, n):\n",
    "    someDieSides1.append(randint(1,6))\n",
    "    someDieSides2.append(randint(1,6))\n",
    "    avg = avg + someDieSides1[i] + someDieSides2[i]\n",
    "\n",
    "avg = avg/n\n",
    "\n",
    "print(\"The average of the acquired values for the sides of two (2) die is the following: {a}. \\nPeronal Note: If I remember correctly such a value must be near the number 7.\".format(a = avg))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f5355241",
   "metadata": {},
   "source": [
    "**Question 5:** Python has some objects called **Dictionaries**, and these are composed of two variables, these being: a **key** and a **value** assigned to this key. It should be noted that a *dictionary*can have multiple *keys* and that each *key* can have multiple *values*. Furthermore, whenever the term *value* is used, it is meant something from an integer to a string or any other object. \n",
    "\n",
    "Run the following code to see what it is meant by this: \n",
    "\n",
    "```\n",
    "someDict = {\"Henry\":420, \"Tom\": 69, \"Ana\": 3000}\n",
    "\n",
    "print(someDict)\n",
    "print(someDict[\"Ana\"])\n",
    "\n",
    "someDict[\"Nala\"] = 21\n",
    "print(someDict)\n",
    "\n",
    "print(someDict.keys())\n",
    "print(someDict.values())\n",
    "\n",
    "someDict[1918] = [1914, 1915, 1916, 1917, 1918]\n",
    "print(someDict)\n",
    "\n",
    "someDict[\"Nope\"] = {\"Nop\": \"\", \"No\": \"Yes\", 40: \"Forty\"}\n",
    "print(someDict)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "a72a06d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Henry': 420, 'Tom': 69, 'Ana': 3000}\n",
      "3000\n",
      "{'Henry': 420, 'Tom': 69, 'Ana': 3000, 'Nala': 21}\n",
      "dict_keys(['Henry', 'Tom', 'Ana', 'Nala'])\n",
      "dict_values([420, 69, 3000, 21])\n",
      "{'Henry': 420, 'Tom': 69, 'Ana': 3000, 'Nala': 21, 1918: [1914, 1915, 1916, 1917, 1918]}\n",
      "{'Henry': 420, 'Tom': 69, 'Ana': 3000, 'Nala': 21, 1918: [1914, 1915, 1916, 1917, 1918], 'Nope': {'Nop': '', 'No': 'Yes', 40: 'Forty'}}\n"
     ]
    }
   ],
   "source": [
    "someDict = {\"Henry\":420, \"Tom\": 69, \"Ana\": 3000}\n",
    "\n",
    "print(someDict)\n",
    "print(someDict[\"Ana\"])\n",
    "\n",
    "someDict[\"Nala\"] = 21\n",
    "print(someDict)\n",
    "\n",
    "print(someDict.keys())\n",
    "print(someDict.values())\n",
    "\n",
    "someDict[1918] = [1914, 1915, 1916, 1917, 1918]\n",
    "print(someDict)\n",
    "\n",
    "someDict[\"Nope\"] = {\"Nop\": \"\", \"No\": \"Yes\", 40: \"Forty\"}\n",
    "print(someDict)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "175e2740",
   "metadata": {},
   "source": [
    "**Question 6:** Python also has an object called a **Set**. This object is just like a list, but with limited functionality, and elements found within itself cannot be repeated. \n",
    "\n",
    "Run the following program to see what it is meant by this:\n",
    "\n",
    "```\n",
    "someSet = set(\"Noice\")\n",
    "\n",
    "print(\"The original set is\",someSet)\n",
    "\n",
    "someSet.add(21)\n",
    "print(\"With the new value of '21', the set becomes:\",someSet)\n",
    "\n",
    "someSet.add(1)\n",
    "print(\"With the new value of '1', the set becomes:\",someSet)\n",
    "\n",
    "someSet.add(21)\n",
    "print(\"See that nothing happens if an old value is added to the set? (The new value that is 'added' is '21'.)\",someSet)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "dff7a796",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original set is {'e', 'N', 'o', 'c', 'i'}\n",
      "With the new value of '21', the set becomes: {'e', 'N', 21, 'o', 'c', 'i'}\n",
      "With the new value of '1', the set becomes: {1, 'e', 'N', 21, 'o', 'c', 'i'}\n",
      "See that nothing happens if an old value is added to the set? (The new value that is 'added' is '21'.) {1, 'e', 'N', 21, 'o', 'c', 'i'}\n"
     ]
    }
   ],
   "source": [
    "someSet = set(\"Noice\")\n",
    "\n",
    "print(\"The original set is\",someSet)\n",
    "\n",
    "someSet.add(21)\n",
    "print(\"With the new value of '21', the set becomes:\",someSet)\n",
    "\n",
    "someSet.add(1)\n",
    "print(\"With the new value of '1', the set becomes:\",someSet)\n",
    "\n",
    "someSet.add(21)\n",
    "print(\"See that nothing happens if an old value is added to the set? (The new value that is 'added' is '21'.)\",someSet)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "115bd842",
   "metadata": {},
   "source": [
    "**Question 7:** Lists and Sets can be use together. Create a list with the numbers **1**, **3**, **4**, **1**, **3**, **25**, **67** and **25**, and find the sum of all non - repetitive terms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "b61e4a6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original list is the following: [1, 3, 4, 1, 3, 25, 67, 25]\n",
      "The newly created set is: {1, 67, 3, 4, 25}\n",
      "The sum of all of the non repetive terms of the previous list is: 100\n"
     ]
    }
   ],
   "source": [
    "givenList = [1, 3, 4, 1, 3, 25, 67, 25]\n",
    "someSet = set(givenList)\n",
    "sum1 = 0\n",
    "\n",
    "for i in someSet:\n",
    "    sum1 = sum1 + i\n",
    "\n",
    "print(\"The original list is the following: {a}\".format(a = givenList))\n",
    "print(\"The newly created set is: {a}\".format(a = someSet))\n",
    "print(\"The sum of all of the non repetive terms of the previous list is: {a}\".format(a = sum1))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3feaf4ec",
   "metadata": {},
   "source": [
    "**Question 8:** Python can be used to open web browsers and handle client - server inputs and outputs. Create a Python 3 program with the library **webbroswer** so that a webpage would open whenever a the user inputs something."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "1a38e62f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import webbrowser\n",
    "\n",
    "userIn = \"\"\n",
    "\n",
    "while(1):\n",
    "    usrIn = input(\"What word is compossed of the following letters: two (2) l's and one t, r and o? >>\")\n",
    "    if(usrIn.lower() == \"troll\"):\n",
    "        webbrowser.open(\"www.google.com\",2)\n",
    "        break"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fb37c3a7",
   "metadata": {},
   "source": [
    "**Question 9:** In Python 3, a programmer can create **objects** via **classes**. These *objects* can denotes as digital representations of real - life things, such as: animals, humans, cooking utencils and complex mathematical equations. Furthermore, given the necesary time, these *objects* can be used to create games like **MAGIKA** or **MEGAMAN**.\n",
    "\n",
    "With that being said, compute the solution of the following mathematical problem:\n",
    "\n",
    "$$Z = 10!$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "0f9d2b17",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Factorial:\n",
    "    def __init__(self):\n",
    "        self.__currentIter = 1\n",
    "        self.__currentVal = 1\n",
    "    def fact(self, maxIter):\n",
    "        return self.__recursion(maxIter, self.__currentIter, self.__currentVal)\n",
    "    def __recursion(self, maxIter, currentIter, currentVal):\n",
    "        currentVal = currentIter*currentVal\n",
    "        if(currentIter == maxIter):\n",
    "            return currentVal\n",
    "        return self.__recursion(maxIter, currentIter + 1, currentVal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "7ee8ba3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If the value is 10, then the factorial to be computed is: 3628800.\n"
     ]
    }
   ],
   "source": [
    "f = Factorial()\n",
    "print(\"If the value is {a}, then the factorial to be computed is: {b}.\".format(a = 10, b = f.fact(10)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "846d2956",
   "metadata": {},
   "source": [
    "**Question 10:** With the knowledge you have learning until now about Python 3, create a *class* of any real - life *thing* that interests you, and create a series of **Getters** and **Setters**. After this class is completed call it in another cell and output all the variables related with itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "bd41622d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    def __init__(self, name, age, tpe, speed, jumpHeight):\n",
    "        self.__name = name\n",
    "        self.__age = age\n",
    "        self.__tpe = tpe\n",
    "        self.__speed = speed\n",
    "        self.__jumpHeight = jumpHeight\n",
    "    def setName(self, name):\n",
    "        self.__name = name\n",
    "    def setAge(self, age):\n",
    "        self.__age = age\n",
    "    def setTpe(self, tpe):\n",
    "        self.__tpe = tpe\n",
    "    def setSpeed(self, speed):\n",
    "        self.__speed = speed\n",
    "    def setJumpHeight(self, jH):\n",
    "        self.__jumpHeight = jH\n",
    "    def getName(self):\n",
    "        return self.__name\n",
    "    def getAge(self):\n",
    "        return self.__age\n",
    "    def getTpe(self):\n",
    "        return self.__tpe\n",
    "    def getSpeed(self):\n",
    "        return self.__speed\n",
    "    def getJumpHeight(self):\n",
    "        return self.__jumpHeight\n",
    "    def isCrazy(self):\n",
    "        if(self.__age*12 <= 6):\n",
    "            return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "6a1ae6d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of the cat: Michito.\n",
      "The age of the cat, in years, is 0.42.\n",
      "The type of the cat: IDK.\n",
      "The magnitude of the speed of the cat: 3000.\n",
      "The max height that the cat can jump, in inches, is 10.\n",
      "The type of variable 'cat' is: <class '__main__.Cat'>.\n",
      "Won't the cat let me sleep? >> True\n"
     ]
    }
   ],
   "source": [
    "cat = Cat(\"Michito\", 5/12, \"IDK\", 3000, 10)\n",
    "print(\"The name of the cat: {a}.\".format(a =cat.getName()))\n",
    "print(\"The age of the cat, in years, is {a}.\".format(a =round(cat.getAge(),2)))\n",
    "print(\"The type of the cat: {a}.\".format(a = cat.getTpe()))\n",
    "print(\"The magnitude of the speed of the cat: {a}.\".format(a = cat.getSpeed()))\n",
    "print(\"The max height that the cat can jump, in inches, is {a}.\".format(a =cat.getJumpHeight()))\n",
    "print(\"The type of variable 'cat' is: {a}.\".format(a = type(cat)))\n",
    "print(\"Won't the cat let me sleep? >> {a}\".format(a = cat.isCrazy()))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "98c096e6",
   "metadata": {},
   "source": [
    "**(FINAL) QUESTION 11:** If you are the first student to finish this assignment completely, correctly and in a fast manner, you will win a **PRIZE ($50)**! \n",
    "\n",
    "Using the concepts learned today during this workshop, implement something new. This can be anything from a simple game to a complex mathematical procedure. You must explain the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "1362b99f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import struct\n",
    "\n",
    "class Quake3_InvSqrt:\n",
    "    def __init__(self, number: int | float):\n",
    "        self.__num = number\n",
    "        self.__x2 = 0.5*number\n",
    "        self.__threehalfs = 1.5\n",
    "    \n",
    "    def setNumber(self, number: int | float):\n",
    "        self.__num = number\n",
    "    \n",
    "    def getNumber(self):\n",
    "        return self.__num\n",
    "    \n",
    "    def compute(self):\n",
    "        tmp = struct.pack('f', self.__num)  # Using the rules of C compilers, convert number to a float and return the memory address of itself.\n",
    "        tmp = struct.unpack('i',tmp)[0]     # Convert the memory address into an integer.\n",
    "        tmp = 0x5f3759df - (tmp >> 1)       # ROR 1 the tmp variable and substract the hex value which will return an int in Python.\n",
    "        tmp = struct.pack('i', tmp)         # Using the rules of C compilers, convert number to integer and return memory address of itself.\n",
    "        tmp = struct.unpack('f', tmp)[0]    # Convert the memory address into a float.\n",
    "        return tmp * (self.__threehalfs - (self.__x2 * (tmp**2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "c5204d1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An approximation of the squared root of 5.668934240362812e-06 is 419.43785421603343.\n"
     ]
    }
   ],
   "source": [
    "q3 = Quake3_InvSqrt(1 / 176400)\n",
    "print(\"An approximation of the squared root of {a} is {b}.\".format(a = q3.getNumber(), b = q3.compute()))"
   ]
  }
 ],
 "metadata": {
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}