Week3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice Quiz: While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Fill in the blanks to make the print_prime_factors function print all the prime factors of a number. A prime factor is a number that is prime and divides another without a remainder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n",
      "5\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Done'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def print_prime_factors(number):\n",
    "  # Start with two, which is the first prime\n",
    "  factor = 2\n",
    "  # Keep going until the factor is larger than the number\n",
    "  while factor <= number:\n",
    "    # Check if factor is a divisor of number\n",
    "    if number % factor == 0:\n",
    "      # If it is, print it and divide the original number\n",
    "      print(factor)\n",
    "      number = number / factor\n",
    "    else:\n",
    "      # If it's not, increment the factor by one\n",
    "      factor += 1\n",
    "  return \"Done\"\n",
    "\n",
    "print_prime_factors(100)\n",
    "# Should print 2,2,5,5\n",
    "# DO NOT DELETE THIS COMMENT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The following code can lead to an infinite loop. Fix the code so that it can finish successfully for all numbers.\n",
    "\n",
    "Note: Try running your function with the number 0 as the input, and see what you get!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_power_of_two(n):\n",
    "  # Check if the number can be divided by two without a remainder\n",
    "  if n == 0:\n",
    "    return False\n",
    "  while n % 2 == 0:\n",
    "    n = n / 2\n",
    "  # If after dividing by two the number is 1, it's a power of two\n",
    "  if n == 1:\n",
    "    return True\n",
    "  return False\n",
    "  \n",
    "\n",
    "print(is_power_of_two(0)) # Should be False\n",
    "print(is_power_of_two(1)) # Should be True\n",
    "print(is_power_of_two(8)) # Should be True\n",
    "print(is_power_of_two(9)) # Should be False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Fill in the empty function so that it returns the sum of all the divisors of a number, without including it. A divisor is a number that divides into another without a remainder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def sum_divisors(n):\n",
    "  sum = 1\n",
    "  # Return the sum of all divisors of n, not including n\n",
    "  div = 2\n",
    "  if n == 0:\n",
    "    return 0\n",
    "  \n",
    "  while div < n/2+1:\n",
    "    if n % div == 0:\n",
    "      sum += div\n",
    "    div += 1\n",
    "    \n",
    "  \n",
    "  \n",
    "  return sum\n",
    "\n",
    "print(sum_divisors(6)) # Should be 6 (sum of 1+2+3)\n",
    "print(sum_divisors(12)) # Should be 16 (sum of 1+2+3+4+6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The multiplication_table function prints the results of a number passed to it multiplied by 1 through 5. An additional requirement is that the result is not to exceed 25, which is done with the break statement. Fill in the blanks to complete the function to satisfy these conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3x1=3\n",
      "3x2=6\n",
      "3x3=9\n",
      "3x4=12\n",
      "3x5=15\n",
      "5x1=5\n",
      "5x2=10\n",
      "5x3=15\n",
      "5x4=20\n",
      "5x5=25\n",
      "8x1=8\n",
      "8x2=16\n",
      "8x3=24\n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(number):\n",
    "\t# Initialize the starting point of the multiplication table\n",
    "\tmultiplier = 1\n",
    "\t# Only want to loop through 5\n",
    "\twhile multiplier <= 5:\n",
    "\t\tresult = number*multiplier \n",
    "\t\t# What is the additional condition to exit out of the loop?\n",
    "\t\tif result>25:\n",
    "\t\t\tbreak\n",
    "\t\tprint(str(number) + \"x\" + str(multiplier) + \"=\" + str(result))\n",
    "\t\t# Increment the variable for the loop\n",
    "\t\tmultiplier += 1\n",
    "\n",
    "multiplication_table(3) \n",
    "# Should print: 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15\n",
    "\n",
    "multiplication_table(5) \n",
    "# Should print: 5x1=5 5x2=10 5x3=15 5x4=20 5x5=25\n",
    "\n",
    "multiplication_table(8)\t\n",
    "# Should print: 8x1=8 8x2=16 8x3=24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice Quiz: For Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Fill in the blanks to make the factorial function return the factorial of n. Then, print the first 10 factorials (from 0 to 9) with the corresponding number. Remember that the factorial of a number is defined as the product of an integer and all integers before it. For example, the factorial of five (5!) is equal to 1*2*3*4*5=120. Also recall that the factorial of zero (0!) is equal to 1.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 1\n",
      "2 2\n",
      "3 6\n",
      "4 24\n",
      "5 120\n",
      "6 720\n",
      "7 5040\n",
      "8 40320\n",
      "9 362880\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    result = 1\n",
    "    for x in range(2,n+1):\n",
    "        result *= x\n",
    "    return result\n",
    "for n in range(10):\n",
    "    print(n, factorial(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Write a script that prints the first 10 cube numbers (x**3), starting with x=1 and ending with x=10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n",
      "27\n",
      "64\n",
      "125\n",
      "216\n",
      "343\n",
      "512\n",
      "729\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "for x in range(1,11):\n",
    "  print(x**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Write a script that prints the multiples of 7 between 0 and 100. Print one multiple per line and avoid printing any numbers that aren't multiples of 7. Remember that 0 is also a multiple of 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "7\n",
      "14\n",
      "21\n",
      "28\n",
      "35\n",
      "42\n",
      "49\n",
      "56\n",
      "63\n",
      "70\n",
      "77\n",
      "84\n",
      "91\n",
      "98\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,101,7):\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The retry function tries to execute an operation that might fail, it retries the operation for a number of attempts. Currently the code will keep executing the function even if it succeeds. Modify the code so that it stops trying after the operation succeeded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def retry(operation, attempts):\n",
    "  for n in range(attempts):\n",
    "    if operation():\n",
    "      print(\"Attempt \" + str(n) + \" succeeded\")\n",
    "      break\n",
    "    else:\n",
    "      print(\"Attempt \" + str(n) + \" failed\")\n",
    "retry(create_user, 3)\n",
    "retry(stop_service, 5)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N.B. The parameters to retry() are passed by coursera. So I can't run it in the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice Quiz: Recursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Fill in the blanks to make the is_power_of function return whether the number is a power of the given base. Note: base is assumed to be a positive number. Tip: for functions that return a boolean value, you can return the result of a comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_power_of(number, base):\n",
    "  # Base case: when number is smaller than base.\n",
    "  if number < base:\n",
    "    # If number is equal to 1, it's a power (base**0).\n",
    "    return number == 1\n",
    "\n",
    "  # Recursive case: keep dividing number by base.\n",
    "  return is_power_of(number/base, base)\n",
    "\n",
    "print(is_power_of(8,2)) # Should be True\n",
    "print(is_power_of(64,4)) # Should be True\n",
    "print(is_power_of(70,10)) # Should be False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The count_users function recursively counts the amount of users that belong to a group in the company system, by going through each of the members of a group and if one of them is a group, recursively calling the function and counting the members. But it has a bug! Can you spot the problem and fix it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def count_users(group):\n",
    "  count = 0\n",
    "  for member in get_members(group):\n",
    "    count += 1\n",
    "    if is_group(member):\n",
    "      count += count_users(member) - 1    \n",
    "  return count\n",
    "print(count_users(\"sales\")) # Should be 3\n",
    "print(count_users(\"engineering\")) # Should be 8\n",
    "print(count_users(\"everyone\")) # Should be 18<\\code>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N.B. The parameters to count_users() are passed by coursera. So, I can't run it in the cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Implement the sum_positive_numbers function, as a recursive function that returns the sum of all positive numbers between the number n received and 1. For example, when n is 3 it should return 1+2+3=6, and when n is 5 it should return 1+2+3+4+5=15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def sum_positive_numbers(n):\n",
    "  sum = 0\n",
    "  if n == 1:\n",
    "    return 1\n",
    "  else:\n",
    "    sum += n + sum_positive_numbers(n-1)\n",
    "    \n",
    "  return sum\n",
    "\n",
    "print(sum_positive_numbers(3)) # Should be 6\n",
    "print(sum_positive_numbers(5)) # Should be 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module 3 Graded Assessment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Fill in the blanks of this code to print out the numbers 1 through 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 "
     ]
    }
   ],
   "source": [
    "number = 1\n",
    "while number <= 7:\n",
    "\tprint(number, end=\" \")\n",
    "\tnumber += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The show_letters function should print out each letter of a word on a separate line. Fill in the blanks to make that happen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "def show_letters(word):\n",
    "\tfor letter in word:\n",
    "\t\tprint(letter)\n",
    "\n",
    "show_letters(\"Hello\")\n",
    "# Should print one line per letter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Complete the function digits(n) that returns how many digits the number has. For example: 25 has 2 digits and 144 has 3 digits. Tip: you can figure out the digits of a number by dividing it by 10 once per digit until there are no digits left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def digits(n):\n",
    "\tcount = 0\n",
    "\tif n == 0:\n",
    "\t  return 1\n",
    "\twhile (n>0):\n",
    "\t\tcount += 1\n",
    "\t\tn = math.floor(n/10)\n",
    "\treturn count\n",
    "\t\n",
    "print(digits(25))   # Should print 2\n",
    "print(digits(144))  # Should print 3\n",
    "print(digits(1000)) # Should print 4\n",
    "print(digits(0))    # Should print 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** This function prints out a multiplication table (where each number is the result of multiplying the first number of its row by the number at the top of its column). Fill in the blanks so that calling multiplication_table(1, 3) will print out:\n",
    "\n",
    "1 2 3\n",
    "\n",
    "2 4 6\n",
    "\n",
    "3 6 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 \n",
      "2 4 6 \n",
      "3 6 9 \n"
     ]
    }
   ],
   "source": [
    "def multiplication_table(start, stop):\n",
    "\tfor x in range(start, stop+1):\n",
    "\t\tfor y in range(start, stop+1):\n",
    "\t\t\tprint(x*y, end=\" \")\n",
    "\t\tprint()\n",
    "\n",
    "multiplication_table(1, 3)\n",
    "# Should print the multiplication table shown above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The counter function counts down from start to stop when start is bigger than stop, and counts up from start to stop otherwise. Fill in the blanks to make this work correctly.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counting up: 1,2,3,4,5,6,7,8,9,10\n",
      "Counting down: 2,1\n",
      "Counting up: 5\n"
     ]
    }
   ],
   "source": [
    "def counter(start, stop):\n",
    "\tx = start\n",
    "\tif start > stop:\n",
    "\t\treturn_string = \"Counting down: \"\n",
    "\t\twhile x >= stop:\n",
    "\t\t\treturn_string += str(x)\n",
    "\t\t\tif x != stop:\n",
    "\t\t\t\treturn_string += \",\"\n",
    "\t\t\tx -= 1\n",
    "\t\t\t\n",
    "\telse:\n",
    "\t\treturn_string = \"Counting up: \"\n",
    "\t\twhile x <= stop:\n",
    "\t\t\treturn_string += str(x)\n",
    "\t\t\tif x != stop:\n",
    "\t\t\t\treturn_string += \",\"\n",
    "\t\t\tx += 1\n",
    "\treturn return_string\n",
    "\n",
    "print(counter(1, 10)) # Should be \"Counting up: 1,2,3,4,5,6,7,8,9,10\"\n",
    "print(counter(2, 1)) # Should be \"Counting down: 2,1\"\n",
    "print(counter(5, 5)) # Should be \"Counting up: 5\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** The loop function is similar to range(), but handles the parameters somewhat differently: it takes in 3 parameters: the starting point, the stopping point, and the increment step. When the starting point is greater than the stopping point, it forces the steps to be negative. When, instead, the starting point is less than the stopping point, it forces the step to be positive. Also, if the step is 0, it changes to 1 or -1. The result is returned as a one-line, space-separated string of numbers. For example, loop(11,2,3) should return 11 8 5 and loop(1,5,0) should return 1 2 3 4. Fill in the missing parts to make that happen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 8 5\n",
      "1 2 3 4\n",
      "-1\n",
      "10 12 14 16 18 20 22 24\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def loop(start, stop, step):\n",
    "\treturn_string = \"\"\n",
    "\tif step == 0:\n",
    "\t\tstep = 1\n",
    "\tif start > stop:\n",
    "\t\tstep = abs(step) * -1\n",
    "\telse:\n",
    "\t\tstep = abs(step)\n",
    "\tfor count in range(start,stop,step):\n",
    "\t\treturn_string += str(count) + \" \"\n",
    "\treturn return_string.strip()\n",
    "\n",
    "print(loop(11,2,3)) # Should be 11 8 5\n",
    "print(loop(1,5,0)) # Should be 1 2 3 4\n",
    "print(loop(-1,-2,0)) # Should be -1\n",
    "print(loop(10,25,-2)) # Should be 10 12 14 16 18 20 22 24 \n",
    "print(loop(1,1,1)) # Should be empty"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}