Python_Program13.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ff2d30fb",
   "metadata": {},
   "source": [
    "# Program 121\n",
    "#### Create a function that takes in two lists and returns True if the second list follows the first list by one element, and False otherwise. In other words, determine if the second list is the first list shifted to the right by 1.\n",
    "- Examples\n",
    "- simon_says([1, 2], [5, 1]) ➞ True\n",
    "- simon_says([1, 2], [5, 5]) ➞ False\n",
    "- simon_says([1, 2, 3, 4, 5], [0, 1, 2, 3, 4]) ➞ True\n",
    "- simon_says([1, 2, 3, 4, 5], [5, 5, 1, 2, 3]) ➞ False\n",
    "- Notes:\n",
    "  - Both input lists will be of the same length, and will have a minimum length of 2.\n",
    "  - The values of the 0-indexed element in the second list and the n-1th indexed element in the first list do not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c0de585b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simon_says(list1, list2):\n",
    "    # Check if the second list is the first list shifted to the right by one position\n",
    "    return list1[:-1] == list2[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0337d995",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2], [5, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bd5cb2b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2], [5, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "523550fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2, 3, 4, 5], [0, 1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3e2351b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simon_says([1, 2, 3, 4, 5], [5, 5, 1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3ee773b",
   "metadata": {},
   "source": [
    "# Program 122\n",
    "#### A group of friends have decided to start a secret society. The name will be the first letter of each of their names, sorted in alphabetical order. Create a function that takes in a list of names and returns the name of the secret society.\n",
    "- Examples\n",
    "- society_name([\"Adam\", \"Sarah\", \"Malcolm\"]) ➞ \"AMS\"\n",
    "- society_name([\"Harry\", \"Newt\", \"Luna\", \"Cho\"]) ➞ \"CHLN\"\n",
    "- society_name([\"Phoebe\", \"Chandler\", \"Rachel\", \"Ross\", \"Monica\", \"Joey\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "63fa2281",
   "metadata": {},
   "outputs": [],
   "source": [
    "def society_name(names):\n",
    "    # Extract the first letter of each name, sort them, and join into a\n",
    "    secret_name = ''.join(sorted([name[0] for name in names]))\n",
    "    return secret_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fc800f79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AMS'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "society_name([\"Adam\", \"Sarah\", \"Malcolm\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6ea029a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CHLN'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "society_name([\"Harry\", \"Newt\", \"Luna\", \"Cho\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "48626389",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CJMPRR'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "society_name([\"Phoebe\", \"Chandler\", \"Rachel\", \"Ross\", \"Monica\", \"Joey\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a97f0fac",
   "metadata": {},
   "source": [
    "# Program 123\n",
    "#### An isogram is a word that has no duplicate letters. Create a function that takes astring and returns either True or False \n",
    "depending on whether or not it's an \"isogram\".\n",
    "- Examples\n",
    "- is_isogram(\"Algorism\") ➞ True\n",
    "- is_isogram(\"PasSword\") ➞ False\n",
    "- Not case sensitive.\n",
    "  - is_isogram(\"Consecutive\") ➞ False\n",
    "  - Notes\n",
    "   - Ignore letter case (should not be case sensitive).\n",
    "   - All test cases contain valid one word strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "39aaa43b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_isogram(word):\n",
    "    # Convert the word to lowercase\n",
    "    word = word.lower()\n",
    "\n",
    "    # Create a set to store unique letters in the word\n",
    "    unique_letters = set()\n",
    "\n",
    "    # Iterate through each letter in the word\n",
    "    for letter in word:\n",
    "        # If the letter is already in the set, it's not an isogram\n",
    "        if letter in unique_letters:\n",
    "            return False\n",
    "        # Otherwise, add it to the set\n",
    "        unique_letters.add(letter)\n",
    "\n",
    "    # If the loop completes without returning False, the word is an isogram\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6df0dbd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_isogram(\"Algorism\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e536f180",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_isogram(\"PasSword\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b88a7acf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_isogram(\"Consecutive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "030908b9",
   "metadata": {},
   "source": [
    "# Program 124\n",
    "### Create a function that takes a string and returns True or False, depending on whether the characters are in order or not.\n",
    "- Examples\n",
    "  - is_in_order(\"abc\") ➞ True\n",
    "  - is_in_order(\"edabit\") ➞ False\n",
    "  - is_in_order(\"123\") ➞ True\n",
    "  - is_in_order(\"xyzz\") ➞ True\n",
    "  - Notes\n",
    "    - You don't have to handle empty strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "286b891c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_in_order(s):\n",
    " \n",
    " return s == ''.join(sorted(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "dcf4bc3a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"abc\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16e4cb96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"edabit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "aef2b120",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"123\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4fb38f81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_in_order(\"xyzz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc1857b3",
   "metadata": {},
   "source": [
    "# Program 125\n",
    "#### Create a function that takes a number as an argument and returns True or False depending on whether the number is                      symmetrical or not. A number is symmetrical when it is the same as its reverse.\n",
    "- Examples\n",
    "  - is_symmetrical(7227) ➞ True\n",
    "  - is_symmetrical(12567) ➞ False\n",
    "  - is_symmetrical(44444444) ➞ True\n",
    "  - is_symmetrical(9939) ➞ False\n",
    "  - is_symmetrical(1112111) ➞ True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a2018da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_symmetrical(num):\n",
    "    # Convert the number to a string\n",
    "    num_str = str(num)\n",
    " \n",
    "    # Check if the string is equal to its reverse\n",
    "    return num_str == num_str[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fcacb661",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_symmetrical(7227)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "09f84294",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_symmetrical(12567) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2f17f7a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_symmetrical(44444444)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "acb3a080",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_symmetrical(555555) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f47cd862",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_symmetrical(1112111)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ed0a4b",
   "metadata": {},
   "source": [
    "# Program 126\n",
    "#### Given a string of numbers separated by a comma and space, return the product of the numbers.\n",
    "- Examples\n",
    "- multiply_nums(\"2, 3\") ➞ 6\n",
    "- multiply_nums(\"1, 2, 3, 4\") ➞ 24\n",
    "- multiply_nums(\"54, 75, 453, 0\") ➞ 0\n",
    "- multiply_nums(\"10, -2\") ➞ -20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "48c341d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply_nums(nums_str):\n",
    "    # Split the input string by comma and space, then convert to integers\n",
    "    nums = [int(num) for num in nums_str.split(\", \")]\n",
    "\n",
    "    # Initialize the result with 1\n",
    "    result = 1\n",
    "\n",
    "    # Multiply all the numbers together\n",
    "    for num in nums:\n",
    "        result *= num\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2c433a72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_nums(\"2, 3\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "65dc1d96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_nums(\"1, 2, 3, 4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "8e5b97cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_nums(\"54, 75, 453, 0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ec9c69a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-20"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_nums(\"10, -2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d00cfb89",
   "metadata": {},
   "source": [
    "# Program 127\n",
    "#### Create a function that squares every digit of a number.\n",
    "- Examples\n",
    "- square_digits(9119) ➞ 811181\n",
    "- square_digits(2483) ➞ 416649\n",
    "- square_digits(3212) ➞ 9414\n",
    "- Notes\n",
    " - The function receives an integer and must return an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "54f1d16f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_digits(n):\n",
    "    # Convert the number to a string to iterate through its digits\n",
    "    num_str = str(n)\n",
    "\n",
    "    # Initialize an empty string to store the squared digits\n",
    "    result_str = \"\"\n",
    "\n",
    "    # Iterate through the digits\n",
    "    for digit in num_str:\n",
    "        # Square the digit and convert it back to an integer\n",
    "        squared_digit = int(digit) ** 2\n",
    "\n",
    "        # Append the squared digit to the result string\n",
    "        result_str += str(squared_digit)\n",
    "\n",
    "    # Convert the result string back to an integer and return\n",
    "    return int(result_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "51af7f25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "811181"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_digits(9119)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e37c97e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "416649"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_digits(2483)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "009b7390",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9414"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_digits(3212) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10cf4149",
   "metadata": {},
   "source": [
    "# Program 128\n",
    "#### Create a function that sorts a list and removes all duplicate items from it.\n",
    "- Examples\n",
    " - setify([1, 3, 3, 5, 5]) ➞ [1, 3, 5]\n",
    " - setify([4, 4, 4, 4]) ➞ [4]\n",
    " - setify([5, 7, 8, 9, 10, 15]) ➞ [5, 7, 8, 9, 10, 15]\n",
    " - setify([3, 3, 3, 2, 1]) ➞ [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e56029fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def setify(lst):\n",
    "    unique_set = set(sorted(lst))\n",
    " \n",
    "   # Convert the set back to a list and return it\n",
    "    return list(unique_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "95d134d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setify([1, 3, 3, 5, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "889cc037",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setify([4, 4, 4, 4]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1395b9b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 8, 9, 10, 15]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setify([5, 7, 8, 9, 10, 15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c1b06f30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setify([3, 3, 3, 2, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92383c58",
   "metadata": {},
   "source": [
    "# Program 129\n",
    "#### Create a function that returns the mean of all digits.\n",
    "- Examples\n",
    "- mean(42) ➞ 3\n",
    "- mean(12345) ➞ 3\n",
    "- mean(666) ➞ 6\n",
    "  - Notes\n",
    "   - The mean of all digits is the sum of digits / how many digits there are (e.g. mean of digits in 512 is                       (5+1+2)/3(number of digits) = 8/3=2).\n",
    "   - The mean will always be an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a0741dfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_of_digits(n):\n",
    "    # Convert the number to a string to iterate through its digits\n",
    "    n_str = str(n)\n",
    "\n",
    "    # Calculate the sum of digits\n",
    "    digit_sum = sum(int(digit) for digit in n_str)\n",
    "\n",
    "    # Calculate the mean by dividing the sum by the number of digits\n",
    "    digit_count = len(n_str)\n",
    "    digit_mean = digit_sum / digit_count\n",
    "\n",
    "    return int(digit_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "2cfaaae9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_of_digits(42) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "40e6372c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_of_digits(12345) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "8e0cdb8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_of_digits(778899) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2783bdac",
   "metadata": {},
   "source": [
    "# Program 130\n",
    "#### Create a function that takes an integer and returns a list from 1 to the given number,\n",
    "- where:\n",
    "- 1. If the number can be divided evenly by 4, amplify it by 10 (i.e. return 10 times the number).\n",
    "2. If the number cannot be divided evenly by 4, simply return the number.\n",
    "   - Examples\n",
    "     - amplify(4) ➞ [1, 2, 3, 40]\n",
    "     - amplify(3) ➞ [1, 2, 3]\n",
    "     - amplify(25) ➞ [1, 2, 3, 40, 5, 6, 7, 80, 9, 10, 11, 120, 13, 14, 15, 160, 17, 18, 19, 200, 21,22, 23, 240, 25]\n",
    "- Notes\n",
    "  - The given integer will always be equal to or greater than 1.Include the number (see example above).\n",
    "  - To perform this problem with its intended purpose, try doing it with list comprehensions. If that's too difficult, just     solve the challenge any way you can."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "f39a5c46",
   "metadata": {},
   "outputs": [],
   "source": [
    "def amplify(num):\n",
    "    # Use a list comprehension to generate the list\n",
    "    return [n * 10 if n % 4 == 0 else n for n in range(1, num + 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "2985fc85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 40]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "amplify(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "a2f30a4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "amplify(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "3265b0c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 40,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 80,\n",
       " 9,\n",
       " 10,\n",
       " 11,\n",
       " 120,\n",
       " 13,\n",
       " 14,\n",
       " 15,\n",
       " 160,\n",
       " 17,\n",
       " 18,\n",
       " 19,\n",
       " 200,\n",
       " 21,\n",
       " 22,\n",
       " 23,\n",
       " 240,\n",
       " 25]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "amplify(25)"
   ]
  }
 ],
 "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
}