[10_Questions]_QUIZ_List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "hazardous-advice",
   "metadata": {},
   "source": [
    "## [10 Questions] QUIZ - List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afraid-carbon",
   "metadata": {},
   "source": [
    "**Q 1:**\n",
    "\n",
    "Define a function named **sum_of_list**.\n",
    "\n",
    "The parameter will be a list.\n",
    "\n",
    "The function will add all the elements in the list and return the summation result.\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "nums = [1, 2, 3, 4, 5] \n",
    "sum_of_list(nums) -> 15\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "another-terminology",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "# S 1:\n",
    "def sum_of_list(nums):\n",
    "    sum=0\n",
    "    for i in range(len(nums)):\n",
    "        \n",
    "        sum +=nums[i]\n",
    "    return sum\n",
    "\n",
    "\n",
    "nums = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "summation = sum_of_list(nums)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "backed-night",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4, 5] \n",
    "\n",
    "summation = sum_of_list(nums)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "complete-intro",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "600\n"
     ]
    }
   ],
   "source": [
    "nums = [10, 20, 30, 40, 500] \n",
    "\n",
    "summation = sum_of_list(nums)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "innovative-highland",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "charming-weather",
   "metadata": {},
   "source": [
    "**Q 2:**\n",
    "\n",
    "Define a function named **two_levels_sum**.\n",
    "\n",
    "The parameter will be a list of two levels (nested list).\n",
    "\n",
    "The function will add all the elements including the nested lists and return the summation result.\n",
    "\n",
    "**Hints:**\n",
    "* isdigit()\n",
    "* type()\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "a_list = [[5, 8], [1, 4, 7], [10], 3]\n",
    "summation = two_levels_sum(a_list)  -> 38\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "technological-confidence",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 2:\n",
    "\n",
    "def two_levels_sum(a_list):\n",
    "    # set the finction variable\n",
    "    total = 0\n",
    "    # Loop through the list checking for other list\n",
    "    for n in a_list:\n",
    "         \n",
    "        if type(n) == list: \n",
    "           \n",
    "    # If a list is found, get the sum and add to total\n",
    "                total += sum(n)\n",
    "        else:\n",
    "            total += n \n",
    "    # else add the num to total\n",
    "    # return the total\n",
    "    return total\n",
    " \n",
    "\n",
    "\n",
    "a_list = [[5, 8], [1, 4, 7], [10], 3]\n",
    "two_levels_sum(a_list)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "underlying-testing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38\n"
     ]
    }
   ],
   "source": [
    "a_list = [[5, 8], [1, 4, 7], [10], 3]\n",
    "\n",
    "summation = two_levels_sum(a_list)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "useful-richmond",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "a_list = [[5, 8], [1, 4, 7], [10], 3, 2]\n",
    "\n",
    "summation = two_levels_sum(a_list)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "qualified-composition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "a_list = [[1, 2, 3], [1, 2], 3, [10, 20]]\n",
    "\n",
    "summation = two_levels_sum(a_list)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "metallic-administrator",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "opponent-input",
   "metadata": {},
   "source": [
    "**Q 3:**\n",
    "\n",
    "The function you defined in Q2 can only add lists of two levels.\n",
    "\n",
    "Now we will convert this into a generic function that can take any levels of nested lists.\n",
    "\n",
    "Function name will be **nested_sum**.\n",
    "\n",
    "It will add all the elements of all lists including nested lists and return the overall summation result.\n",
    "\n",
    "\n",
    "**Hints:**\n",
    "* Recursive\n",
    "* isdigit()\n",
    "* type()\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "a_list = [[5, 8], [1, 4, 7, [8, 2]], [10, [-1, 2]], 3]\n",
    "summation = nested_sum(a_list)  -> 49\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "beneficial-bradley",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49\n"
     ]
    }
   ],
   "source": [
    "# S 3:\n",
    "a_list = [[5, 8], [1, 4, 7, [8, 2]], [10, [-1, 2]], 3]\n",
    "def nested_sum(a_list):\n",
    "    # set the finction variable\n",
    "    total = 0\n",
    "    # Loop through the list checking for other list\n",
    "    for num in a_list:\n",
    "        if type(num) == list: \n",
    "    # If a list is found, get the sum and add to total\n",
    "            total +=nested_sum(num)\n",
    "        else:\n",
    "            total += num # else add the num to total\n",
    "    return total # return the total\n",
    "\n",
    "summation = nested_sum(a_list)\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "injured-girlfriend",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49\n"
     ]
    }
   ],
   "source": [
    "a_list = [[5, 8], [1, 4, 7, [8, 2]], [10, [-1, 2]], 3]\n",
    "\n",
    "summation = nested_sum(a_list)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "boxed-fundamentals",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57\n"
     ]
    }
   ],
   "source": [
    "a_list = [[-5, [9, 1, [6, 2]], 8], [1, 4, 7, [8, 2]], [10, [-1, 2]], 3]\n",
    "\n",
    "summation = nested_sum(a_list)\n",
    "\n",
    "print(summation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nearby-education",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "endangered-particle",
   "metadata": {},
   "source": [
    "**Q 4:**\n",
    "\n",
    "Define a function named **squares**.\n",
    "\n",
    "It will calculate the square of each item in the list and append it to a new list.\n",
    "\n",
    "It will return the new list of squares.\n",
    "\n",
    "<pre>\n",
    "numbers = [1,2,3,4,5]\n",
    "squares(numbers)  ->   [1, 4, 9, 16, 25]\n",
    "\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "future-forge",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# S 4:\n",
    "def sqaures(numbers):\n",
    "    square = []\n",
    "    for i in numbers:\n",
    "        square.append(i**2) \n",
    "    return(square)\n",
    "\n",
    "numbers = [1,2,3,4,5]\n",
    "\n",
    "result = sqaures(numbers)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "rising-warehouse",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "\n",
    "result = sqaures(numbers)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "conceptual-adelaide",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "level-mongolia",
   "metadata": {},
   "source": [
    "**Q 5:**\n",
    "\n",
    "Define a function named **sum_of_squares**.\n",
    "\n",
    "It will calculate the squares of items first and will add them to create items of a new list.\n",
    "\n",
    "Each item in the new list will be the sum of items from the old list starting from index 0 up to the item's index.\n",
    "\n",
    "For example in the new list the item in index 4 is going to be the sum of squares of items at indices 0-1-2-3-4 of parameter list.\n",
    "\n",
    "And it will retun the new list.\n",
    "\n",
    "**Hints:**\n",
    "* use sum_of_list funtion you defined in Q1\n",
    "\n",
    "<pre>\n",
    "a_list = [1,2,3,4,5]\n",
    "result = sum_of_squares(a_list)\n",
    "print(result)\n",
    "\n",
    "Expected Output:\n",
    "[1, 5, 15, 37, 83]\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "executed-manitoba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 15, 37, 94]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 5:\n",
    "def sum_of_squares(a_list):\n",
    "    \n",
    "    new_list = []\n",
    "    \n",
    "    for element in a_list:\n",
    "        \n",
    "        # get total of new list\n",
    "        new_list_total = sum_of_list(new_list)\n",
    "        \n",
    "        # get square of the current element and add it new_total\n",
    "        new_total = new_list_total + element**2\n",
    "        \n",
    "        # append new total to new_list\n",
    "        new_list.append(new_total)\n",
    "        \n",
    "    return new_list\n",
    "\n",
    "a_list = [1,2,3,4,6]\n",
    "sum_of_squares(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9e660e7-fb7b-4466-bebf-8062b2bbc063",
   "metadata": {},
   "outputs": [],
   "source": [
    "Expected Output:\n",
    "[1, 5, 15, 37, 83]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "lovely-arizona",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 15]\n"
     ]
    }
   ],
   "source": [
    "a_list = [1,2,3]\n",
    "\n",
    "result = sum_of_squares(a_list)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "educational-intervention",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 15, 37, 83]\n"
     ]
    }
   ],
   "source": [
    "a_list = [1,2,3,4,5]\n",
    "\n",
    "result = sum_of_squares(a_list)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "operating-yukon",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "express-michael",
   "metadata": {},
   "source": [
    "**Q 6:**\n",
    "\n",
    "Define a function that return the difference bwtween items at odd indices (1,3,5...) and items at even indices (0,2,4...).\n",
    "\n",
    "The function name will be **odd_even_difference**.\n",
    "\n",
    "**Hints:**\n",
    "* index starts from zero\n",
    "* use lists and indices only\n",
    "* do not use loop\n",
    "* use sum_of_list funtion you defined in Q1\n",
    "\n",
    "<pre>\n",
    "a_list = [1,2,3,4,5,6]\n",
    "diff = odd_even_difference(a_list)\n",
    "print(diff)\n",
    "\n",
    "Expected Output:\n",
    "3\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "confused-cream",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 6:\n",
    "def odd_even_difference(p_list):\n",
    "    \n",
    "    # odd elements\n",
    "    odds = p_list[1::2]\n",
    "    \n",
    "    # odd summation\n",
    "    odds_sum = sum_of_list(odds)\n",
    "    \n",
    "    # even elements\n",
    "    evens = p_list[::2]\n",
    "    \n",
    "    # event summation\n",
    "    evens_sum = sum_of_list(evens)\n",
    "\n",
    "    # get difference\n",
    "    diff = odds_sum - evens_sum\n",
    "    \n",
    "    return diff\n",
    "\n",
    "p_list = [2,4,3,4,5,6,7]\n",
    "odd_even_difference(p_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "international-wheel",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a_list = [1,2,3,4,5,6]\n",
    "\n",
    "diff = odd_even_difference(a_list)\n",
    "\n",
    "print(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "streaming-settle",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "a_list = [10,10,30,30,500,600]\n",
    "\n",
    "diff = odd_even_difference(a_list)\n",
    "\n",
    "print(diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incident-occupation",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "multiple-rescue",
   "metadata": {},
   "source": [
    "**Q 7:**\n",
    "\n",
    "Define a function that crop the list parameter.\n",
    "\n",
    "The function will be **crop_the_list**.\n",
    "\n",
    "Cropping means remove the first and the last elements from the list.\n",
    "\n",
    "The function will **mutate the originial list parameter** namely it will modify the list in-place.\n",
    "\n",
    "It will not return any value.\n",
    "\n",
    "Test the function and prove it mutates the list which you pass as argument.\n",
    "\n",
    "<pre>    \n",
    "nums = [1,2,3,4,5,6,7]\n",
    "print('the list before passing as parameter:', nums)\n",
    "crop_the_list(nums)\n",
    "print('the list before passing as parameter:', nums)\n",
    "\n",
    "Expected Output:\n",
    "the list before passing as parameter: [1, 2, 3, 4, 5, 6, 7]\n",
    "the list before passing as parameter: [2, 3, 4, 5, 6]\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "uniform-compression",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before passing to function: [1, 2, 3, 4, 5, 6, 7]\n",
      "before passing to function: [2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# S 7:\n",
    "nums = [1,2,3,4,5,6,7]\n",
    "print(\"before passing to function:\", nums)\n",
    "\n",
    "\n",
    "def crop_the_list(nums):\n",
    "    # mutation\n",
    "    del nums[0]\n",
    "    del nums[-1]\n",
    "    \n",
    "crop_the_list(nums)\n",
    "\n",
    "\n",
    "print(\"before passing to function:\", nums)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "powered-sarah",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the list before passing as parameter: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "the list before passing as parameter: [1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "nums = [0,1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "print('the list before passing as parameter:', nums)\n",
    "\n",
    "crop_the_list(nums)\n",
    "\n",
    "print('the list before passing as parameter:', nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fancy-nelson",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "julian-killer",
   "metadata": {},
   "source": [
    "**Q 8:**\n",
    "\n",
    "Define a function named **sort_the_list**.\n",
    "\n",
    "It will take a list and sort type (is_reverse) as parameters.\n",
    "\n",
    "**is_reverse** will be boolean and it will decide if the sort will be ascending or descending. It's default value will be False.\n",
    "* if is_reverse is True -> sort will be descending\n",
    "* if is_reverse is False -> sort will be ascending\n",
    "\n",
    "The function will return the new sorted list.\n",
    "\n",
    "**Hints:**\n",
    "* sorted()\n",
    "* no loops\n",
    "* do not mutate the original list\n",
    "\n",
    "<pre>\n",
    "a = [12, 4, 2, 1, 6, 3, 45]\n",
    "print('a:', a)\n",
    "sorted_a = sort_the_list(a, False)\n",
    "print('sorted - ascending', sorted_a)\n",
    "sorted_a = sort_the_list(a, True)\n",
    "print('sorted - descending', sorted_a)\n",
    "print('a after sort_the_list function call:', a)\n",
    "\n",
    "Expected Output:\n",
    "a: [12, 4, 2, 1, 6, 3, 45]\n",
    "sorted - ascending [1, 2, 3, 4, 6, 12, 45]\n",
    "sorted - descending [45, 12, 6, 4, 3, 2, 1]\n",
    "a after sort_the_list function call: [12, 4, 2, 1, 6, 3, 45]\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "chinese-offer",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 8:\n",
    "\n",
    "# First Way\n",
    "def sort_the_list(a,is_reverse ):\n",
    "    if is_reverse is False:\n",
    "        return(sorted(a,reverse=False))\n",
    "    elif is_reverse is True:\n",
    "        return (sorted(a,reverse=True))\n",
    "    else:\n",
    "        return a\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "veterinary-dealer",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [12, 4, 2, 1, 6, 3, 45]\n",
      "sorted - ascending [1, 2, 3, 4, 6, 12, 45]\n",
      "sorted - descending [45, 12, 6, 4, 3, 2, 1]\n",
      "a after sort_the_list function call: [12, 4, 2, 1, 6, 3, 45]\n"
     ]
    }
   ],
   "source": [
    "a = [12, 4, 2, 1, 6, 3, 45]\n",
    "print('a:', a)\n",
    "\n",
    "sorted_a = sort_the_list(a, False)\n",
    "print('sorted - ascending', sorted_a)\n",
    "\n",
    "sorted_a = sort_the_list(a, True)\n",
    "print('sorted - descending', sorted_a)\n",
    "\n",
    "print('a after sort_the_list function call:', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "stuffed-director",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [23, 243, 1522, 101, 66, 3, 45, 1, 73]\n",
      "sorted - ascending [1, 3, 23, 45, 66, 73, 101, 243, 1522]\n",
      "sorted - descending [1522, 243, 101, 73, 66, 45, 23, 3, 1]\n",
      "a after sort_the_list function call: [23, 243, 1522, 101, 66, 3, 45, 1, 73]\n"
     ]
    }
   ],
   "source": [
    "a = [23, 243, 1522, 101, 66, 3, 45, 1,73]\n",
    "print('a:', a)\n",
    "\n",
    "sorted_a = sort_the_list(a, False)\n",
    "print('sorted - ascending', sorted_a)\n",
    "\n",
    "sorted_a = sort_the_list(a, True)\n",
    "print('sorted - descending', sorted_a)\n",
    "\n",
    "print('a after sort_the_list function call:', a)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "exposed-agency",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [123, 43, 122, 10, 66, 73, 45]\n",
      "sorted - ascending [10, 43, 45, 66, 73, 122, 123]\n",
      "sorted - descending [123, 122, 73, 66, 45, 43, 10]\n",
      "a after sort_the_list function call: [123, 43, 122, 10, 66, 73, 45]\n"
     ]
    }
   ],
   "source": [
    "a = [123, 43, 122, 10, 66, 73, 45]\n",
    "print('a:', a)\n",
    "\n",
    "sorted_a = sort_the_list(a, False)\n",
    "print('sorted - ascending', sorted_a)\n",
    "\n",
    "sorted_a = sort_the_list(a, True)\n",
    "print('sorted - descending', sorted_a)\n",
    "\n",
    "print('a after sort_the_list function call:', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fuzzy-agreement",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "optimum-mentor",
   "metadata": {},
   "source": [
    "**Q 9:**\n",
    "\n",
    "The Consecutive Numbers in Math are actually Lists in Python.\n",
    "\n",
    "**Gauss' Method for Summing Consecutive Numbers** is a method that gives you the summation of numbers.\n",
    "\n",
    "And that's how Gauss' Method works:\n",
    "* First it sorts the list in ascending order\n",
    "* Then sorts the list in descending order\n",
    "* Adds the items in both lists at the same index\n",
    "* Divides the overall summation by 2 (because each element is written 2 times)\n",
    "\n",
    "Example: Sum of all integers from 1 to 10.\n",
    "\n",
    "<pre>\n",
    "1   2   3   4   5   6   7   8   9   10\n",
    "10  9   8   7   6   5   4   3   2   1\n",
    "+   +   +   +   +   +   +   +   +   +\n",
    "11  11  11  11  11  11  11  11  11  11    (pairwise sum)\n",
    "\n",
    "Summation = 11 * 10\n",
    "Result = Summation / 2\n",
    "</pre>\n",
    "\n",
    "In this question you are going to sum all the number starting from 2 up to 100 with step size 3.\n",
    "\n",
    "You should use Gauss' Method in Python to calculate the overral sum.\n",
    "\n",
    "The function name will be **gauss** and the parameters and default values will be:\n",
    "* start -> 1\n",
    "* end -> 100\n",
    "* step_size -> 2\n",
    "\n",
    "**Hints:**\n",
    "* use range() to create the list\n",
    "\n",
    "<pre>\n",
    "conseq_sum = gauss(2, 100, 3)\n",
    "conseq_sum\n",
    "\n",
    "Expected Output:\n",
    "1650.0\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "printable-publicity",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1650.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 9:\n",
    "\n",
    "def gauss(n,p,r): \n",
    "    total = 0.0 \n",
    "    for i in range(n,p,r): \n",
    "        total +=i\n",
    "    return (total) \n",
    "conseq_sum = gauss(2, 100, 3)\n",
    "conseq_sum      \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "pregnant-child",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conseq_sum = gauss(1, 10, 1)\n",
    "conseq_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "premier-position",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1650.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conseq_sum = gauss(2, 100, 3)\n",
    "conseq_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "initial-prompt",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 9:\n",
    "\n",
    "# Second Way\n",
    "# True Gaussian Way\n",
    "\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "incorporate-hampshire",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = list(range(1, 10, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "suspended-discovery",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0] + my_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "timely-clock",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[1] + my_list[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "finite-ocean",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[2] + my_list[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "offensive-weight",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45.0"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def true_gaussian(n,p,r): \n",
    "    total = 0.0 \n",
    "    for i in range(n,p,r): \n",
    "        total +=i\n",
    "    return (total) \n",
    "conseq_sum = true_gaussian(1, 10, 1)\n",
    "conseq_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "surface-flashing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1650.0"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conseq_sum = true_gaussian(2, 100, 3)\n",
    "conseq_sum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "representative-mathematics",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "protected-mystery",
   "metadata": {},
   "source": [
    "**Q 10:**\n",
    "\n",
    "Define a function to check if a given list is sorted in descending order or not.\n",
    "\n",
    "The function name will be **is_it_sorted_descending**.\n",
    "\n",
    "It will return True if the list items are in descending order, False otherwise.\n",
    "\n",
    "**Hints:**\n",
    "* solve this questions with 4 different ways :)\n",
    "\n",
    "<pre>\n",
    "a_list = [2, 3, 4, 7]\n",
    "is_it_sorted_descending(a_list)\n",
    "Expected Output: False\n",
    "\n",
    "a_list = [7, 7, 4, 3, 2, 1, 1]\n",
    "is_it_sorted_descending(a_list)\n",
    "Expected Output: True\n",
    "\n",
    "a_list = ['a', 'b', 'c', 'd']\n",
    "is_it_sorted_descending(a_list)\n",
    "Expected Output: False\n",
    "\n",
    "a_list = ['d', 'c', 'b', 'a']\n",
    "is_it_sorted_descending(a_list)\n",
    "Expected Output: True\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "fiscal-transcript",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 10:\n",
    "\n",
    "# Way 1:\n",
    "# Nested Loops\n",
    "# Least Pythonic\n",
    "\n",
    "def is_it_sorted_descending(a_list):\n",
    "    for n in range(len(a_list) + 1):\n",
    "        if a_list[n] > a_list[n+1]:\n",
    "            return True\n",
    "        else:\n",
    "            if a_list[n] < a_list[n+1]:\n",
    "                return False\n",
    "a_list = [2, 3, 4, 7]\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "smaller-deficit",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [2, 7, 3, 4]\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "narrative-garden",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [2, 3, 4, 7]\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "liberal-handbook",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [7, 4, 3, 2]\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "mediterranean-province",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [7, 7, 4, 3, 2, 1, 1]\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "primary-nylon",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = ['a', 'd', 'b', 'c']\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "listed-method",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = ['a', 'b', 'c', 'd']\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "labeled-practice",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = ['d', 'c', 'b', 'a']\n",
    "is_it_sorted_descending(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "dependent-courtesy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 10:\n",
    "\n",
    "# Way 2:\n",
    "# Check for Pair differences\n",
    "# More Pythonic\n",
    "def is_it_sorted_descending_2(a_list):\n",
    "    condition_1= all(a_list[i] >= a_list[i+1] for i in range(len(a_list)-1))\n",
    "    condition_2= all(a_list[i] <= a_list[i] for i in range(len(a_list)-1))\n",
    "    if condition_1 and condition_2:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "a_list = [7, 6, 4, 3, 2, 1]\n",
    "is_it_sorted_descending_2(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "suspected-ocean",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [2, 7, 3, 4]\n",
    "is_it_sorted_descending_2(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "urban-perspective",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [7, 4, 3, 2]\n",
    "is_it_sorted_descending_2(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "palestinian-design",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 10:\n",
    "\n",
    "# Way 3:\n",
    "# Check with sorted list\n",
    "# Pythonic\n",
    "def is_it_sorted_descending_3(a_list):\n",
    "    \n",
    "    if ((sorted (a_list,reverse=True) == a_list)) and len(a_list)== len(set(a_list)) :\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "\n",
    "a_list = [2, 7, 3, 4]\n",
    "is_it_sorted_descending_3(a_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "historical-recipient",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [2, 7, 3, 4]\n",
    "is_it_sorted_descending_3(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "infrared-remove",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [7, 4, 3, 2]\n",
    "is_it_sorted_descending_3(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "renewable-bristol",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 10:\n",
    "\n",
    "# Way 4:\n",
    "# one line control\n",
    "# Pythonic & Functional\n",
    "\n",
    "def is_it_sorted_descending_4(a_list):\n",
    "    return all([a_list[n] >= a_list[n+1] for n in range(len(a_list)-1)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "suburban-sugar",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [2, 7, 3, 4]\n",
    "is_it_sorted_descending_4(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "binary-stockholm",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [7, 4, 3, 2]\n",
    "is_it_sorted_descending_4(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "textile-minimum",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = ['a', 'd', 'b', 'c']\n",
    "is_it_sorted_descending_4(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "8e5ebe86-8ab7-42e1-bf3c-3d7a4f01bbe4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = ['d', 'c', 'b', 'a']\n",
    "is_it_sorted_descending_4(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47f2f407-a485-420f-a2d0-7cdaa1a4b24e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}