03_Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Python Code Challenges involving Lists"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "32129ffd9bc4db40"
  },
  {
   "cell_type": "markdown",
   "source": [
    "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": "ffd51e675ee12d89"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Function Syntax\n",
    "As a refresher, function syntax looks like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "4742da4ca3fc3ad7"
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [],
   "source": [
    "def some_function(some_input1, some_input2):\n",
    "  # … do something with the inputs …\n",
    "  return output"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.649967Z",
     "start_time": "2023-09-25T21:42:40.449258Z"
    }
   },
   "id": "532ebd0cc5d7ef1a"
  },
  {
   "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": "3bcd908ee6da3414"
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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:42:40.757436Z",
     "start_time": "2023-09-25T21:42:40.462975Z"
    }
   },
   "id": "a11ac2bced87caf4"
  },
  {
   "cell_type": "markdown",
   "source": [
    "And this would produce output like:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "92831f8cc89cdab"
  },
  {
   "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"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "8a8026e2d584d4db"
  },
  {
   "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.\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a66788df11d1baf2"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1. Append Size\n",
    "For the first code challenge, we are going to calculate the length of a list and then append the value to the end of the list. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept one parameter for our list\n",
    "2. Get the length of the list\n",
    "3. Append the length of the list to the end of the list\n",
    "4. Return the modified list"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b11add84721f3ba5"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function called append_size that has one parameter named my_list.\n",
    "\n",
    "The function should append the size of my_list (inclusive) to the end of my_list. The function should then return this new list.\n",
    "\n",
    "For example, if my_list was [23, 42, 108], the function should return [23, 42, 108, 3] because the size of my_list was originally 3."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d7396b253d729d2d"
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 42, 108, 3]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def append_size(my_list):\n",
    "  my_list.append(len(my_list))\n",
    "  return my_list\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(append_size([23, 42, 108]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.780123Z",
     "start_time": "2023-09-25T21:42:40.483401Z"
    }
   },
   "id": "b53ee88a381ab163"
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "outputs": [],
   "source": [
    "# Here is this solution:\n",
    "\n",
    "def append_size(my_list):\n",
    "  my_list.append(len(my_list))\n",
    "  return my_list"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.792109Z",
     "start_time": "2023-09-25T21:42:40.500300Z"
    }
   },
   "id": "ed603627414e682a"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can get the length and append it at the same time by nesting the function calls as shown in the solution. Afterward, we return the modified list."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "6673ea8f2c2bf4c1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 2. Append Sum\n",
    "Let’s create a function that calculates the sum of the last two elements of a list and appends it to the end. After doing so, it will repeat this process two more times and return the resulting list. You can choose to use a loop or manually use three lines. Here are the steps we need:\n",
    "\n",
    "1. Define the function to accept one parameter for our list of numbers\n",
    "2. Add the last and second-to-last elements from our list together\n",
    "3. Append the calculated value to the end of our list.\n",
    "4. Repeat steps 2 and 3 two more times\n",
    "5. Return the modified list\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3a07c52c71b5e637"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named append_sum that has one parameter — a list named named my_list.\n",
    "\n",
    "The function should add the last two elements of my_list together and append the result to my_list. It should do this process three times and then return my_list.\n",
    "\n",
    "For example, if my_list started as [1, 1, 2], the final result should be [1, 1, 2, 3, 5, 8]."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2fefb7c4c59f67f4"
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def append_sum(my_list):\n",
    "  counter = 0\n",
    "  while counter <= 2:\n",
    "    my_list.append(my_list[-1] + my_list [-2])\n",
    "    counter += 1\n",
    "  return my_list\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(append_sum([1, 1, 2]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.797385Z",
     "start_time": "2023-09-25T21:42:40.521309Z"
    }
   },
   "id": "a1c62735d7bc562a"
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "outputs": [],
   "source": [
    "# This is how we solved it:\n",
    "\n",
    "def append_sum(my_list):\n",
    "  my_list.append(my_list[-1] + my_list[-2])\n",
    "  my_list.append(my_list[-1] + my_list[-2])\n",
    "  my_list.append(my_list[-1] + my_list[-2])\n",
    "  return my_list\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.818538Z",
     "start_time": "2023-09-25T21:42:40.542019Z"
    }
   },
   "id": "86fa7df054e750d1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "In our solution, we add the numbers and append the result in one line. We add the last and second to last elements within the .append() function and we repeat this line two more times. Remember that when we use negative indices, it starts from the end of the list and goes towards the beginning of the list. You could also use a loop to solve this instead of repeating the lines."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "af976ba7d6a0204e"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 3. Larger List\n",
    "Let’s say we are working with two conveyor belts that contain items represented by a numerical ID. If one conveyor belt contains more items than the other, then we need to return the ID of the last item on that belt. In the case where they have the same number of items, return the last item from the first conveyor belt. In our code, we can represent the belts using lists. Here are the steps:\n",
    "\n",
    "1. Define the function to accept two parameters for our two lists of numbers\n",
    "2. Check if the length of the first list is greater than or equal to the length of the second list\n",
    "3. If true, then return the last element from the first list. Otherwise, return the last element from the second list\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b6123a315db14058"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named larger_list that has two parameters named my_list1 and my_list2.\n",
    "\n",
    "The function should return the last element of the list that contains more elements. If both lists are the same size, then return the last element of my_list1."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "83de43e6c562ebe3"
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def larger_list(my_list1, my_list2):\n",
    "  if len(my_list1) >= len(my_list2):\n",
    "    return my_list1[-1]\n",
    "  else:\n",
    "    return my_list2[-1]\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(larger_list([4, 10, 2, 5], [-10, 2, 5, 1]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.821124Z",
     "start_time": "2023-09-25T21:42:40.559069Z"
    }
   },
   "id": "61f564f071d54be2"
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "outputs": [],
   "source": [
    "# Here is how we did it:\n",
    "\n",
    "def larger_list(my_list1, my_list2):\n",
    "  if len(my_list1) >= len(my_list2):\n",
    "    return my_list1[-1]\n",
    "  else:\n",
    "    return my_list2[-1]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.823407Z",
     "start_time": "2023-09-25T21:42:40.571912Z"
    }
   },
   "id": "9e57c689962fd108"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We start by comparing the lengths of each of the lists using the len() function. This determines whether to return the last element of the first list or the second list. Notice that we use >=. This way, we know what to do if the lists have an equal length.\n",
    "\n",
    "In order to get the last element, we get the element at the -1 index. The negative index starts at the end of the list and works towards the start of the list."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "277247869ed3572a"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 4. More Than N\n",
    "Our factory produces a variety of different flavored snacks and we want to check the number of instances of a certain type. We have a conveyor belt full of different types of snacks represented by different numbers. Our function will accept a list of numbers (representing the type of snack), a number for the second parameter (the type of snack we are looking for), and another number as the third parameter (the maximum number of that type of snack on the conveyor belt). The function will return True if the snack we are searching for appears more times than we provided as our third parameter. These are the steps we need:\n",
    "\n",
    "1. Define the function to accept three parameters, a list of numbers, a number to look for, and a number for the number of instances\n",
    "2. Count the number of occurrences of item (the second parameter) in my_list (the first parameter)\n",
    "3. If the number of occurrences is greater than n (the third parameter), return True. Otherwise, return False"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d880b97b5a415105"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function named more_than_n that has three parameters named my_list, item, and n.\n",
    "\n",
    "The function should return True if item appears in the list more than n times. The function should return False otherwise."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "46c754c9ae69a78a"
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def more_than_n(my_list, item, n):\n",
    "  if my_list.count(item) > n:\n",
    "    return True\n",
    "  else:\n",
    "    return False\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(more_than_n([2, 4, 6, 2, 3, 2, 1, 2], 2, 3))\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.828386Z",
     "start_time": "2023-09-25T21:42:40.585991Z"
    }
   },
   "id": "60c8df8aebcc4c8a"
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "outputs": [],
   "source": [
    "# Here is one way to do it:\n",
    "\n",
    "def more_than_n(my_list, item, n):\n",
    "  if my_list.count(item) > n:\n",
    "    return True\n",
    "  else:\n",
    "    return False"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.841974Z",
     "start_time": "2023-09-25T21:42:40.601434Z"
    }
   },
   "id": "a9a217d76985ea41"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We use the count() function to count the number of times item appears in my_list. You could also do this manually by looping through my_list and incrementing a variable every time you see item. We then compare the result to n."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ff926c62325f6883"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 5. Combine Sort\n",
    "Finally, let’s create a function that combines two different lists together and then sorts them. To do this we can combine the lists with an operation and then sort using a function call. Here are the steps we need to use:\n",
    "\n",
    "1. Define the function to accept two parameters, one for each list.\n",
    "2. Combine the two lists together\n",
    "3. Sort the result\n",
    "4. Return the sorted and combined list"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b2baac612867ddcd"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named combine_sort that has two parameters named my_list1 and my_list2.\n",
    "\n",
    "The function should combine these two lists into one new list and sort the result. Return the new sorted list."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2c7a84077e3e07f9"
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, 2, 2, 4, 5, 5, 10, 10]\n"
     ]
    }
   ],
   "source": [
    "#Write your function here\n",
    "def combine_sort(my_list1, my_list2):\n",
    "  new_list = my_list1 + my_list2\n",
    "  return sorted(new_list)\n",
    "\n",
    "#Uncomment the line below when your function is done\n",
    "print(combine_sort([4, 10, 2, 5], [-10, 2, 5, 10]))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.842552Z",
     "start_time": "2023-09-25T21:42:40.610980Z"
    }
   },
   "id": "6911c21ef152bed5"
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [],
   "source": [
    "# Here is how we did it:\n",
    "\n",
    "def combine_sort(my_list1, my_list2):\n",
    "  unsorted = my_list1 + my_list2\n",
    "  sortedList = sorted(unsorted)\n",
    "  return sortedList"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T21:42:40.842810Z",
     "start_time": "2023-09-25T21:42:40.629407Z"
    }
   },
   "id": "e193c3e9d327ad6"
  },
  {
   "cell_type": "markdown",
   "source": [
    "We start by combining the two lists together using + in order to get a new list. Next, in order to sort them, we use the sorted() function which returns a new sorted version of the list."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "6a6848b30ea4dc6"
  }
 ],
 "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
}