Week2/openSAP_python1_Week_2_Unit_5_ranges_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using [ranges](https://docs.python.org/3/tutorial/controlflow.html#the-range-function) to create sequences of numbers\n",
    "Python has an own data type to represent a sequence of numbers. This data type is called\n",
    "[*Range*](https://docs.python.org/3/library/stdtypes.html#ranges). Ranges are created by calling the `range` function.\n",
    "\n",
    "In its simplest form the `range` function is invoked by with just one parameter. In this case a Range starting from 0 is\n",
    "created. The following example shows how to create a range containing the numbers from 0 to 4:\n",
    "\n",
    "```python\n",
    "  range(5) # -> 0 1 2 3 4\n",
    "```\n",
    "\n",
    "As you can see, the paramter, i.e. the end point of the sequence, is **not** part of the sequence. \n",
    "\n",
    "Alternatively, an initial value other than 0 can be used to defined a range. To do this, the `range` function is called\n",
    "with two parameters. The following function call creates a range in the interval from 10 to 15.\n",
    "\n",
    "```python\n",
    "  range(10,16) # -> 10 11 12 13 14 15\n",
    "```\n",
    "\n",
    "As you can see, the start point **is** part of the sequence, the end point is not. Question: What sequence is produced with range: `range(3,3)`? Give it a try ...\n",
    "\n",
    "By using the step size the distance between the numbers in the interval can be defined. The step size can be negative as\n",
    "well as positive.\n",
    "\n",
    "```python\n",
    "  range(2,12,3) # -> 2 5 8 11\n",
    "  range(20,5,-5) # -> 20 15 10\n",
    "```\n",
    "\n",
    "# Ranges and the `for` loop\n",
    "Ranges can be used in combination with the `for` loop to control the number of loop passes. This is explained in more\n",
    "detail in the following examples. For instance, to print the numbers from 0 to 9, the following Python code can be used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in range(3,3):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for number in range(10):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numbers from 10 to 19 can be output as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "for number in range(10, 20):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last but not least, the step size of the interval represented by the range can be adjusted. For example, the following\n",
    "Python code outputs all numbers from 10 to 0 in steps of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "8\n",
      "6\n",
      "4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for number in range(10, 0, -2):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 1 - Combining `range` and `input`\n",
    "Now it's your turn again. Write a Python program that expects three integer numbers as input: from, to and increment.\n",
    "Then output the numbers in that range with the appropriate increment. Note: Remember to convert the inputs to the\n",
    "correct data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "What is the starting value?  5\n",
      "What is the stopping value?  20\n",
      "What is the step?  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "start = int(input(\"What is the starting value? \"))\n",
    "end = int(input(\"What is the stopping value? \"))\n",
    "step = int(input(\"What is the step? \"))\n",
    "\n",
    "for number in range(start, end, step):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 2 - FizzBuzz\n",
    "Write a program that outputs the numbers from 1 to 100. All numbers that are divisible by three should be replaced by\n",
    "*Fizz* and all numbers that are divisible by 5 should be replaced by *Buzz*. Numbers that are divisible by both 3 and 5\n",
    "will be replaced by \"FizzBuzz\".  \n",
    "**Note:** You can check the divisibility with the modulo operator ``%`. The output of the function should look like\n",
    "this:\n",
    "\n",
    "> 1 <br>\n",
    "> 2 <br>\n",
    "> Fizz <br>\n",
    "> 4 <br>\n",
    "> Buzz <br>\n",
    "> Fizz <br>\n",
    "> 7 <br>\n",
    "> ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "FIZZ\n",
      "4\n",
      "BUZZ\n",
      "FIZZ\n",
      "7\n",
      "8\n",
      "FIZZ\n",
      "BUZZ\n",
      "11\n",
      "FIZZ\n",
      "13\n",
      "14\n",
      "FIZZBUZZ\n",
      "16\n",
      "17\n",
      "FIZZ\n",
      "19\n",
      "BUZZ\n",
      "FIZZ\n",
      "22\n",
      "23\n",
      "FIZZ\n",
      "BUZZ\n",
      "26\n",
      "FIZZ\n",
      "28\n",
      "29\n",
      "FIZZBUZZ\n",
      "31\n",
      "32\n",
      "FIZZ\n",
      "34\n",
      "BUZZ\n",
      "FIZZ\n",
      "37\n",
      "38\n",
      "FIZZ\n",
      "BUZZ\n",
      "41\n",
      "FIZZ\n",
      "43\n",
      "44\n",
      "FIZZBUZZ\n",
      "46\n",
      "47\n",
      "FIZZ\n",
      "49\n",
      "BUZZ\n",
      "FIZZ\n",
      "52\n",
      "53\n",
      "FIZZ\n",
      "BUZZ\n",
      "56\n",
      "FIZZ\n",
      "58\n",
      "59\n",
      "FIZZBUZZ\n",
      "61\n",
      "62\n",
      "FIZZ\n",
      "64\n",
      "BUZZ\n",
      "FIZZ\n",
      "67\n",
      "68\n",
      "FIZZ\n",
      "BUZZ\n",
      "71\n",
      "FIZZ\n",
      "73\n",
      "74\n",
      "FIZZBUZZ\n",
      "76\n",
      "77\n",
      "FIZZ\n",
      "79\n",
      "BUZZ\n",
      "FIZZ\n",
      "82\n",
      "83\n",
      "FIZZ\n",
      "BUZZ\n",
      "86\n",
      "FIZZ\n",
      "88\n",
      "89\n",
      "FIZZBUZZ\n",
      "91\n",
      "92\n",
      "FIZZ\n",
      "94\n",
      "BUZZ\n",
      "FIZZ\n",
      "97\n",
      "98\n",
      "FIZZ\n",
      "BUZZ\n"
     ]
    }
   ],
   "source": [
    "# My approach\n",
    "\n",
    "for num in range(1,101):\n",
    "    if (num % 3 ==0) and (num % 5 == 0):\n",
    "        print(\"FIZZBUZZ\")\n",
    "    elif (num % 5 == 0):\n",
    "        print(\"BUZZ\")\n",
    "    elif (num % 3 == 0):\n",
    "        print(\"FIZZ\")\n",
    "    else:\n",
    "        print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "FIZZ\n",
      "4\n",
      "BUZZ\n",
      "FIZZ\n",
      "7\n",
      "8\n",
      "FIZZ\n",
      "BUZZ\n",
      "11\n",
      "FIZZ\n",
      "13\n",
      "14\n",
      "FIZZBUZZ\n",
      "16\n",
      "17\n",
      "FIZZ\n",
      "19\n",
      "BUZZ\n",
      "FIZZ\n",
      "22\n",
      "23\n",
      "FIZZ\n",
      "BUZZ\n",
      "26\n",
      "FIZZ\n",
      "28\n",
      "29\n",
      "FIZZBUZZ\n",
      "31\n",
      "32\n",
      "FIZZ\n",
      "34\n",
      "BUZZ\n",
      "FIZZ\n",
      "37\n",
      "38\n",
      "FIZZ\n",
      "BUZZ\n",
      "41\n",
      "FIZZ\n",
      "43\n",
      "44\n",
      "FIZZBUZZ\n",
      "46\n",
      "47\n",
      "FIZZ\n",
      "49\n",
      "BUZZ\n",
      "FIZZ\n",
      "52\n",
      "53\n",
      "FIZZ\n",
      "BUZZ\n",
      "56\n",
      "FIZZ\n",
      "58\n",
      "59\n",
      "FIZZBUZZ\n",
      "61\n",
      "62\n",
      "FIZZ\n",
      "64\n",
      "BUZZ\n",
      "FIZZ\n",
      "67\n",
      "68\n",
      "FIZZ\n",
      "BUZZ\n",
      "71\n",
      "FIZZ\n",
      "73\n",
      "74\n",
      "FIZZBUZZ\n",
      "76\n",
      "77\n",
      "FIZZ\n",
      "79\n",
      "BUZZ\n",
      "FIZZ\n",
      "82\n",
      "83\n",
      "FIZZ\n",
      "BUZZ\n",
      "86\n",
      "FIZZ\n",
      "88\n",
      "89\n",
      "FIZZBUZZ\n",
      "91\n",
      "92\n",
      "FIZZ\n",
      "94\n",
      "BUZZ\n",
      "FIZZ\n",
      "97\n",
      "98\n",
      "FIZZ\n",
      "BUZZ\n"
     ]
    }
   ],
   "source": [
    "# Another Approach. Not very recommended because of the nested if\n",
    "\n",
    "for num in range(1,101):\n",
    "    if (num % 3 ==0):\n",
    "        if (num % 5 == 0):\n",
    "            print(\"FIZZBUZZ\")\n",
    "        else:\n",
    "            print(\"FIZZ\")\n",
    "    elif (num % 5 == 0):\n",
    "        print(\"BUZZ\")\n",
    "    else:\n",
    "        print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Self Test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1\n",
    "`1.0 Pts`\n",
    "\n",
    "Which list is created by the following statement? `list(range(8))`\n",
    "\n",
    "[0, 1, 2, 3, 4, 5, 6, 7] \n",
    "\n",
    "[0, 1, 2, 3, 4, 5, 6, 7, 8] \n",
    "\n",
    "[1, 2, 3, 4, 5, 6, 7] \n",
    "\n",
    "[1, 2, 3, 4, 5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2\n",
    "`1.0 Pts`\n",
    "\n",
    "Which list is created by the following statement? `list(range(-3, 3, 3))`\n",
    "\n",
    "[3, 0, -3] \n",
    "\n",
    "[0, 3] \n",
    "\n",
    "[-3, 0, 3] \n",
    "\n",
    "[-3, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-3, 0]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(-3, 3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 5: Exercise\n",
    "\n",
    "Instructions:\n",
    "\n",
    "Write a program that lets the user input a two-dimensional matrix (Hint: you could use a list of lists to store the matrix). The program should first ask the user how many rows and columns the matrix should contain. Next, the program should ask the user for the elements of the matrix. Your program should read the values from the user row by row. If, for example, the matrix has the dimension 2 by 3, the values should be read as follows:\n",
    "\n",
    "First row, first value \n",
    "\n",
    "First row, second value \n",
    "\n",
    "First row, third value \n",
    "\n",
    "Second row, first value \n",
    "\n",
    "Second row, second value \n",
    "\n",
    "Second row, third value\n",
    "\n",
    "Finally, the program should calculate and print the sums of the values in each row. \n",
    "\n",
    "Below is an example execution of the program:\n",
    "\n",
    "Please enter the number of rows in the matrix: 2 \n",
    "\n",
    "Please enter the number of columns in the matrix: 3 \n",
    "\n",
    "Enter the matrix values: \n",
    "\n",
    "Value: 1 \n",
    "\n",
    "Value: 2 \n",
    "\n",
    "Value: 3 \n",
    "\n",
    "Value: 4 \n",
    "\n",
    "Value: 5 \n",
    "\n",
    "Value: 6 \n",
    "\n",
    "Sum of row: 6 \n",
    "\n",
    "Sum of row: 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter the number of rows in the matrix: 2\n",
      "Please enter the number of columns in the matrix: 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the matrix values:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Values: 1\n",
      "Values: 2\n",
      "Values: 3\n",
      "Values: 4\n",
      "Values: 5\n",
      "Values: 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of row: 6\n",
      "Sum of row: 15\n"
     ]
    }
   ],
   "source": [
    "# First Attempt\n",
    "rows = int(input(\"Please enter the number of rows in the matrix:\"))\n",
    "columns = int(input(\"Please enter the number of columns in the matrix:\"))\n",
    "matrix = []\n",
    "print(\"Enter the matrix values:\")\n",
    "for num in range(1, ((rows*columns)+1)):\n",
    "    temp = int(input(\"Values:\"))\n",
    "    matrix.append(temp)\n",
    "\n",
    "if rows == 1:\n",
    "    # for i in range(1, rows+1):\n",
    "    print(\"Sum of row:\", matrix[0]+matrix[1]+matrix[2])\n",
    "elif rows == 2:\n",
    "    # for i in range(1, rows+1):\n",
    "    print(\"Sum of row:\", matrix[0]+matrix[1]+matrix[2])\n",
    "    print(\"Sum of row:\", matrix[3]+matrix[4]+matrix[5])\n",
    "elif rows == 3:\n",
    "    print(\"Sum of row:\", matrix[0]+matrix[1]+matrix[2])\n",
    "    print(\"Sum of row:\", matrix[3]+matrix[4]+matrix[5])\n",
    "    print(\"Sum of row:\", matrix[6]+matrix[7]+matrix[8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test File 1 (functional_tests.py)\n",
    "`Passed Tests` 1 out of 1 \n",
    "\n",
    "`Score` 1 out of 1 \n",
    "\n",
    "`Feedback` Well done. All tests have been passed.\n",
    "\n",
    "### Test File 2 (structural_tests.py)\n",
    "`Passed Tests` 1 out of 2 \n",
    "\n",
    "`Score` 0.5 out of 1 \n",
    "\n",
    "`Feedback` You did not use the expected statements or structures. Please check the details below. \n",
    "\n",
    "`Error Messages` test_nested_for: You should use nested for loops to solve this exercise.\n",
    "\n",
    "### Linter Feedback (not graded) \n",
    "`Code Rating` 10 out of 10 \n",
    "\n",
    "`Feedback` Well done. The linter is completly satisfied.\n",
    "\n",
    "\n",
    "Score: 75%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter the number of rows in the matrix: 2\n",
      "Please enter the number of columns in the matrix: 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the matrix values:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Values: 1\n",
      "Values: 2\n",
      "Values: 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of row: 6\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Values: 4\n",
      "Values: 5\n",
      "Values: 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of row: 15\n"
     ]
    }
   ],
   "source": [
    "## Second Attempt\n",
    "rows = int(input(\"Please enter the number of rows in the matrix:\"))\n",
    "columns = int(input(\"Please enter the number of columns in the matrix:\"))\n",
    "matrix = []\n",
    "print(\"Enter the matrix values:\")\n",
    "for x in range(1, rows+1):\n",
    "    for y in range(1, columns+1):\n",
    "        temp = int(input(\"Values:\"))\n",
    "        matrix.append(temp)\n",
    "    print(\"Sum of row:\", matrix[-1] + matrix[-2] + matrix[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It worked!!! Yay!!! 💃💃💃"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please insert number of rows: 2\n",
      "Please insert number of columns: 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the matrix values:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Value: 1\n",
      "Value: 2\n",
      "Value: 3\n",
      "Value: 4\n",
      "Value: 5\n",
      "Value: 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of row: 6\n",
      "Sum of row: 15\n"
     ]
    }
   ],
   "source": [
    "# Review\n",
    "\n",
    "rows = int(input(\"Please insert number of rows:\"))\n",
    "columns = int(input(\"Please insert number of columns:\"))\n",
    "r1 = range(1, rows + 1)\n",
    "c1 = range(1, columns + 1)\n",
    "matrix = []\n",
    "print(\"Enter the matrix values:\")\n",
    "for r in r1:\n",
    "    list = []\n",
    "    r0 = r - 1\n",
    "    for c in c1:\n",
    "        value = int(input(\"Value:\"))\n",
    "        list.append(value)\n",
    "    matrix.append(list)\n",
    "    \n",
    "    # Removed the following two lines to get the code working\n",
    "#     for i in matrix[r0]:\n",
    "#         print(\"Value:\", i)\n",
    "\n",
    "for r in r1:\n",
    "    r0 = r - 1\n",
    "    result = 0\n",
    "    for i in matrix[r0]:\n",
    "        result = result + i\n",
    "    print(\"Sum of row:\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "interpreter": {
   "hash": "ac59ebe37160ed0dfa835113d9b8498d9f09ceb179beaac4002f036b9467c963"
  },
  "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.2"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}