activities/day2_conditionals_loops_and_logical_thinking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "360c13df-200c-4a07-afd2-ca8cfb7749f2",
   "metadata": {},
   "source": [
    "# UQ SMP Programming Bootcamp (Python) V1\n",
    "\n",
    "## Day 2 activities: conditionals, loops, and logical thinking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1eec7c4",
   "metadata": {},
   "source": [
    "A good reference: https://www.w3schools.com/python/default.asp\n",
    "\n",
    "Recap from yesterday: \n",
    "- How many data types do you remember? For example, int. \n",
    "- What were some differences between these data types?\n",
    "- How do we display text? \n",
    "- How do we prompt the user to enter text?\n",
    "- How can we write a basic conditional?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03b6c414",
   "metadata": {},
   "source": [
    "### Task 2.1. Write a program that asks the user to enter a number. Print \"Positive\" if this number is positive, \"Negative\" if it is negative, and \"Zero\" if it is zero.  \n",
    "#### Challenge: Let the user know if the number they entered is even or odd. Hint: The modulo operator is %.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "d9fef511",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exactly 5 or exactly 7\n"
     ]
    }
   ],
   "source": [
    "num = 4\n",
    "\n",
    "# Who does it print \"Exactly 5 or exactly 7\" when num = 4\n",
    "if num==5 or 7:\n",
    "    print(\"Exactly 5 or exactly 7\")\n",
    "else:\n",
    "    print(\"Something else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "613cdec2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Between 3 and 6\n"
     ]
    }
   ],
   "source": [
    "num = 5\n",
    "\n",
    "# Why does it not print 'Exactly 5' when num = 5?\n",
    "if num>3 and num<6:\n",
    "    print(\"Between 3 and 6\")\n",
    "elif num==5:\n",
    "    print(\"Exactly 5\")\n",
    "else:\n",
    "    print(\"Something else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "c8d89a60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Divisible by 3.\n"
     ]
    }
   ],
   "source": [
    "num = 15\n",
    "\n",
    "# Why does it not print \"Divisible by 5 and 3\" if num = 15?\n",
    "if num%3==0:\n",
    "    print(\"Divisible by 3.\")\n",
    "elif num%5==0:\n",
    "    print(\"Divisible by 5.\")\n",
    "elif num%3==0 and num%5==0:\n",
    "    print(\"Divisible by 5 and 3.\")\n",
    "else:\n",
    "    print(\"Something else.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "97de3582-6e9b-499f-87cc-4a32931f9ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import * # this is the random library, it will generate random numbers for us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1a71edd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.48539270426959913"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random() # a random number between 0 and 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bda6d7de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randint(3,6) # a random integer between 3 and 6 (inclusive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "26fa86e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "choice([0,5,9]) # a random item from the given list (or other sequence, such as a string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d8811342",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.23604808973743452"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed(4) # makes the random number generator produce the same results each time\n",
    "random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3de5bba2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cb403d74-f7b6-4e6b-93e8-567e84e887b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maths_quiz():\n",
    "    x = int(100*random())\n",
    "    y = int(100*random())\n",
    "    print(f\"What is {x} + {y}?\")\n",
    "    correct_ans = x + y\n",
    "    user_ans = int(input())\n",
    "    if user_ans == correct_ans:\n",
    "        print(f\"You are right! {x}+{y}={user_ans}\")\n",
    "    else:\n",
    "        print(f\"You are wrong!  {x}+{y} ≠ {user_ans}\") #https://www.compart.com/en/unicode/U+2260"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "935fb07f-162f-4d7e-8767-debd8ea14a22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is 49 + 9?\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 42\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are wrong!  49+9 ≠ 42\n"
     ]
    }
   ],
   "source": [
    "maths_quiz()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df243b0-f82d-43de-8bbd-821429fcd2fd",
   "metadata": {},
   "source": [
    "### Task 2.2: Adapt the program to handle multiplication problems of numbers up to 12.\n",
    "#### Challenge: Adapt the program to allow the user to choose between addition or multiplication (up to 12) before asking them to do the appropriate maths question. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc6d46b1",
   "metadata": {},
   "source": [
    "ASCII: https://www.ascii-code.com/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "aeab3086",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = \"a\"\n",
    "ord(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "8784c5be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "f1d0b223",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "19519bbc",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ord() expected a character, but string of length 5 found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[57], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;43mord\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhello\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: ord() expected a character, but string of length 5 found"
     ]
    }
   ],
   "source": [
    "ord(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "791bdde3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(110)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "b1330a5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(65)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "47703d07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(51)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e123b8dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "6a6c6ebf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "6e753103",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d786fa8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "cf84d8bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lo W'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "16662083",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lo World!'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "723da44f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello W'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "54b90f84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HloWrd'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "997321af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!dlroW olleH'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "cd11e583",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO WORLD!'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "4213bff3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world!'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "806896a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hELLO wORLD!'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "740a0179",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "799b87c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"5\".isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "85acab03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"5.0\".isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "4f41bb4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello 5 hello\".isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "2f91cc30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "2167e06b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello world\".isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ecb08f13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"helloworld\".isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "cb213262",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "c6a6309a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.isascii()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "f3a1cc2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"e\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "1f5b44b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "35292740",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "a65932e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "9d488ee9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(s, str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "fb3a45ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(s, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "00eb8460",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H-e-l-l-o- -W-o-r-l-d-!'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"-\".join(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aac8bb6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "password = \"\"\n",
    "\n",
    "# ask for a letter, a word and a number\n",
    "letter = input(\"Enter a letter: \")\n",
    "word = input(\"Enter a word: \")\n",
    "number = input(\"Enter a positive integer: \")\n",
    "\n",
    "# make the letter upper case, and add it to the end of the password\n",
    "password = password + letter.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54403a23",
   "metadata": {},
   "source": [
    "### Task 2.3. Complete the above program by doing the following:\n",
    "- Make 'word' lower case and add it to the end of the password\n",
    "- Multiply the numerical value of 'number' by a random integer between 0 and 5 (inclusive), then add to the number a random integer between 2 and 6 (inclusive), then add the final number to the end of the password\n",
    "- Display the new password to the user\n",
    "- Tell the user if their password is good or bad. It is not a good password if:\n",
    "    - The first letter is A\n",
    "    - The word they used is 'password' or 'pass'\n",
    "    - The number they used is negative.\n",
    "\n",
    "\n",
    "#### Challenge:\n",
    "Check the user's inputs, and tell the user you cannot generate a password if:\n",
    " - The 'letter' they entered is not a letter in the english alphabet\n",
    " - The 'letter' they entered is actually no letters, or multiple letters\n",
    " - The 'word' they entered is less than 4 characters\n",
    " - The 'word' they entered contains characters not in the english alphabet\n",
    " - The 'word' they entered contains the letter \"x\"\n",
    " - The 'number' they entered contains any non-digit characters\n",
    " - The 'number' they used is divisible by 4\n",
    " - Anything interesting that you can think of. \n",
    "\n",
    "#### Extra Challenge:\n",
    "- Change each character in 'word' by substituting it with the next letter in the alphabet, so \"b\" would become \"c\", \"c\" would become \"d\", and so on. If the original character is \"z\", substitute it with \"a\". (Make sure 'word' is lower case and contains only characters in the alphabet beforehand). \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccd46b36-e2aa-4091-8110-412f3cf01553",
   "metadata": {},
   "source": [
    "Doing something many times with a `for` loop and `range`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cbc5d8d0-9371-476b-96b4-3db272233e7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "Hello!\n",
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "for _ in range(3):\n",
    "    print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fbcc791d-283e-45d2-b0c9-4b4a512e21b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello for time #0\n",
      "Hello for time #1\n",
      "Hello for time #2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(f\"Hello for time #{i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9cb1bb8f-462e-4bae-8731-e6dcbe8f32ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello for time #1\n",
      "Hello for time #2\n",
      "Hello for time #3\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,4):\n",
    "    print(f\"Hello for time #{i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "08fc0a52-1e49-41d0-8931-df460cabd7cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the first 3 numbers is 6\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for i in range(1,4):\n",
    "    total = total + i\n",
    "print(f\"The sum of the first 3 numbers is {total}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9b5b33e-d13a-4064-ac1a-66810127eb40",
   "metadata": {},
   "source": [
    "#### Task 2.4: Adapt the math_quiz function/program to see if users can \"guess\" the total of the first n numbers. The program chooses some random $n$ and asks the user about the sum of $1+2+\\ldots+n$. It tells the user if they are correct or not.\n",
    "\n",
    "The \"user\" may remember that \n",
    "\n",
    "$$\n",
    "\\sum_{i=1}^n i = \\frac{n(n+1)}{2}.\n",
    "$$\n",
    "\n",
    "(but assume that the programmer of the program (you), does not know this)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f45cd80a-d8db-46de-80f2-6870a15a475f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love Yarden\n",
      "I love Emily\n",
      "I love Kayley\n"
     ]
    }
   ],
   "source": [
    "my_kids = [\"Yarden\", \"Emily\", \"Kayley\"]\n",
    "for kid in my_kids: #we can loop over lists, not just over range()\n",
    "    print(f\"I love {kid}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a0db3bfa-2561-4d44-ae80-6a09b659b2c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yarden is 13  years old\n",
      "Emily is 17  years old\n",
      "Kayley is 15  years old\n"
     ]
    }
   ],
   "source": [
    "my_kids_ages = [13, 17, 15]\n",
    "for i in range(len(my_kids)):\n",
    "    print(f\"{my_kids[i]} is {my_kids_ages[i]}  years old\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ad7ba1f-2c41-46ca-b650-cbf9c14a1db0",
   "metadata": {},
   "source": [
    "Using `enumerate`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ec74d9b5-b8cc-4464-a640-e01ece7c5b19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kids number 1 is Yarden\n",
      "Kids number 2 is Emily\n",
      "Kids number 3 is Kayley\n"
     ]
    }
   ],
   "source": [
    "for i,k in enumerate(my_kids): \n",
    "    print(f\"Kids number {i+1} is {k}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a8772407-f356-4ed7-94b2-f37568d71ce5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Return random integer in range [a, b], including both end points.\n",
       "        \n",
       "\u001b[0;31mFile:\u001b[0m      ~/anaconda3/lib/python3.10/random.py\n",
       "\u001b[0;31mType:\u001b[0m      method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "264a4af6-7081-42e0-9505-bed5b23c3d2e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[430, 686, 243, 661, 765, 387, 965, 515, 785, 848]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [randint(1,1000) for _ in range(10)]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "875c191b-a97a-40de-85a3-f50af5fe21ee",
   "metadata": {},
   "source": [
    "#### Task 2.5: Write a program that finds the maximal and minimal number in the array `numbers`. Can you do it with only a single for loop?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcbdc843-9744-45b8-bc60-d11e41cb6dd6",
   "metadata": {},
   "source": [
    "#### Task 2.6: The hailstone sequence. Consider a sequence of numbers $x_0$ and a recurrence\n",
    "\n",
    "$$\n",
    "x_{n+1} =\n",
    "\\begin{cases}\n",
    "x_n/2 & n~\\text{even} \\\\\n",
    "3x_n + 1 & \\text{odd}\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "The [Collatz conjecture](https://en.wikipedia.org/wiki/Collatz_conjecture) is that for any initial positive whole $x_n$ we always end up in $1$ at some point.\n",
    "\n",
    "Write a function/program that produces the first 30 numbers of a sequence when starting at some given $x_0$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d065ffa-765b-4416-9e6c-3cc99e8bb1f3",
   "metadata": {},
   "source": [
    "The `break` statement is a way to stop the loop early."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53f9e7c1-6c2a-474e-87e9-115581c7fd46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".............................................................................................We must be lucky\n"
     ]
    }
   ],
   "source": [
    "numbers = [randint(1,1000) for _ in range(100)]\n",
    "for n in numbers:\n",
    "    if n > 990:\n",
    "        print(\"We must be lucky\")\n",
    "        break\n",
    "    print(\".\",end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c410e505-334a-49cb-9e20-05c97887d95d",
   "metadata": {},
   "source": [
    "#### Task 2.7: Write a program that gives the user 5 math questions. If they get anyone wrong they fail and it stops. If they reach all 5 correct they win."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa94318b-d046-4447-9429-ffe87f221c01",
   "metadata": {},
   "source": [
    "Less common than `break` there is also the `continue` keyword which goes back to the top of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cea3ec6f-44b2-4b47-a660-35f343d5a163",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I've got a car\n",
      "I've got a dog\n",
      "I've got a brain\n"
     ]
    }
   ],
   "source": [
    "my_things = [23, \"car\", 252, \"dog\", 12, 15, \"brain\"]\n",
    "\n",
    "for thing in my_things:\n",
    "    if type(thing) == int:\n",
    "        continue\n",
    "    print(f\"I've got a {thing}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d384b84-3d17-4fd4-be60-8494e91b021b",
   "metadata": {},
   "source": [
    "Return now to the hailstone sequence and say we want to run until we hit 1. Here is the `while` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4dcdfc83-1d08-48d6-9160-000aa67b1a86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "20\n",
      "10\n",
      "5\n",
      "16\n",
      "8\n",
      "4\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 13 # init value\n",
    "while x != 1:\n",
    "    if x % 2 == 0:\n",
    "        x = x // 2\n",
    "    else:\n",
    "        x = 3*x + 1\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d0844a5-c2f8-4ade-a544-9e47c6260adf",
   "metadata": {},
   "source": [
    "Easy to \"get stuck\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fe088ff2-b01f-49ef-ac3e-313b50809b35",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m      2\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    x = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30944e88-3d2a-4753-bdb3-683277af66ba",
   "metadata": {},
   "source": [
    "You can have a loop within a loop (and more):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3ae527e4-5dc6-4eef-bb6b-b1aa82ee12de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 \n",
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 \n",
      "1 \n",
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 \n",
      "1 2 3 4 5 6 7 8 9 \n",
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 \n",
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 \n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    n = randint(1,20)\n",
    "    if n == 7:\n",
    "        break\n",
    "    for i in range(1,n+1):\n",
    "        print(i, end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de0e5251-6d6f-4e9a-9fa3-691be6bb12b8",
   "metadata": {},
   "source": [
    "#### Task 2.8: Write finds the $x_0 \\le 1000$ which yields the longest hailstone sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d807a9-c7a5-4478-a871-410b727918af",
   "metadata": {},
   "source": [
    "#### Task 2.9: You can always convert for loops into a while loop. Can you do it with this code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "90378e20-8847-463e-9ef9-a4efcae0937f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jason\n",
      "Janet\n",
      "Jill\n",
      "Joel\n",
      "Jack\n"
     ]
    }
   ],
   "source": [
    "names = [\"Jason\", \"Janet\", \"Jill\", \"Joel\", \"Jack\"]\n",
    "for name in names:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7368d7a-7ad0-4c58-9547-77dcd4684b96",
   "metadata": {},
   "source": [
    "#### Task 2.10: Write a program that gets a number and tells us if it is prime or not."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e958b87-7147-4240-8b5c-6c385f95f1d3",
   "metadata": {},
   "source": [
    "#### Task 2.11: Consider the [Stirling approximation](https://en.wikipedia.org/wiki/Stirling%27s_approximation) of factorials. Print a table of the relative error of the approximation. You may need to look up how to compute exp() and pi."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c479402-ec66-4713-b2da-c4d5df7a0fdd",
   "metadata": {},
   "source": [
    "Working \"buckets\"..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "53abf74b-2452-48b1-b389-f6c154f47dcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m  \u001b[0mord\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m/\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m Return the Unicode code point for a one-character string.\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "? ord"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d0c2a179-456f-4133-baa1-472263113d19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "22432244-50ac-447e-816c-392d6bf439b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5314f87a-748a-4613-aa82-2b904960509d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(98)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "03ee8d93-6514-4c13-9ba0-0a147de18a05",
   "metadata": {},
   "outputs": [],
   "source": [
    "some_text = \"\"\"\n",
    "This is some text which I just wrote here. \n",
    "It doesn't have much meaning. \n",
    "It is just some text. \n",
    "I love writing. I really do.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a324982d-cd98-49da-8e17-203a6c45426e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " appears 5 times\n",
      "  appears 24 times\n",
      "' appears 1 times\n",
      ". appears 5 times\n",
      "I appears 5 times\n",
      "T appears 1 times\n",
      "a appears 3 times\n",
      "c appears 2 times\n",
      "d appears 2 times\n",
      "e appears 12 times\n",
      "g appears 2 times\n",
      "h appears 6 times\n",
      "i appears 7 times\n",
      "j appears 2 times\n",
      "l appears 3 times\n",
      "m appears 4 times\n",
      "n appears 4 times\n",
      "o appears 6 times\n",
      "r appears 4 times\n",
      "s appears 8 times\n",
      "t appears 11 times\n",
      "u appears 3 times\n",
      "v appears 2 times\n",
      "w appears 3 times\n",
      "x appears 2 times\n",
      "y appears 1 times\n"
     ]
    }
   ],
   "source": [
    "counts = [0 for _ in range(200)]\n",
    "for c in some_text:\n",
    "    index = ord(c)\n",
    "    counts[index] = counts[index] + 1\n",
    "\n",
    "for i, num in enumerate(counts):\n",
    "    if num == 0:\n",
    "        continue\n",
    "    print(f\"{chr(i)} appears {num} times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "013b83b0-31f8-4f50-a833-b604a014a1b1",
   "metadata": {},
   "source": [
    "#### Task 2.12: Write a game that challanges the player to write a sentance where no character appears more than 3 times. The longer the sentance (in characters), the higher the score. (The game will not check the validity of the sentence)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1563d1a-11dc-46c5-84d7-fcb6266ce04d",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <h1>\n",
    "        END OF DAY 2\n",
    "    </h1>\n",
    "</center>"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}