06_Loops(Advanced).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Python Code Challenges: Loops (Advanced)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "8acb3f69c9b82c63"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Difficult Python Code Challenges involving Loops\n",
    "\n",
    "This lesson will help you review Python loops by providing some challenge exercises involving loops.\n",
    "\n",
    "Some of these challenges are difficult! Take some time to think about them before starting to code.\n",
    "\n",
    "You might not get the solution correct on your first try — look at your output, try to find where you’re going wrong, and iterate on your solution.\n",
    "\n",
    "Finally, if you get stuck, use our solution code! If you “Check Answer” twice with an incorrect solution, you should see an option to get our solution code. However, truly investigate that solution — experiment and play with the solution code until you have a good grasp of how it is working. Good luck!"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "61808b6868d163e4"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Function and Loop Syntax\n",
    "As a refresher, function syntax looks like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "facaea4e6976cdb0"
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid character '…' (U+2026) (2371689147.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001B[0;36m  Cell \u001B[0;32mIn[59], line 2\u001B[0;36m\u001B[0m\n\u001B[0;31m    … do something with the inputs …\u001B[0m\n\u001B[0m    ^\u001B[0m\n\u001B[0;31mSyntaxError\u001B[0m\u001B[0;31m:\u001B[0m invalid character '…' (U+2026)\n"
     ]
    }
   ],
   "source": [
    "def some_function(some_input1, some_input2):\n",
    "  … do something with the inputs …\n",
    "  return output\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.357333Z",
     "start_time": "2023-09-25T22:50:46.076047Z"
    }
   },
   "id": "6059ae831f17a3f0"
  },
  {
   "cell_type": "markdown",
   "source": [
    "For example, a function that prints all odd numbers in a list would look like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "85a680e7a12a4283"
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "outputs": [],
   "source": [
    "def odd_nums(lst):\n",
    "  for item in lst:\n",
    "    if item % 2 == 1:\n",
    "      print(item)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.357694Z",
     "start_time": "2023-09-25T22:50:46.097874Z"
    }
   },
   "id": "970d81e94b9f006b"
  },
  {
   "cell_type": "markdown",
   "source": [
    "And this would produce output like:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3f79dca08229cace"
  },
  {
   "cell_type": "raw",
   "source": [
    ">>> odd_nums([4, 7, 9, 10, 13])\n",
    "7\n",
    "9\n",
    "13"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "912a82eb4819d0cb"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Challenges\n",
    "We’ve included 5 challenges below. Try to answer all of them and polish up your problem-solving skills and your loop expertise."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a0c166709fc6cae5"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1. Larger Sum\n",
    "We are going to start our advanced challenge problems by calculating which list of two inputs has the larger sum. We will iterate through each of the list and calculate the sums, afterwards we will compare the two and return which one has a greater sum. Here are the steps we need:\n",
    "\n",
    "1. Define the function to accept two input parameters: lst1 and lst2\n",
    "2. Create two variables to record the two sums\n",
    "3. Loop through the first list and add up all of the numbers\n",
    "4. Loop through the second list and add up all of the numbers\n",
    "5. Compare the first and second sum and return the list with the greater sum"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "6eb72bdd3f233168"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named larger_sum() that takes two lists of numbers as parameters named lst1 and lst2.\n",
    "\n",
    "The function should return the list whose elements sum to the greater number. If the sum of the elements of each list are equal, return lst1."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "cd84a4cfdefa1111"
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 5]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def larger_sum(lst1, lst2):\n",
    "  sum1 = 0\n",
    "  sum2 = 0\n",
    "  for i in lst1:\n",
    "    sum1 += i\n",
    "  for i in lst2:\n",
    "    sum2 += i\n",
    "  \n",
    "  if sum1 >= sum2:\n",
    "    return lst1\n",
    "  else:\n",
    "    return lst2\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(larger_sum([1, 9, 5], [2, 3, 7]))\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.385341Z",
     "start_time": "2023-09-25T22:50:46.124280Z"
    }
   },
   "id": "31b62e632b3f0520"
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "outputs": [],
   "source": [
    "# Here’s one way to do it:\n",
    "\n",
    "def larger_sum(lst1, lst2):\n",
    "  sum1 = 0\n",
    "  sum2 = 0\n",
    "  for number in lst1:\n",
    "    sum1 += number\n",
    "  for number in lst2:\n",
    "    sum2 += number\n",
    "  if sum1 >= sum2:\n",
    "    return lst1\n",
    "  else: \n",
    "    return lst2"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.409689Z",
     "start_time": "2023-09-25T22:50:46.136428Z"
    }
   },
   "id": "a7fdcd4a5af25afb"
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this solution, we manually iterate through each element in each list and calculate our sums. We then return the list with the greater sum and break the tie by returning lst1. You can also try solving this problem using the sum() function in python. The body of this function could also be condensed into one line of code if you want an additional challenge!\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f7ce9d36f7564af1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 2. Over 9000\n",
    "We are constructing a device that is able to measure the power level of our coding abilities and according to the device, it will be impossible for our power levels to be over 9000. Because of this, as we iterate through a list of power values we will count up each of the numbers until our sum reaches a value greater than 9000. Once this happens, we should stop adding the numbers and return the value where we stopped. In order to do this, we will need the following steps:\n",
    "\n",
    "1. Define the function to accept a list of numbers\n",
    "2. Create a variable to keep track of our sum\n",
    "3. Iterate through every element in our list of numbers\n",
    "4. Within the loop, add the current number we are looking at to our sum\n",
    "5. Still within the loop, check if the sum is greater than 9000. If it is, end the loop\n",
    "6. Return the value of the sum when we ended our loop"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "7b5835340bd1e88f"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named over_nine_thousand() that takes a list of numbers named lst as a parameter.\n",
    "\n",
    "The function should sum the elements of the list until the sum is greater than 9000. When this happens, the mfunction should return the sum. If the sum of all of the elements is never greater than 9000, the function should return total sum of all the elements. If the list is empty, the function should return 0.\n",
    "\n",
    "For example, if lst was [8000, 900, 120, 5000], then the function should return 9020.\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d4554e2fac33340a"
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9020\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def over_nine_thousand(lst):\n",
    "  sum = 0\n",
    "  for i in lst:\n",
    "    sum += i\n",
    "    if sum > 9000:\n",
    "      break\n",
    "  return sum\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(over_nine_thousand([8000, 900, 120, 5000,2345]))\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.410534Z",
     "start_time": "2023-09-25T22:50:46.150523Z"
    }
   },
   "id": "2d6cd819ad586d63"
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "outputs": [],
   "source": [
    "# Here is this solution:\n",
    "\n",
    "def over_nine_thousand(lst):\n",
    "  sum = 0\n",
    "  for number in lst:\n",
    "    sum += number\n",
    "    if (sum > 9000):\n",
    "      break\n",
    "  return sum\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.425581Z",
     "start_time": "2023-09-25T22:50:46.161011Z"
    }
   },
   "id": "fb9e7ab43d373154"
  },
  {
   "cell_type": "markdown",
   "source": [
    "Our solution follows a similar pattern to some of the other code challenges, except that we have a condition where we end early. In the case where we reach a sum greater than 9000, we can use the break keyword to exit our loop. This will continue to execute the code outside of our loop, which in this case, returns the sum that we found."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d94f4ab3844ab28e"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 3. Max Num\n",
    "Here is a more traditional coding problem for you. This function will be used to find the maximum number in a list of numbers. This can be accomplished using the max() function in python, but as a challenge, we are going to manually implement this function. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept a list of numbers called nums\n",
    "2. Set our default maximum value to be the first element in the list\n",
    "3. Loop through every number in the list of numbers\n",
    "4. Within the loop, if we find a number greater than our starting maximum, then replace the maximum with what we found.\n",
    "5. Return the maximum number"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "78e0c5dff3a94041"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named max_num() that takes a list of numbers named nums as a parameter.\n",
    "\n",
    "The function should return the largest number in nums"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c3f23047e637ad25"
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "75\n",
      "-10\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def max_num(nums):\n",
    "  maximun = nums[0]\n",
    "  for i in nums:\n",
    "    if i > maximun:\n",
    "      maximun = i\n",
    "  return maximun\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(max_num([50, -10, 0, 75, 20]))\n",
    "print(max_num([-50, -10]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.427055Z",
     "start_time": "2023-09-25T22:50:46.175731Z"
    }
   },
   "id": "39decc29d8668e94"
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "outputs": [],
   "source": [
    "# Here is one way to solve this:\n",
    "\n",
    "def max_num(nums):\n",
    "  maximum = nums[0]\n",
    "  for number in nums:\n",
    "    if number > maximum:\n",
    "      maximum = number\n",
    "  return maximum"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.447577Z",
     "start_time": "2023-09-25T22:50:46.186692Z"
    }
   },
   "id": "d5389f6e9033fcdb"
  },
  {
   "cell_type": "markdown",
   "source": [
    "There are a few different ways to accomplish this task, but the way we did it was to check every element in the list and see if there is one bigger than what we currently think is the biggest. If there is a bigger one, then replace it. We keep replacing the number until the largest number has been found."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "485646500b439da6"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 4. Same Values\n",
    "In this challenge, we need to find the indices in two equally sized lists where the numbers match. We will be iterating through both of them at the same time and comparing the values, if the numbers are equal, then we record the index. These are the steps we need to accomplish this:\n",
    "\n",
    "1. Define our function to accept two lists of numbers\n",
    "2. Create a new list to store our matching indices\n",
    "3. Loop through each index to the end of either of our lists\n",
    "4. Within the loop, check if our first list at the current index is equal to the second list at the current index. If so, append the index where they matched\n",
    "5. Return our list of indices\n",
    "If any of the two elements are not equal then we know that the second list is not the reverse of the first list and we return False. If we made it to the end without a mismatch then we can return True since the second list is the reverse of the first. You could also try simplifying this code by using the python function reversed() or other methods that you will learn later on such as ‘slicing’."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b19e1c9435fc5d51"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named same_values() that takes two lists of numbers of equal size as parameters.\n",
    "\n",
    "The function should return a list of the indices where the values were equal in lst1 and lst2.\n",
    "\n",
    "For example, the following code should return [0, 2, 3]\n",
    "\n",
    "same_values([5, 1, -10, 3, 3], [5, 10, -10, 3, 5])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f2548f972a91e026"
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this code, we iterate through each of the indices for the entire length of either of the lists (since we assume the lengths are equal) and we perform a comparison on each of the elements. We get the element at the current index from our first list with lst1[index] and we test it against the last index of the second list minus the current index len(lst2) - 1 – index.\n",
    "\n",
    "That math is a little complicated — it helps to look at a concrete example. If we are given a list of 5 elements, the valid indices are 0 to 4. Because of this, the last index in the second list is len(lst2) - 1, or 5 - 1 = 4. Now in order to get the inverse of the position we are at in the first list, we subtract the index we are at from the end of the second list. So on the first pass, we’ll compare the element at position 0 to the element at position 5 - 1 - 0 = 4. On the next pass, we’ll compare the element at position 1 to the element at position 5 - 1 - 1 = 3, and so on.\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "46172937f509f610"
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def same_values(lst1, lst2):\n",
    "  same_num_index = []\n",
    "  for ind in range(len(lst1)):\n",
    "    if lst1[ind] == lst2[ind]:\n",
    "      same_num_index.append(ind)\n",
    "  return same_num_index\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(same_values([5, 1, -10, 3, 3], [5, 10, -10, 3, 5]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.482472Z",
     "start_time": "2023-09-25T22:50:46.200873Z"
    }
   },
   "id": "82b0c4f9139bd4a1"
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "outputs": [],
   "source": [
    "# Here’s how we did it:\n",
    "\n",
    "def same_values(lst1, lst2):\n",
    "  new_lst = []\n",
    "  for index in range(len(lst1)):\n",
    "    if lst1[index] == lst2[index]:\n",
    "      new_lst.append(index)\n",
    "  return new_lst\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.504700Z",
     "start_time": "2023-09-25T22:50:46.214788Z"
    }
   },
   "id": "a77cdafa80d758ea"
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this solution, we used a loop that iterates using the range of the len of our list. This generates the indices we need to iterate through. Note that we assume the lists are of equal size. We then access the element at the current index from each list using lst1[index] and lst2[index]. If they are equal we add the index to the new list. Finally, we return the results."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f6fdde1d98e00afc"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 5. Reversed List\n",
    "For the final challenge, we are going to test two lists to see if the second list is the reverse of the first list. There are a few different ways to approach this, but we are going to try a method that iterates through each of the values in one direction for the first list and compares them against the values starting from the other direction in the second list. Here is what you need to do:\n",
    "\n",
    "1. Define a function that has two input parameters for our lists\n",
    "2. Loop through every index in one of the lists from beginning to end\n",
    "3. Within the loop, compare the element in the first list at the current index against the element at the second list’s last index minus the current index. If there was a mismatch, then the lists aren’t reversed and we can return False\n",
    "4. If the loop ended successfully, then we know the lists are reversed and we can return True."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "e336a5d0f70ebf90"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named reversed_list() that takes two lists of the same size as parameters named lst1 and lst2.\n",
    "\n",
    "The function should return True if lst1 is the same as lst2 reversed. The function should return False otherwise.\n",
    "\n",
    "For example, reversed_list([1, 2, 3], [3, 2, 1]) should return True."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d782a69a93b1e5d4"
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def reversed_list(lst1, lst2):\n",
    "  if lst2[::-1] == lst1:\n",
    "    return True\n",
    "  return False\n",
    "\n",
    "#Uncomment the lines below when your function is done\n",
    "print(reversed_list([1, 2, 3], [3, 2, 1]))\n",
    "print(reversed_list([1, 5, 3], [3, 2, 1]))\n",
    "\n",
    "\n",
    "#Reverse list with for loop\n",
    "# ls = [1,2,3,4]\n",
    "# ls_rev = []\n",
    "# for i in ls:\n",
    "#   ls_rev.insert(0,i)\n",
    "# print(ls_rev)\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.506202Z",
     "start_time": "2023-09-25T22:50:46.231645Z"
    }
   },
   "id": "75ce9e1f6f3b333d"
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Altern solution\n",
    "def reversed_list(lst1, lst2):\n",
    "  lst2_rev = []\n",
    "  for i in lst2:\n",
    "    lst2_rev.insert(0, i)\n",
    "  #print(lst2_rev)\n",
    "  if lst2_rev == lst1:\n",
    "    return True\n",
    "  return False\n",
    "\n",
    "#Uncomment the lines below when your function is done\n",
    "print(reversed_list([1, 2, 3], [3, 2, 1]))\n",
    "print(reversed_list([1, 5, 3], [3, 2, 1]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.508778Z",
     "start_time": "2023-09-25T22:50:46.252739Z"
    }
   },
   "id": "dd7b561c08ecd314"
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "outputs": [],
   "source": [
    "# Here is one way to do it:\n",
    "\n",
    "def reversed_list(lst1, lst2):\n",
    "  for index in range(len(lst1)):\n",
    "    if lst1[index] != lst2[len(lst2) - 1 - index]:\n",
    "      return False\n",
    "  return True"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:50:46.520574Z",
     "start_time": "2023-09-25T22:50:46.271415Z"
    }
   },
   "id": "df5bd7baea3969ea"
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this code, we iterate through each of the indices for the entire length of either of the lists (since we assume the lengths are equal) and we perform a comparison on each of the elements. We get the element at the current index from our first list with lst1[index] and we test it against the last index of the second list minus the current index len(lst2) - 1 – index.\n",
    "\n",
    "That math is a little complicated — it helps to look at a concrete example. If we are given a list of 5 elements, the valid indices are 0 to 4. Because of this, the last index in the second list is len(lst2) - 1, or 5 - 1 = 4. Now in order to get the inverse of the position we are at in the first list, we subtract the index we are at from the end of the second list. So on the first pass, we’ll compare the element at position 0 to the element at position 5 - 1 - 0 = 4. On the next pass, we’ll compare the element at position 1 to the element at position 5 - 1 - 1 = 3, and so on.\n",
    "\n",
    "If any of the two elements are not equal then we know that the second list is not the reverse of the first list and we return False. If we made it to the end without a mismatch then we can return True since the second list is the reverse of the first. You could also try simplifying this code by using the python function reversed() or other methods that you will learn later on such as ‘slicing’."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "889a2cad1f57962d"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}