Exercises/Exercise_2_Control_Flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python   \n",
    "\n",
    "### Control Flow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A brief note about measuring time to run a cell  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "51.86967382466177\n"
     ]
    }
   ],
   "source": [
    "print(time.time()/((3600*24*365)+13)) # The Unix time started in 1970..."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "t0 = time.time()\n",
    "<code>\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1- Create a script that prints the numbers from 1 to 100, following these rules:   \n",
    "\n",
    "1. in those that are multiples of 3, print \"Fizz\" instead of the number.  \n",
    "2. in those that are  multiples of 5 print \"Buzz\" instead of the number.  \n",
    "3. For numbers that are multiples of both 3 and 5, print \"FizzBuzz\".  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 Buzz\n",
      "5 Fizz\n",
      "6 Buzz\n",
      "9 Buzz\n",
      "10 Fizz\n",
      "12 Buzz\n",
      "15 FizzBuzz\n",
      "18 Buzz\n",
      "20 Fizz\n",
      "21 Buzz\n",
      "24 Buzz\n",
      "25 Fizz\n",
      "27 Buzz\n",
      "30 FizzBuzz\n",
      "33 Buzz\n",
      "35 Fizz\n",
      "36 Buzz\n",
      "39 Buzz\n",
      "40 Fizz\n",
      "42 Buzz\n",
      "45 FizzBuzz\n",
      "48 Buzz\n",
      "50 Fizz\n",
      "51 Buzz\n",
      "54 Buzz\n",
      "55 Fizz\n",
      "57 Buzz\n",
      "60 FizzBuzz\n",
      "63 Buzz\n",
      "65 Fizz\n",
      "66 Buzz\n",
      "69 Buzz\n",
      "70 Fizz\n",
      "72 Buzz\n",
      "75 FizzBuzz\n",
      "78 Buzz\n",
      "80 Fizz\n",
      "81 Buzz\n",
      "84 Buzz\n",
      "85 Fizz\n",
      "87 Buzz\n",
      "90 FizzBuzz\n",
      "93 Buzz\n",
      "95 Fizz\n",
      "96 Buzz\n",
      "99 Buzz\n",
      "100 Fizz\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,101):\n",
    "    if i % 3 == 0 and i % 5 == 0:\n",
    "        print(i,'FizzBuzz')\n",
    "    elif i % 5 == 0:\n",
    "        print(i,'Fizz')\n",
    "    elif i % 3 == 0:\n",
    "        print(i,'Buzz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 - Given the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1,2,3,'4',5,6.3,7.4 + 2j,\"123\",[1,2,3], 93, \"98\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a script or function to print each element of a list, along with its predecessor and its successor. Follow these rules:\n",
    "\n",
    "1. If this element is numeric or a string, print its representational value; and\n",
    "2. If the element is a container but not a string (tuple, list, dict, set, frozenset), print each element of the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6.3\n",
      "(7.4+2j)\n",
      "123\n",
      "[1, 2, 3]\n",
      "93\n",
      "98\n"
     ]
    }
   ],
   "source": [
    "#different approach than in the solution file, but the result seems to be correct (only the set [1, 2, 3] is not split up).\n",
    "for e in list1:\n",
    "    if e != type(str) or type(num):\n",
    "        print(e)\n",
    "    elif e == type(str) and type(tuple) or type(list) or type(set) or type(frozenset):\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6.3\n",
      "(7.4+2j)\n",
      "123\n",
      "1\n",
      "2\n",
      "3\n",
      "93\n",
      "98\n"
     ]
    }
   ],
   "source": [
    "#version from solution file: \n",
    "for e in list1:\n",
    "    if isinstance(e, tuple) or \\\n",
    "    isinstance(e, list) or \\\n",
    "    isinstance(e, dict) or \\\n",
    "    isinstance(e, set) or \\\n",
    "    isinstance(e, frozenset):\n",
    "        for subelement in e:\n",
    "            print(subelement)\n",
    "    else:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3- Using the \"random\" library, create a script to average the sum of two 6-sided dice (D6) in 10,000 releases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method randrange in module random:\n",
      "\n",
      "randrange(start, stop=None, step=1, _int=<class 'int'>) method of random.Random instance\n",
      "    Choose a random item from range(start, stop[, step]).\n",
      "    \n",
      "    This fixes the problem with randint() which includes the\n",
      "    endpoint; in Python this is usually not what you want.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#no chance to figure that out without the cheet sheet. \n",
    "help(random.randrange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2007837044.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/var/folders/34/sw2csfvn5p534d16zdzqdqk40000gn/T/ipykernel_3757/2007837044.py\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    randrage(1, stop=10.000, step=1, _int=<class 'int'>)\u001b[0m\n\u001b[0m                                          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "#my first try: \n",
    "range(1, 10.000, [1])\n",
    "randrage(1, stop=10.000, step=1, _int=<class 'int'>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.00602\n"
     ]
    }
   ],
   "source": [
    "#my second try after going through the solutions. I was not able to get from the method help to random.randint(1, 6)\n",
    "#why start with sum_two dice = []?\n",
    "\n",
    "sum_two_dice = []\n",
    "\n",
    "for i in range(100000):\n",
    "    dice1 = random.randint(1,6)\n",
    "    dice2 = random.randint(1,6)\n",
    "    sum_two_dice.append(dice1 + dice2)\n",
    "\n",
    "print(sum(sum_two_dice)/len(sum_two_dice)) # what does \"len\" do? length? so the 10.000 possibible outcomes of two diceses are the sum_two_dice. Divide the sum through the takes to get the average. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 9, 9, 5, 8, 4, 6, 6, 11, 7]\n",
      "7.3\n"
     ]
    }
   ],
   "source": [
    "#try the same with range up to 10\n",
    "\n",
    "sum_two_dice_test = []\n",
    "for i in range (10): \n",
    "    dice3 = random.randint(1,6)\n",
    "    dice4 = random.randint(1,6)\n",
    "    sum_two_dice_test.append(dice3 + dice4)\n",
    "print (sum_two_dice_test)\n",
    "print(sum(sum_two_dice_test)/len(sum_two_dice_test))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4 - [Project Euler - Problem 3](https://projecteuler.net/problem=3)  \n",
    "  \n",
    "The prime factors of 13195 are 5, 7, 13 and 29.  \n",
    "What is the largest prime factor of the number 600851475143 ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for %: 'int' and 'range'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/34/sw2csfvn5p534d16zdzqdqk40000gn/T/ipykernel_3757/2981041164.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#first try:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m600851475143\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m600851475143\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m600851475143\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for %: 'int' and 'range'"
     ]
    }
   ],
   "source": [
    "#first try: \n",
    "x = 600851475143\n",
    "y = 600851475143 % range(600851475143) and type(int)\n",
    "\n",
    "print(y)\n",
    "print(y.sort)\n",
    "\n",
    "\n",
    "if x/y = type(int):\n",
    "    print(y) \n",
    "    ordery\n",
    "x / y when y = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5 - [Project Euler - Problem 4](https://projecteuler.net/problem=4)  \n",
    "\n",
    "#### Largest palindrome product\n",
    "\n",
    "\"A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.\"  \n",
    "\n",
    "**Find the largest palindrome made from the product of two 3-digit numbers.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Hint: How to reverse a string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'gnirts modnar A'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A random string'[-1::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6 - [Project Euler - Problem 14](https://projecteuler.net/problem=14)  \n",
    "\n",
    "#### Longest Collatz sequence\n",
    "\n",
    "\n",
    "The following iterative sequence is defined for the set of positive integers:\n",
    "\n",
    "n → n/2 (n is even)\n",
    "n → 3n + 1 (n is odd)\n",
    "\n",
    "Using the rule above and starting with 13, we generate the following sequence:\n",
    "\n",
    "13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1\n",
    "It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.\n",
    "\n",
    "**Which starting number, under one million, produces the longest chain?**\n",
    "\n",
    "NOTE: Once the chain starts the terms are allowed to go above one million."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}