Python_Program12.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b2309af9",
   "metadata": {},
   "source": [
    "# Program 111\n",
    "#### Given a list of numbers, create a function which returns the list but with each element's index in the list added to itself. This            means you add 0 to the number at index 0, add 1 to the number at index 1, etc...\n",
    "    - Examples\n",
    "    - add_indexes([0, 0, 0, 0, 0]) ➞ [0, 1, 2, 3, 4]\n",
    "    - add_indexes([1, 2, 3, 4, 5]) ➞ [1, 3, 5, 7, 9]\n",
    "    - add_indexes([5, 4, 3, 2, 1]) ➞ [5, 5, 5, 5, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9c119253",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_indexes(lst):\n",
    "    # Use list comprehension to add index to each element\n",
    "    return [i + val for i, val in enumerate(lst)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fda3d4e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_indexes([0, 0, 0, 0, 0]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7be9344d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_indexes([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f5b245d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 5, 5, 5, 5]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_indexes([5, 4, 3, 2, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0670c411",
   "metadata": {},
   "source": [
    "# Program 112\n",
    "### Create a function that takes the height and radius of a cone as arguments and returns the volume of the            cone rounded to the nearest hundredth. See the resources tab for the formula.\n",
    "     - Examples\n",
    "     - cone_volume(3, 2) ➞ 12.57\n",
    "     - cone_volume(15, 6) ➞ 565.49\n",
    "     - cone_volume(18, 0) ➞ 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "40625a06",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def cone_volume(height, radius):\n",
    "    if radius == 0:\n",
    "        return 0\n",
    "    volume = (1/3) * math.pi * (radius**2) * height\n",
    "    return round(volume, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "78f1617a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.57"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone_volume(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "79da4a04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "565.49"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone_volume(15, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "78aa44d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone_volume(18, 0) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "368d3f89",
   "metadata": {},
   "source": [
    "# Program 113\n",
    "#### This Triangular Number Sequence is generated from a pattern of dots that form a triangle. The first 5 numbers of the sequence, or dots, are: 1, 3, 6, 10, 15\n",
    "- This means that the first triangle has just one dot, the second one has three dots, the third one has 6 dots and so on.\n",
    "- Write a function that gives the number of dots with its corresponding triangle number of the sequence.\n",
    "- Examples\n",
    "  - triangle(1) ➞ 1\n",
    "  - triangle(6) ➞ 21\n",
    "  - triangle(215) ➞ 23220"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f6b8ba4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def triangle(n):\n",
    "    if n < 1:\n",
    "        return 0\n",
    "    return n * (n + 1) // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8fd1559f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "triangle(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "13f2d8a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "triangle(6) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7eee7a45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23220"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "triangle(215)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a043b9e6",
   "metadata": {},
   "source": [
    "# Program 114\n",
    "#### Create a function that takes a list of numbers between 1 and 10 (excluding one number) and returns the missing number.\n",
    "- Examples\n",
    "  - missing_num([1, 2, 3, 4, 6, 7, 8, 9, 10]) ➞ 5\n",
    "  - missing_num([7, 2, 3, 6, 5, 9, 1, 4, 8]) ➞ 10\n",
    "  - missing_num([10, 5, 1, 2, 4, 6, 8, 3, 9]) ➞ 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "79b3407d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def missing_num(lst):\n",
    "    total_sum = sum(range(1, 11)) # Sum of numbers from 1 to 10\n",
    "    given_sum = sum(lst) # Sum of the given list of numbers\n",
    "    missing = total_sum - given_sum\n",
    "    return missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1fcb5651",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "missing_num([1, 2, 3, 4, 6, 7, 8, 9, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f31d287d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "missing_num([7, 2, 3, 6, 5, 9, 1, 4, 8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "71842fb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "missing_num([10, 5, 1, 2, 4, 6, 8, 3, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf0b18f6",
   "metadata": {},
   "source": [
    "# Program 115\n",
    "#### Write a function that takes a list and a number as arguments. Add the number to the end of the list, then remove the first                element of the list. The function should then return the updated list.\n",
    "- Examples\n",
    "  - next_in_line([5, 6, 7, 8, 9], 1) ➞ [6, 7, 8, 9, 1]\n",
    "  - next_in_line([7, 6, 3, 23, 17], 10) ➞ [6, 3, 23, 17, 10]\n",
    "  - next_in_line([1, 10, 20, 42 ], 6) ➞ [10, 20, 42, 6]\n",
    "  - next_in_line([], 6) ➞ \"No list has been selected\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "58be7431",
   "metadata": {},
   "outputs": [],
   "source": [
    "def next_in_line(lst, num):\n",
    "    if lst:\n",
    "        lst.pop(0) # Remove the first element\n",
    "        lst.append(num) # Add the number to the end\n",
    "        return lst\n",
    "    else:\n",
    "        return \"No list has been selected\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "01600506",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7, 8, 9, 1]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_in_line([5, 6, 7, 8, 9], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "935adcb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 3, 23, 17, 10]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_in_line([7, 6, 3, 23, 17], 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4f1cc06c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 42, 6]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_in_line([1, 10, 20, 42 ], 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "474d9a62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'No list has been selected'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_in_line([], 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64976563",
   "metadata": {},
   "source": [
    "# Program 116\n",
    "#### Create the function that takes a list of dictionaries and returns the sum of people's budgets.\n",
    "  - Examples\n",
    "    - get_budgets([\n",
    "    { 'name': 'John', 'age': 21, 'budget': 23000 },\n",
    "    { 'name': 'Steve', 'age': 32, 'budget': 40000 },\n",
    "    { 'name': 'Martin', 'age': 16, 'budget': 2700 }\n",
    "   ]) ➞ 65700   <br>\n",
    "- get_budgets([\n",
    "{ 'name': 'John', 'age': 21, 'budget': 29000 },\n",
    "{ 'name': 'Steve', 'age': 32, 'budget': 32000 },\n",
    "{ 'name': 'Martin', 'age': 16, 'budget': 1600 }\n",
    "]) ➞ 62600"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "41ccaf83",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_budgets(lst):\n",
    "    total_budget = sum(person['budget'] for person in lst)\n",
    "    return total_budget\n",
    "# Test cases\n",
    "budgets1 = [\n",
    " {'name': 'John', 'age': 21, 'budget': 23000},\n",
    " {'name': 'Steve', 'age': 32, 'budget': 40000},\n",
    " {'name': 'Martin', 'age': 16, 'budget': 2700}\n",
    "]\n",
    "budgets2 = [\n",
    " {'name': 'John', 'age': 21, 'budget': 29000},\n",
    " {'name': 'Steve', 'age': 32, 'budget': 32000},\n",
    " {'name': 'Martin', 'age': 16, 'budget': 1600}\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0aa2ee00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65700"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_budgets(budgets1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c04e69ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62600"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_budgets(budgets2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b3819a2",
   "metadata": {},
   "source": [
    "# Program 117\n",
    "#### Create a function that takes a string and returns a string with its letters in alphabetical order.\n",
    "- Examples\n",
    "  - alphabet_soup(\"hello\") ➞ \"ehllo\"\n",
    "  - alphabet_soup(\"edabit\") ➞ \"abdeit\"\n",
    "  - alphabet_soup(\"hacker\") ➞ \"acehkr\"\n",
    "  - alphabet_soup(\"geek\") ➞ \"eegk\"\n",
    "  - alphabet_soup(\"javascript\") ➞ \"aacijprstv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1d90201d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def alphabet_soup(txt):\n",
    "    return ''.join(sorted(txt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "91fd0abc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ehllo'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"hello\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3b0ffcc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ilnsu'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"sunil\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a5eb0fde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ENPU'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"PUNE\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e9947cd6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BHOR'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"BHOR\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b39c0617",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abdeit'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"edabit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8ed5f920",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'acehkr'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"hacker\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fdadb5e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eegk'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"geek\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "62423012",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aacijprstv'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet_soup(\"javascript\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0d17c3",
   "metadata": {},
   "source": [
    "# Program 118\n",
    "#### Suppose that you invest $10,000 for 10 years at an interest rate of 6% compounded monthly.What will be the value of your investment at the end of the 10 year period?\n",
    "Create a function that accepts the principal p, the term in years t, the interest rate r,\n",
    "and the number of compounding periods per year n. The function returns the value at\n",
    "the end of term rounded to the nearest cent.\n",
    "For the example:\n",
    "compound_interest(10000, 10, 0.06, 12) ➞ 18193.97\n",
    "Note that the interest rate is given as a decimal and n=12 because with monthly\n",
    "compounding there are 12 periods per year. Compounding can also be done\n",
    "annually, quarterly, weekly, or daily.\n",
    "Examples\n",
    "compound_interest(100, 1, 0.05, 1) ➞ 105.0\n",
    "compound_interest(3500, 15, 0.1, 4) ➞ 15399.26\n",
    "compound_interest(100000, 20, 0.15, 365) ➞ 2007316.26"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c8495bf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compound_interest(p, t, r, n):\n",
    "    # Calculate the compound interest using the formula\n",
    "    a = p * (1 + (r / n)) ** (n * t)\n",
    "    # Round the result to the nearest cent\n",
    "    return round(a, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "bfc071b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18193.97"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compound_interest(10000, 10, 0.06, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "f1af60b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compound_interest(100, 1, 0.05, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f5753b8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15399.26"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compound_interest(3500, 15, 0.1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dc87350a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2007316.26"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compound_interest(100000, 20, 0.15, 365)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b750488e",
   "metadata": {},
   "source": [
    "# Program 119\n",
    "#### Write a function that takes a list of elements and returns only the integers.\n",
    "- Examples\n",
    "- return_only_integer([9, 2, \"space\", \"car\", \"lion\", 16]) ➞ [9, 2, 16]\n",
    "- return_only_integer([\"hello\", 81, \"basketball\", 123, \"fox\"]) ➞ [81, 123]\n",
    "- return_only_integer([10, \"121\", 56, 20, \"car\", 3, \"lion\"]) ➞ [10, 56, 20,3]\n",
    "- return_only_integer([\"String\", True, 3.3, 1]) ➞ [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "60fc2851",
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_only_integer(lst):\n",
    "    # Use list comprehension to filter out integers\n",
    "    return [x for x in lst if isinstance(x, int)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e5ff6e71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 2, 16]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_only_integer([9, 2, \"space\", \"car\", \"lion\", 16])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "6f93454f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[81, 123]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_only_integer([\"hello\", 81, \"basketball\", 123, \"fox\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7e506a3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 56, 20, 3]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_only_integer([10, \"121\", 56, 20, \"car\", 3, \"lion\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5d8a7b24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, 1]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_only_integer([\"String\", True, 3.3, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14e270d0",
   "metadata": {},
   "source": [
    "# Program 120\n",
    "#### Create a function that takes three parameters where:\n",
    "  - x is the start of the range (inclusive).\n",
    "  - y is the end of the range (inclusive).\n",
    "  - n is the divisor to be checked against.\n",
    "### Return an ordered list with numbers in the range that are divisible by the third parameter n.\n",
    "- Return an empty list if there are no numbers that are divisible by n.\n",
    "- Examples\n",
    "- list_operation(1, 10, 3) ➞ [3, 6, 9]\n",
    "- list_operation(7, 9, 2) ➞ [8]\n",
    "- list_operation(15, 20, 7) ➞ []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "886de76c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_operation(x, y, n):\n",
    "    # Validate inputs\n",
    "    if not all(isinstance(arg, int) for arg in (x, y, n)):\n",
    "        raise ValueError(\"All inputs must be integers\")\n",
    "    \n",
    "    # Use list comprehension to generate the list of numbers divisible by n\n",
    "    return [num for num in range(x, y + 1) if num % n == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c9f71eff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_operation(1, 10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "52af468d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_operation(7, 9, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "6636fd2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_operation(15, 20, 7)"
   ]
  }
 ],
 "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
}