04_Lists(Advanced).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Python Code Challenges: Lists (Advanced)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "4e29219d2c891f36"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Difficult Python Code Challenges involving Lists\n",
    "\n",
    "This article will help you review Python functions by providing some code challenges involving lists.\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": "3620a830634d81b0"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Function Syntax\n",
    "As a refresher, function syntax looks like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "4c601dc3078d0305"
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "outputs": [],
   "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-25T21:54:24.770892Z",
     "start_time": "2023-09-25T21:54:24.440532Z"
    }
   },
   "id": "a8f085b70f5870ee"
  },
  {
   "cell_type": "markdown",
   "source": [
    "For example, a function that returns the sum of the first and last elements of a given list might look like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "bc3265a098a1db1c"
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "outputs": [],
   "source": [
    "def first_plus_last(my_list):\n",
    "  return my_list[0] + my_list[-1]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.771628Z",
     "start_time": "2023-09-25T21:54:24.457505Z"
    }
   },
   "id": "aba0091bd868a8f9"
  },
  {
   "cell_type": "markdown",
   "source": [
    "And this would produce output like:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c3e97d0e1b5ebc1d"
  },
  {
   "cell_type": "raw",
   "source": [
    ">>> first_plus_last([1, 2, 3, 4])\n",
    "5\n",
    ">>> first_plus_last([8, 2, 5, -8])\n",
    "0\n",
    ">>> first_plus_last([-10, 2, 3, -4])\n",
    "-14\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "52cb30622dbab7e9"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Challenges\n",
    "We’ve included 5 list challenges below. Try to answer all of them and polish up your problem-solving skills and your list expertise!"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "eb4a7ebcd9824dcd"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1. Every Three Numbers\n",
    "Let’s start our challenging problems with a function that creates a list of numbers up to 100 in increments of 3 starting from a number that is passed to the function as an input parameter. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept one parameter for our starting number\n",
    "2. Calculate the numbers between the starting number and 100 while incrementing by 3\n",
    "3. Store the numbers in a list\n",
    "4. Return the list"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "85434ff331ba0f09"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function called every_three_nums that has one parameter named start.\n",
    "\n",
    "The function should return a list of every third number between start and 100 (inclusive). For example, every_three_nums(91) should return the list [91, 94, 97, 100]. If start is greater than 100, the function should return an empty list."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "94156c5b4a0e5f6a"
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[91, 94, 97, 100]\n",
      "[81, 84, 87, 90, 93, 96, 99]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def every_three_nums(start_n):\n",
    "  list_n = []\n",
    "  counter = start_n\n",
    "  while counter <= 100:\n",
    "    list_n.append(counter)\n",
    "    counter += 3\n",
    "  return list_n\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(every_three_nums(91))\n",
    "\n",
    "\n",
    "# Applying range func\n",
    "def every_3(start):\n",
    "  return list(range(start, 100, 3))\n",
    "print(every_3(81))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.799947Z",
     "start_time": "2023-09-25T21:54:24.479607Z"
    }
   },
   "id": "bec836c34501d31a"
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "outputs": [],
   "source": [
    "# Here is what we did:\n",
    "\n",
    "def every_three_nums(start):\n",
    "  return list(range(start, 101, 3))\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.819226Z",
     "start_time": "2023-09-25T21:54:24.492403Z"
    }
   },
   "id": "8dcf7052ad98bf36"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can write the body of this function in one line by nesting the range() function inside of the list() function. The range function accepts the starting number, the ending number (exclusive), and the amount to increment by."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "13c0ede4b1de6421"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 2. Remove Middle\n",
    "Our next function will remove all elements from a list with an index within a certain range. The function will accept a list, a starting index, and an ending index. All elements with an index between the starting and ending index should be removed from the list. Here are the steps:\n",
    "\n",
    "1. Define the function to accept three parameters: the list, the starting index, and the ending index\n",
    "2. Get all elements before the starting index\n",
    "3. Get all elements after the ending index\n",
    "4. Combine the two partial lists into the result\n",
    "5. Return the result"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c1e50a1ffae60270"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named remove_middle which has three parameters named my_list, start, and end.\n",
    "\n",
    "The function should return a list where all elements in my_list with an index between start and end (inclusive) have been removed.\n",
    "\n",
    "For example, the following code should return [4, 23, 42] because elements at indices 1, 2, and 3 have been removed:\n",
    "\n",
    " remove_middle([4, 8 , 15, 16, 23, 42], 1, 3)\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "838cc7605f39abe6"
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 23, 42]\n",
      "[4, 23, 42]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def remove_middle(my_list, start, end):\n",
    "  remove_ls = list(range(start, end+1))\n",
    "  for i in remove_ls:\n",
    "    my_list.pop(start)\n",
    "  return my_list\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(remove_middle([4, 8, 15, 16, 23, 42], 1, 3))\n",
    "\n",
    "\n",
    "# Applying subset method\n",
    "def remove_mid(my_list, start, end):\n",
    "  return my_list[:start] + my_list[end+1:]\n",
    "\n",
    "print(remove_mid([4, 8, 15, 16, 23, 42], 1, 3))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.834529Z",
     "start_time": "2023-09-25T21:54:24.520784Z"
    }
   },
   "id": "324aacdda45ef2ab"
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "outputs": [],
   "source": [
    "# Here is what we did:\n",
    "\n",
    "def remove_middle(my_list, start, end):\n",
    "  return my_list[:start] + my_list[end+1:]\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.860689Z",
     "start_time": "2023-09-25T21:54:24.536530Z"
    }
   },
   "id": "a1d9cb7a126eef12"
  },
  {
   "cell_type": "markdown",
   "source": [
    "This can be solved using one line of code if you combine and slice the lists at the same time. Slicing allows us to get the segments of the list before and after the index range and the operation + allows us to combine them together."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "36211fc845e01183"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 3. More Frequent Item\n",
    "Let’s go back to our factory example. We have a conveyor belt of items where each item is represented by a different number. We want to know, out of two items, which one shows up more on our belt. To solve this, we can use a function with three parameters. One parameter for the list of items, another for the first item we are comparing, and another for the second item. Here are the steps:\n",
    "\n",
    "1. Define the function to accept three parameters: the list, the first item, and the second item\n",
    "2. Count the number of times item1 shows up in our list\n",
    "3. Count the number of times item2 shows up in our list\n",
    "4. Return the item that appears more frequently in my_list — if both items show up the same number of times, return item1"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "816dfd686c94c9b3"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named more_frequent_item that has three parameters named my_list, item1, and item2.\n",
    "\n",
    "Return either item1 or item2 depending on which item appears more often in my_list.\n",
    "\n",
    "If the two items appear the same number of times, return item1."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "4dd9cab5a0413dae"
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "outputs": [],
   "source": [
    "# Here is this solution:\n",
    "\n",
    "def more_frequent_item(my_list, item1, item2):\n",
    "  if my_list.count(item1) >= my_list.count(item2):\n",
    "    return item1\n",
    "  else:\n",
    "    return item2\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.869547Z",
     "start_time": "2023-09-25T21:54:24.557529Z"
    }
   },
   "id": "411d073cff37c63d"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We use the count() function to find the number of occurrences for each item. We then compare the counts against each other to find the item which appears the most in the list. The item with the most appearances is returned by the function."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a58e4994a3e4e7f"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 4. Double Index\n",
    "Our next function will double a value at a given position. We will provide a list and an index to double. This will create a new list by replacing the value at the index provided with double the original value. If the index is invalid then we should return the original list. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept two parameters, one for the list and another for the index of the value we are going to double\n",
    "2. Test if the index is invalid. If it’s invalid then return the original list\n",
    "3. If the index is valid then get all values up to the index and store it as a new list\n",
    "4. Append the value at the index times 2 to the new list\n",
    "5. Add the rest of the list from the index onto the new list\n",
    "6. Return the new list"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "315e6bbf44234e6c"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named double_index that has two parameters: a list named my_list and a single number named index.\n",
    "\n",
    "The function should return a new list where all elements are the same as in my_list except for the element at index. The element at index should be double the value of the element at index of the original my_list.\n",
    "\n",
    "If index is not a valid index, the function should return the original list.\n",
    "\n",
    "For example, the following code should return [1,2,6,4] because the element at index 2 has been doubled:\n",
    "\n",
    "double_index([1, 2, 3, 4], 2)\n",
    "\n",
    "After writing your function, un-comment the call to the function that we’ve provided for you to test your results."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b163923161d362ca"
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 8, -20, 12]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def double_index(my_list, index):\n",
    "  if index > len(my_list):\n",
    "    return my_list\n",
    "  else:\n",
    "    return [i if my_list.index(i) != index else i*2 for i in my_list ]\n",
    "\n",
    "# #Uncomment the line below when your function is done\n",
    "print(double_index([3, 8, -10, 12], 2))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.870210Z",
     "start_time": "2023-09-25T21:54:24.580534Z"
    }
   },
   "id": "bdebdb4a052b7c15"
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "outputs": [],
   "source": [
    "# Here is one way to do it:\n",
    "\n",
    "def double_index(my_list, index):\n",
    "  # Checks to see if index is too big\n",
    "  if index >= len(my_list):\n",
    "    return my_list\n",
    "  else:\n",
    "    # Gets the original list up to index\n",
    "    my_new_list = my_list[0:index]\n",
    " # Adds double the value at index to the new list \n",
    "  my_new_list.append(my_list[index]*2)\n",
    "  #  Adds the rest of the original list\n",
    "  my_new_list = my_new_list + my_list[index+1:]\n",
    "  return my_new_list"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.870695Z",
     "start_time": "2023-09-25T21:54:24.596830Z"
    }
   },
   "id": "ce436302906c3e08"
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note that this solution is careful not to modify the original input list. If we were to simply use my_list[index] = my_list[index] * 2 then the list that was passed into the function would be modified outside of the function as well. Creating a new list and writing the values to it prevents this from happening. We use slicing to extract the values before and after the index and we append the modified value at the index to our new list."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2dc5057efa249af0"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 5. Middle Item\n",
    "For the final code challenge, we are going to create a function that finds the middle item from a list of values. This will be different depending on whether there are an odd or even number of values. In the case of an odd number of elements, we want this function to return the exact middle value. If there is an even number of elements, it returns the average of the middle two elements. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept one parameter for our list of numbers\n",
    "2. Determine if the length of the list is even or odd\n",
    "3. If the length is even, then return the average of the middle two numbers\n",
    "4. If the length is odd, then return the middle number"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "97f7ccd388124298"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function called middle_element that has one parameter named my_list.\n",
    "\n",
    "If there are an odd number of elements in my_list, the function should return the middle element. If there are an even number of elements, the function should return the average of the middle two elements."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "962a3f704759deb2"
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-7.0\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def middle_element(my_list):\n",
    "  if len(my_list) % 2 != 0:\n",
    "    return my_list[int(len(my_list)/2)]\n",
    "  else:\n",
    "    sum = my_list[int(len(my_list)/2)] + my_list[(int(len(my_list)/2)-1)]\n",
    "    return sum / 2\n",
    "  \n",
    "#Uncomment the line below when your function is done\n",
    "print(middle_element([5, 2, -10, -4, 4, 5]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.894958Z",
     "start_time": "2023-09-25T21:54:24.631225Z"
    }
   },
   "id": "4b7bd752e65bcc6"
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "outputs": [],
   "source": [
    "# Here is how we solved it:\n",
    "\n",
    "def middle_element(my_list):\n",
    "  if len(my_list) % 2 == 0:\n",
    "    sum = my_list[int(len(my_list)/2)] + my_list[int(len(my_list)/2) - 1]\n",
    "    return sum / 2\n",
    "  else:\n",
    "    return my_list[int(len(my_list)/2)]\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:54:24.895260Z",
     "start_time": "2023-09-25T21:54:24.670995Z"
    }
   },
   "id": "b11001e901253b37"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We used modulus to determine if the list had an even or odd number of elements. After determining this, for an odd number of elements, we calculate the middle index and return the middle element from the list. For an even number of elements, we calculate the index of the element close to the middle and the other element close to the middle (by subtracting 1 from the middle calculation). We get the values at those indices and calculate the average.\n",
    "\n",
    "Note that the math to find the middle index is a bit tricky. In some cases, when we divide by 2, we would get a double. For example, if our list had 3 items in it, then 3/2 would give us 1.5. The middle index should be 1, so in order to go from 1.5 to 1, we cast 1.5 as an int. In total, this is int(len(my_list)/2)."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ec8c61e71c40a458"
  }
 ],
 "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
}