20th_August_Python_basics_practice_test_file.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b27a887a-e3ec-4c8b-8042-4df72d143683",
   "metadata": {},
   "source": [
    "                                    TOPIC: String Based Assignment Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b418cf0-edae-4fdd-9047-3ddd65cef657",
   "metadata": {},
   "source": [
    "1. Write a program to reverse a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7151c639-bddc-4526-b95a-47f3b55e2b3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reverse string of AMIT is TIMA\n"
     ]
    }
   ],
   "source": [
    "36. Replace every element in a list with its square."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8dcd46a-d7af-48e9-896f-637ef379ac98",
   "metadata": {},
   "source": [
    "2. Check if a string is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e92370fe-e53d-4094-baed-8ccb4c01b98d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter string amit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string is not a palindrome.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "s = input(\"enter string\")\n",
    "\n",
    "rev_str= s[::-1]\n",
    "if rev_str==s:\n",
    "    print(\"string is a palindrome.\")\n",
    "else:\n",
    "    print(\"string is not a palindrome.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37148029-1e80-4e54-95b0-593581071367",
   "metadata": {},
   "source": [
    "3. Convert a string to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "054490dc-52d2-40b2-b596-7772308ccbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AMIT\n"
     ]
    }
   ],
   "source": [
    "s = \"amit\"\n",
    "uppr_case = s.upper()\n",
    "print(uppr_case)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb67ca19-b1eb-40e1-ae9c-e64a19882883",
   "metadata": {},
   "source": [
    "4. Convert a string to lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0f7f15be-81b6-49ad-af82-21825fc64561",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amit\n"
     ]
    }
   ],
   "source": [
    "s = \"AmIT\"\n",
    "lowr_case = s.lower()\n",
    "print(lowr_case)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ad8c7f-503c-4e27-8c8b-b688ca068f25",
   "metadata": {},
   "source": [
    "5. Count the number of vowels in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8ff5b06c-86a4-4d0c-87d9-6fdbe74612d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter string amit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "string = input(\"enter string\")\n",
    "vowels = \"aeiouAEIOU\"\n",
    "\n",
    "count = sum(string.count(vowel) for vowel in vowels)\n",
    "print(count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34053f7f-04db-478f-a7d6-6402ad31f4c8",
   "metadata": {},
   "source": [
    "6. Count the number of consonants in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e383a598-f8a7-45b1-9925-63f784a05ed8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  ram seeta\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of consonant: 5\n"
     ]
    }
   ],
   "source": [
    "consonants=0\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    " \n",
    "string = user_input.lower()\n",
    " \n",
    "for i in range(0,len(string)):  \n",
    "    if string[i] not in ('a',\"e\",\"i\",\"o\",\"u\"):  \n",
    "        consonants = consonants + 1;  \n",
    " \n",
    "print(\"The number of consonant:\",consonants);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9ac481b-f7ac-4836-a9c5-ea66c58d54b8",
   "metadata": {},
   "source": [
    "7. Remove all whitespaces from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "745e9c68-20df-420c-bcdc-c09a876b594a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amitkumar\n"
     ]
    }
   ],
   "source": [
    "\n",
    "string = \"amit kumar\"\n",
    " \n",
    "string_new = string.replace (\" \",\"\")\n",
    " \n",
    "print(string_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50f1a317-6c9d-4c69-8e58-58dc91ae3878",
   "metadata": {},
   "source": [
    "8. Find the length of a string without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e29b9ec5-8ada-413b-a15c-3af2371d6266",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter string amit kumar baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "str_count =input (\"enter string\")\n",
    "\n",
    "count = 0\n",
    "\n",
    "for i in str_count:\n",
    " \n",
    "    count+=1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76a39865-9f05-4945-9d95-1321ad05b9d8",
   "metadata": {},
   "source": [
    "9. Check if a string contains a specific word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f0f4b705-9c1d-41f2-83c8-d46afc739f09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found\n"
     ]
    }
   ],
   "source": [
    "string1 = \"AMIT\"\n",
    "string1_lower= string1.lower()\n",
    "string2 = \"a\"\n",
    "if string2 in string1_lower:\n",
    "    print(\"found\")\n",
    "else:\n",
    "    print(\"not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0e6a37-760d-424a-a9bc-71d779cc7346",
   "metadata": {},
   "source": [
    "10. Replace a word in a string with another word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "455b9387-92b0-4db4-a60a-06c96b7dab8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amit kumar\n"
     ]
    }
   ],
   "source": [
    "string = \"amit\"\n",
    "new_string = string.replace(\"amit\", \"amit kumar\")\n",
    "\n",
    "print(new_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "364435a1-3130-4cc6-bd79-3b044c7febd7",
   "metadata": {},
   "source": [
    "11. Count the occurrences of a word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1af0e4cd-4a58-4739-af21-6bf326df5466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    " \n",
    "def countOccurrences(str, word):\n",
    "\n",
    "\twordslist = list(str.split())\n",
    "\treturn wordslist.count(word)\n",
    " \n",
    "str = \"dayalbgah educational institute agra \"\n",
    "word = \"agra\"\n",
    "print(countOccurrences(str, word))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c72682cb-487c-4f51-97b3-606398d29144",
   "metadata": {},
   "source": [
    "12. Find the first occurrence of a word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f36663f2-40f8-4840-b9f9-08997a0cfc4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    " string = 'Python programming. Network programming.'\n",
    "substring = 'prog'\n",
    "\n",
    "index = string.find(substring)\n",
    "print(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99359a86-8a31-4565-b193-fc9dbc47d1db",
   "metadata": {},
   "source": [
    "13. Find the last occurrence of a word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3eb283be-7ab4-4638-85dd-ffd2a4adf395",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The last index of y in the given string is 20\n"
     ]
    }
   ],
   "source": [
    "str1 = \"welcome to my country\"\n",
    "\n",
    "index = str1.rindex('y')\n",
    "print(\"The last index of y in the given string is\",index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7eed7a-c4ac-49c6-8bcf-e0aa369bbba2",
   "metadata": {},
   "source": [
    "14. Split a string into a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9f414d7d-6948-4cd4-a2b7-6c205cac51b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hey', 'amit', 'how', 'are', 'you?']\n"
     ]
    }
   ],
   "source": [
    "str_spilit = \"hey amit how are you?\"\n",
    "s = str_spilit.split()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad2eb761-999d-47d0-a16d-3c0409e128d1",
   "metadata": {},
   "source": [
    "15. Join a list of words into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "084b78b6-85d7-4949-a2c0-b1b36ac0652c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amit, kumar, baghel\n"
     ]
    }
   ],
   "source": [
    "\n",
    "Str = [\"amit\", \"kumar\",\"baghel\"]\n",
    "a = \", \"\n",
    "print(a.join(Str))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c65fd7fb-36f4-4b4a-913e-7f02b9793810",
   "metadata": {},
   "source": [
    "16. Convert a string where words are separated by spaces to one where words\n",
    "are separated by underscores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "80bddf42-dbac-49b4-b090-f210414013cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['amit', 'kumar', 'baghel']\n",
      "amit_kumar_baghel\n"
     ]
    }
   ],
   "source": [
    "s = \"amit kumar baghel\"\n",
    "a = s.split(\" \")\n",
    "print(a) \n",
    " \n",
    "print(\"_\".join(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60750e6b-6b89-42e9-bd74-40356304829f",
   "metadata": {},
   "source": [
    "17. Check if a string starts with a specific word or phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ae0db293-f0bb-4db9-83e1-dfaaf5e43a92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "message = 'Python is very usefull'\n",
    "\n",
    "print(message.startswith('Python'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b2d46c-341d-4e44-94e4-d530f700e9cc",
   "metadata": {},
   "source": [
    "18. Check if a string ends with a specific word or phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d70241b7-ca91-4c4d-ba4c-ffba3dcd2977",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "message = 'Python is very usefull'\n",
    "\n",
    "print(message.endswith('Python'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f703d56f-b9d2-4e97-a0b6-c5caa7712884",
   "metadata": {},
   "source": [
    "19. Convert a string to title case (e.g., \"hello world\" to \"Hello World\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81c1dc18-a854-4c02-ad2b-b76b84cfbd44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Hello World\"\n"
     ]
    }
   ],
   "source": [
    "string = \"hello world\"\n",
    "title = '\\\"hello world\\\"'\n",
    "print(title.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa3169e-6db7-4f90-8ac9-7ffd419c01ac",
   "metadata": {},
   "source": [
    "20. Find the longest word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "826b434c-0b0a-49de-becd-2629932638dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter words:  amit kumar baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is input result: baghel\n"
     ]
    }
   ],
   "source": [
    "a = input(\"enter words:\")\n",
    "word = a.split()\n",
    "longest_word = max(word, key=len)\n",
    "print(\"this is input result:\",longest_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05cf138e-b21a-450f-aee5-02edfb598054",
   "metadata": {},
   "source": [
    "21. Find the shortest word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8c3c66a4-189f-4a06-907e-7f1c729d70cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter words: amit kumar baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is input result: amit\n"
     ]
    }
   ],
   "source": [
    "a = input(\"enter words:\")\n",
    "word = a.split()\n",
    "longest_word = min(word, key=len)\n",
    "print(\"this is input result:\",longest_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc33798c-16b9-4db2-833f-63adae553453",
   "metadata": {},
   "source": [
    "22. Reverse the order of words in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "26dbd564-aaa6-4642-9707-611fce1b7009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "good very is baghel kumar amit\n"
     ]
    }
   ],
   "source": [
    " \n",
    "string = \"amit kumar baghel is very good\"\n",
    " \n",
    "s = string.split()[::-1]\n",
    "l = []\n",
    "for i in s:\n",
    "\t \n",
    "\tl.append(i)\n",
    " \n",
    "print(\" \".join(l))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e937dbd7-102a-482f-ac6f-91663ca5a7a9",
   "metadata": {},
   "source": [
    "23. Check if a string is alphanumeric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "dd3fc723-eeae-4468-91a6-19e9f5384471",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar baghel is very good\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string is not alphanumeric.\n"
     ]
    }
   ],
   "source": [
    "def is_alphanumeric(input_string):\n",
    "    return input_string.isalnum()\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "\n",
    "if is_alphanumeric(user_input):\n",
    "    print(\"The string is alphanumeric.\")\n",
    "else:\n",
    "    print(\"The string is not alphanumeric.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08002eee-ddf2-4d77-9bbe-9913652f970b",
   "metadata": {},
   "source": [
    "24. Extract all digits from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f6869c45-6b87-4704-a4b2-603dbecf4802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted digits: 19\n"
     ]
    }
   ],
   "source": [
    "def extract_digits(input_string):\n",
    "    return ''.join(char for char in input_string if char.isdigit())\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "digits = extract_digits(user_input)\n",
    "\n",
    "print(\"Extracted digits:\", digits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb598a7d-fc7d-4eac-9d6b-8b901b68b343",
   "metadata": {},
   "source": [
    "25. Extract all alphabets from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9e12500d-afe2-4dcb-95d5-e3687b482e5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar 1996, 01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted alphabets: amitkumar\n"
     ]
    }
   ],
   "source": [
    "def extract_alphabets(input_string):\n",
    "    return ''.join(char for char in input_string if char.isalpha())\n",
    "\n",
    " user_input = input(\"Enter a string: \")\n",
    "alphabets = extract_alphabets(user_input)\n",
    "\n",
    "print(\"Extracted alphabets:\", alphabets)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfbe0808-dcc2-4aa3-8c56-2e7512b690fc",
   "metadata": {},
   "source": [
    "26. Count the number of uppercase letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "11a9774a-f8b6-4970-8125-b93ca4715d84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  AMIt kuMAR BagHEL\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of uppercase letters: 10\n"
     ]
    }
   ],
   "source": [
    "def count_uppercase_letters(input_string):\n",
    "    return sum(1 for char in input_string if char.isupper())\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "uppercase_count = count_uppercase_letters(user_input)\n",
    "\n",
    "print(\"Number of uppercase letters:\", uppercase_count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f76b6f9-94ac-480f-8ba7-89a68afd6696",
   "metadata": {},
   "source": [
    "27. Count the number of lowercase letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2908792b-9279-4423-b522-8c1322c4ca2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit KumaR\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of lowercase letters: 7\n"
     ]
    }
   ],
   "source": [
    "def count_lowercase_letters(input_string):\n",
    "    return sum(1 for char in input_string if char.islower())\n",
    "\n",
    "# Example usage:\n",
    "user_input = input(\"Enter a string: \")\n",
    "lowercase_count = count_lowercase_letters(user_input)\n",
    "\n",
    "print(\"Number of lowercase letters:\", lowercase_count)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dfaedb3-4823-48e3-8d0b-110f31b8dbb5",
   "metadata": {},
   "source": [
    "28. Swap the case of each character in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7cd6ae67-9320-4ddb-bc26-f30160860b61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  Amit KUmaR\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swapped case: aMIT kuMAr\n"
     ]
    }
   ],
   "source": [
    "def swap_case(input_string):\n",
    "    return input_string.swapcase()\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "swapped_string = swap_case(user_input)\n",
    "\n",
    "print(\"Swapped case:\", swapped_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3ff3605-ad76-4705-a5b7-41917a3ac053",
   "metadata": {},
   "source": [
    "29. Remove a specific word from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2589c74a-631f-41c4-ab54-a6bfe98a9966",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:   amit kumar baghel\n",
      "Enter the word to remove:  it\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after removal:  am kumar baghel\n"
     ]
    }
   ],
   "source": [
    "def remove_word(input_string, word_to_remove):\n",
    "    return input_string.replace(word_to_remove, '')\n",
    " \n",
    "user_input = input(\"Enter a string: \")\n",
    "word_to_remove = input(\"Enter the word to remove: \")\n",
    "\n",
    "result_string = remove_word(user_input, word_to_remove)\n",
    "\n",
    "print(\"String after removal:\", result_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a45caef1-c771-40a5-8ae6-f751eac1c7af",
   "metadata": {},
   "source": [
    "30. Check if a string is a valid email address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9b8b515c-5fd8-4899-a39e-38e0d20a641f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def solve(s):\n",
    "   pat = \"^[a-zA-Z0-9-_]+@[a-zA-Z0-9]+\\.[a-z]{1,3}$\"\n",
    "   if re.match(pat,s):\n",
    "      return True\n",
    "   return False\n",
    "\n",
    "s = \"popular_website15@comPany.com\"\n",
    "print(solve(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85737ecf-40f1-4a5d-b241-b4900a55663d",
   "metadata": {},
   "source": [
    "31. Extract the username from an email address string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ec40c60e-54ba-4d0b-b23a-03e44c075472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an email address:  amitbaghel096\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted username: amitbaghel096\n"
     ]
    }
   ],
   "source": [
    "def extract_username(email):\n",
    "    parts = email.split('@')\n",
    "    username = parts[0]\n",
    "    \n",
    "    return username\n",
    "user_email = input(\"Enter an email address: \")\n",
    "\n",
    "username = extract_username(user_email)\n",
    "\n",
    "print(\"Extracted username:\", username)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b50b1355-9390-4d15-8906-b8f9ce6c1c02",
   "metadata": {},
   "source": [
    "32. Extract the domain name from an email address string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2ed8a0e5-7d55-43fa-b8ad-0fd2fb231f22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an email address:  amitbaghel096@gmail.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted domain: gmail.com\n"
     ]
    }
   ],
   "source": [
    " def extract_domain(email):\n",
    "  \n",
    "    parts = email.split('@')\n",
    "    domain = parts[1]\n",
    "    \n",
    "    return domain\n",
    " \n",
    "user_email = input(\"Enter an email address: \")\n",
    "\n",
    "domain = extract_domain(user_email)\n",
    "\n",
    "print(\"Extracted domain:\", domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4d14e5b-665b-43a4-899d-92834a9492cf",
   "metadata": {},
   "source": [
    "33. Replace multiple spaces in a string with a single space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "88b232b5-41ee-4439-9db4-091aaf28d00c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit    kumar      baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String with single spaces: amit kumar baghel\n"
     ]
    }
   ],
   "source": [
    "def replace_multiple_spaces(input_string):\n",
    "    words = input_string.split(' ')\n",
    "     \n",
    "    result_string = ' '.join(filter(None, words))\n",
    "    \n",
    "    return result_string\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "result_string = replace_multiple_spaces(user_input)\n",
    "\n",
    "print(\"String with single spaces:\", result_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b839416-d839-4a70-950a-4836e7850ca5",
   "metadata": {},
   "source": [
    "34. Check if a string is a valid URL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ce5e2803-a4e9-490b-af97-703c38b5d572",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a URL:  https://lab.pwskills.com/my-labs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The URL is valid.\n"
     ]
    }
   ],
   "source": [
    "from urllib.parse import urlparse\n",
    "\n",
    "def is_valid_url(url):\n",
    "    try:\n",
    "        result = urlparse(url)\n",
    "        return all([result.scheme, result.netloc])\n",
    "    except ValueError:\n",
    "        return False\n",
    "\n",
    "user_url = input(\"Enter a URL: \")\n",
    "\n",
    "if is_valid_url(user_url):\n",
    "    print(\"The URL is valid.\")\n",
    "else:\n",
    "    print(\"The URL is not valid.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a025b3e-2141-454c-9a35-d1a24b7ecd76",
   "metadata": {},
   "source": [
    "35. Extract the protocol (http or https) from a URL string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8f1edc47-cc86-455b-8200-667b1852638f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a URL:  https://lab.pwskills.com/my-labs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted protocol: https\n"
     ]
    }
   ],
   "source": [
    "from urllib.parse import urlparse\n",
    "\n",
    "def extract_protocol(url):\n",
    "    parsed_url = urlparse(url)\n",
    "    return parsed_url.scheme\n",
    "\n",
    "user_url = input(\"Enter a URL: \")\n",
    "\n",
    "protocol = extract_protocol(user_url)\n",
    "\n",
    "if protocol:\n",
    "    print(\"Extracted protocol:\", protocol)\n",
    "else:\n",
    "    print(\"Invalid URL or no protocol found.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39407e31-713b-4e9a-a117-d8ee74b10384",
   "metadata": {},
   "source": [
    "36. Find the frequency of each character in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8afb7d2c-dd68-450d-8f63-5db9f2420895",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character frequency:\n",
      "a: 2\n",
      "m: 2\n",
      "i: 1\n",
      "t: 1\n",
      " : 1\n",
      "k: 1\n",
      "u: 1\n",
      "r: 1\n"
     ]
    }
   ],
   "source": [
    "def character_frequency(input_string):\n",
    "    frequency_dict = {}\n",
    "\n",
    "    for char in input_string:\n",
    "        if char in frequency_dict:\n",
    "            frequency_dict[char] += 1\n",
    "        else:\n",
    "            frequency_dict[char] = 1\n",
    "\n",
    "    return frequency_dict\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "frequency_result = character_frequency(user_input)\n",
    "\n",
    "print(\"Character frequency:\")\n",
    "for char, count in frequency_result.items():\n",
    "    print(f\"{char}: {count}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c907fcbe-018a-4c70-8a11-daff1d9da9e7",
   "metadata": {},
   "source": [
    "37. Remove all punctuation from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5aba9326-af32-4c21-af96-02a1e7f518c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String without punctuation: amit kumar baghel\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def remove_punctuation(input_string):\n",
    "    return ''.join(char for char in input_string if char not in string.punctuation)\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "result_string = remove_punctuation(user_input)\n",
    "\n",
    "print(\"String without punctuation:\", result_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c398359-2045-40ca-8fc3-97a96514a37e",
   "metadata": {},
   "source": [
    "38. Check if a string contains only digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e5ee7f4f-74f1-41c2-98ac-20ed9edcfbd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  516546548974\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string contains only digits.\n"
     ]
    }
   ],
   "source": [
    "def contains_only_digits(input_string):\n",
    "    return input_string.isdigit()\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "\n",
    "if contains_only_digits(user_input):\n",
    "    print(\"The string contains only digits.\")\n",
    "else:\n",
    "    print(\"The string contains characters other than digits.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3694923e-9023-4c80-b621-ceb3c0e76782",
   "metadata": {},
   "source": [
    "39. Check if a string contains only alphabets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ba03fe36-41d9-4de2-b59d-333ddc3c22a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar1996\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string contains characters other than alphabets.\n"
     ]
    }
   ],
   "source": [
    "def contains_only_alphabets(input_string):\n",
    "    return input_string.isalpha()\n",
    "\n",
    "# Example usage:\n",
    "user_input = input(\"Enter a string: \")\n",
    "\n",
    "if contains_only_alphabets(user_input):\n",
    "    print(\"The string contains only alphabets.\")\n",
    "else:\n",
    "    print(\"The string contains characters other than alphabets.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4969d22a-b299-4c80-a072-59329f1ac4cc",
   "metadata": {},
   "source": [
    "40. Convert a string to a list of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "eefb802b-34f7-4f9c-a77d-b7eb68ab69f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of characters: ['A', 'm', 'i', 't', ' ', 'B', 'a', 'g', 'h', 'e', 'l']\n"
     ]
    }
   ],
   "source": [
    "input_string = \"Amit Baghel\"\n",
    "character_list = [char for char in input_string]\n",
    "\n",
    "print(\"List of characters:\", character_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4302f07f-37a8-48f6-ae08-19fb582a20d5",
   "metadata": {},
   "source": [
    "41. Check if two strings are anagrams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fbd13a4e-3555-499c-99ef-ce7a764f154d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first string:   with the red jacket\n",
      "Enter the second string:  Filled with joy\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The strings are not anagrams.\n"
     ]
    }
   ],
   "source": [
    "def are_anagrams(str1, str2):\n",
    "    return sorted(str1) == sorted(str2)\n",
    "\n",
    "string1 = input(\"Enter the first string: \")\n",
    "string2 = input(\"Enter the second string: \")\n",
    "\n",
    "if are_anagrams(string1, string2):\n",
    "    print(\"The strings are anagrams.\")\n",
    "else:\n",
    "    print(\"The strings are not anagrams.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8881e3a-433a-4544-bb79-cdfbf2150172",
   "metadata": {},
   "source": [
    "42. Encode a string using a Caesar cipher."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bf250c04-f11b-45c3-a489-23b7358cfeee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the plaintext:   asdfghjklasdfgh\n",
      "Enter the shift value:  56\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encrypted text:  ewhjklnopewhjkl\n"
     ]
    }
   ],
   "source": [
    " def encrypt_text(plaintext,n):\n",
    "    ans = \"\"\n",
    "    # iterate over the given text\n",
    "    for i in range(len(plaintext)):\n",
    "        ch = plaintext[i]\n",
    "        \n",
    "        # check if space is there then simply add space\n",
    "        if ch==\" \":\n",
    "            ans+=\" \"\n",
    "        # check if a character is uppercase then encrypt it accordingly \n",
    "        elif (ch.isupper()):\n",
    "            ans += chr((ord(ch) + n-65) % 26 + 65)\n",
    "        # check if a character is lowercase then encrypt it accordingly\n",
    "        \n",
    "        else:\n",
    "            ans += chr((ord(ch) + n-97) % 26 + 97)\n",
    "    \n",
    "    return ans\n",
    "\n",
    "plaintext = \"HELLO EVERYONE\"\n",
    "n = 1\n",
    "print(\"Plain Text is : \" + plaintext)\n",
    "print(\"Shift pattern is : \" + str(n))\n",
    "print(\"Cipher Text is : \" + encrypt_text(plaintext,n))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8da974d-8934-418b-85ee-f11ebc4fd5cf",
   "metadata": {},
   "source": [
    "43. Decode a Caesar cipher encoded string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "62bc9305-fad9-4006-a9e9-b8914e006fd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the ciphertext:  amit kumar baghel\n",
      "Enter the shift value:  1996\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decrypted text: gsoz qasgx hgmnkr\n"
     ]
    }
   ],
   "source": [
    "def caesar_cipher_decrypt(ciphertext, shift):\n",
    "    decrypted_text = \"\"\n",
    "\n",
    "    for char in ciphertext:\n",
    "        if char.isalpha():\n",
    "            # Determine the case of the character (uppercase or lowercase)\n",
    "            is_upper = char.isupper()\n",
    "\n",
    "            # Shift the character back by the specified amount\n",
    "            char_code = ord(char)\n",
    "            decrypted_char_code = (char_code - ord('A' if is_upper else 'a') - shift) % 26 + ord('A' if is_upper else 'a')\n",
    "\n",
    "            # Append the decrypted character to the result string\n",
    "            decrypted_text += chr(decrypted_char_code)\n",
    "        else:\n",
    "            # If the character is not a letter, leave it unchanged\n",
    "            decrypted_text += char\n",
    "\n",
    "    return decrypted_text\n",
    "\n",
    "# Example usage:\n",
    "ciphertext = input(\"Enter the ciphertext: \")\n",
    "shift = int(input(\"Enter the shift value: \"))\n",
    "\n",
    "decrypted_text = caesar_cipher_decrypt(ciphertext, shift)\n",
    "\n",
    "print(\"Decrypted text:\", decrypted_text)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19446200-05da-4556-9a52-9d0164cf10d5",
   "metadata": {},
   "source": [
    "44.Find the most frequent word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3cc7a420-3fce-4b6b-9bc3-ac22f0d28c74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit b gahel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most frequent word: amit\n"
     ]
    }
   ],
   "source": [
    "def most_frequent_word(input_string):\n",
    "    word_frequency = {}\n",
    "    \n",
    "    cleaned_string = ''.join(char.lower() if char.isalpha() or char.isspace() else ' ' for char in input_string)\n",
    "    \n",
    "    words = cleaned_string.split()\n",
    "    \n",
    "    for word in words:\n",
    "        if word in word_frequency:\n",
    "            word_frequency[word] += 1\n",
    "        else:\n",
    "            word_frequency[word] = 1\n",
    "    \n",
    "    most_frequent = max(word_frequency, key=word_frequency.get)\n",
    "    \n",
    "    return most_frequent\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "result_word = most_frequent_word(user_input)\n",
    "\n",
    "print(\"Most frequent word:\", result_word)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33137520-4df7-44a6-9902-4380251b360d",
   "metadata": {},
   "source": [
    "45. Find all unique words in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c0dd385c-eba9-42fb-878c-fe6a9a0e3df6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit baghel kumar\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique words: {'kumar', 'amit', 'baghel'}\n"
     ]
    }
   ],
   "source": [
    "def unique_words(input_string):\n",
    "    \n",
    "    cleaned_string = ''.join(char.lower() if char.isalpha() or char.isspace() else ' ' for char in input_string)\n",
    "    words = cleaned_string.split()\n",
    "    unique_word_set = set(words)\n",
    "\n",
    "    return unique_word_set\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "result_unique_words = unique_words(user_input)\n",
    "\n",
    "print(\"Unique words:\", result_unique_words)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17429bdb-3d1e-4502-9203-41081b785086",
   "metadata": {},
   "source": [
    "46. Count the number of syllables in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0d7e79fe-e86e-408a-842d-298edd1eae90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of syllables: 6\n"
     ]
    }
   ],
   "source": [
    "def count_syllables(word):\n",
    "    vowels = \"aeiouy\"\n",
    "    count = 0\n",
    "    is_vowel = False\n",
    "\n",
    "    for char in word.lower():\n",
    "        if char in vowels:\n",
    "            if not is_vowel:\n",
    "                count += 1\n",
    "                is_vowel = True\n",
    "        else:\n",
    "            is_vowel = False\n",
    "\n",
    "    return count\n",
    "\n",
    "def total_syllables(text):\n",
    "    words = text.split()\n",
    "    return sum(count_syllables(word) for word in words)\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "syllable_count = total_syllables(user_input)\n",
    "\n",
    "print(\"Number of syllables:\", syllable_count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62cdd03-0800-4838-8534-fe27abd7e085",
   "metadata": {},
   "source": [
    "47. Check if a string contains any special characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "74a4612c-e7b6-4e6b-8702-d0a32fa07a99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit @kumar#baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string contains special characters.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def contains_special_characters(input_string):\n",
    "    pattern = re.compile('[^a-zA-Z0-9]')\n",
    "    return bool(pattern.search(input_string))\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "\n",
    "if contains_special_characters(user_input):\n",
    "    print(\"The string contains special characters.\")\n",
    "else:\n",
    "    print(\"The string does not contain special characters.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f6b88de-895d-463b-8749-226d3c1af6af",
   "metadata": {},
   "source": [
    "48. Remove the nth word from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "9262f8c5-d9f1-4348-a10b-a320d2875625",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar baghel\n",
      "Enter the position of the word to remove (1-based index):  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after removing the nth word: Invalid value of n\n"
     ]
    }
   ],
   "source": [
    "def remove_nth_word(input_string, n):\n",
    "    words = input_string.split()\n",
    "\n",
    "    if 1 <= n <= len(words):\n",
    "        del words[n - 1]\n",
    "        result_string = ' '.join(words)\n",
    "        return result_string\n",
    "    else:\n",
    "        return \"Invalid value of n\"\n",
    " \n",
    "user_input = input(\"Enter a string: \")\n",
    "nth_word_to_remove = int(input(\"Enter the position of the word to remove (1-based index): \"))\n",
    "\n",
    "result_string = remove_nth_word(user_input, nth_word_to_remove)\n",
    "\n",
    "print(\"String after removing the nth word:\", result_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a5e970b-63ce-42bb-b062-8a8644756196",
   "metadata": {},
   "source": [
    "49. Insert a word at the nth position in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3e384805-3334-4936-8807-d5e1280cfa00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  amit kumar baghel\n",
      "Enter the position to insert the word (1-based index):  5\n",
      "Enter the word to insert:  g\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after inserting the word: Invalid position for insertion\n"
     ]
    }
   ],
   "source": [
    "def insert_word_at_position(input_string, n, new_word):\n",
    "    words = input_string.split()\n",
    "\n",
    "    if 1 <= n <= len(words) + 1:        \n",
    "        words.insert(n - 1, new_word)\n",
    "        result_string = ' '.join(words)\n",
    "        return result_string\n",
    "    else:\n",
    "        return \"Invalid position for insertion\"\n",
    "\n",
    "user_input = input(\"Enter a string: \")\n",
    "position_to_insert = int(input(\"Enter the position to insert the word (1-based index): \"))\n",
    "word_to_insert = input(\"Enter the word to insert: \")\n",
    "\n",
    "result_string = insert_word_at_position(user_input, position_to_insert, word_to_insert)\n",
    "\n",
    "print(\"String after inserting the word:\", result_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5092feac-37ec-40e1-95a4-c8b40cb08ea9",
   "metadata": {},
   "source": [
    "50. Convert a CSV string to a list of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd84e9be-606d-47d1-a1de-a8d4e78cbcca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a CSV string:  amit kumar bafhel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of lists: [['amit kumar bafhel']]\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "from io import StringIO\n",
    "\n",
    "def csv_string_to_list(csv_string):\n",
    "    csv_reader = csv.reader(StringIO(csv_string))\n",
    "    csv_list = list(csv_reader)\n",
    "\n",
    "    return csv_list\n",
    "csv_input = input(\"Enter a CSV string: \")\n",
    "result_list = csv_string_to_list(csv_input)\n",
    "\n",
    "print(\"List of lists:\", result_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b685f37-f260-4f80-a822-605421e7d899",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd5188b9-c0d6-4573-b014-b6263c25ba23",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2610aba3-bfa9-43ef-8544-21f08a5b1b3b",
   "metadata": {},
   "source": [
    "                                         topic: List Based Practice Problem "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f35c426b-91ad-47a1-9f5f-dc7fe69d262b",
   "metadata": {},
   "source": [
    "1. Create a list with integers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95bb44d0-9023-45c5-a9ce-4cfff8f9217a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with integers from 1 to 10: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "my_list = list(range(1, 11))\n",
    "\n",
    "print(\"List with integers from 1 to 10:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baebe238-9ccd-4fa9-89e3-ccf532119723",
   "metadata": {},
   "source": [
    "2. Find the length of a list without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6d23684d-c658-45ad-b5fc-8ca703c424fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter the string amit kumar baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lenth of word are: 17\n"
     ]
    }
   ],
   "source": [
    "s = input(\"enter the string\")\n",
    "def len_input(s):\n",
    "    count = 0\n",
    "    for i in s:\n",
    "        count +=1\n",
    "    return count\n",
    "list_of_word = len_input(s)\n",
    "print(\"lenth of word are:\",list_of_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61d719e0-aa1e-4e21-b157-e338069ae6c9",
   "metadata": {},
   "source": [
    "3. Append an element to the end of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4b9bf857-2a32-4270-8161-9657c3c79dfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after appending element: ['amit', 'kumar', 'baghel']\n"
     ]
    }
   ],
   "source": [
    "my_list = [\"amit\",\"kumar\"]\n",
    "new_element = \"baghel\"\n",
    "my_list.append(new_element)\n",
    "\n",
    "print(\"List after appending element:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d39a8fd0-262d-4bb2-8a54-d8478068d765",
   "metadata": {},
   "source": [
    "4. Insert an element at a specific index in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "410efcfe-8b20-438a-ad59-4a9c9b479067",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after inserting element: [1, 2, 11, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "new_element = 11\n",
    "index_to_insert = 2\n",
    " \n",
    "my_list.insert(index_to_insert, new_element)\n",
    "\n",
    "print(\"List after inserting element:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb6967f5-a611-4d4b-8e97-cf5c6c789a66",
   "metadata": {},
   "source": [
    "5. Remove an element from a list by its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "74e4f729-2aa2-4050-8148-6401c3cc23d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing element: [1, 2, 11, 22, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 11, 22, 4, 5]\n",
    "value_to_remove = 4\n",
    " \n",
    "my_list.remove(value_to_remove)\n",
    "\n",
    "print(\"List after removing element:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b578f0-4350-45b4-826f-76c1af3dac20",
   "metadata": {},
   "source": [
    "6. Remove an element from a list by its index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f40d9cbe-e7a7-4b4f-a7dd-cc086676729a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing element: [1, 2, 4, 5]\n",
      "Removed element: 3\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "index_to_remove = 2\n",
    " \n",
    "removed_element = my_list.pop(index_to_remove)\n",
    "\n",
    "print(\"List after removing element:\", my_list)\n",
    "print(\"Removed element:\", removed_element)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8223f335-0c70-4aed-889d-850e31036c26",
   "metadata": {},
   "source": [
    "7. Check if an element exists in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0eb6774a-f287-41b8-8e3a-af47f20c7b66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 exists in the list.\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 11, 5]\n",
    "element_to_check = 11\n",
    " \n",
    "if element_to_check in my_list:\n",
    "    print(f\"{element_to_check} exists in the list.\")\n",
    "else:\n",
    "    print(f\"{element_to_check} does not exist in the list.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "168b10b1-0659-4763-92ee-a61603df57a5",
   "metadata": {},
   "source": [
    "8. Find the index of the first occurrence of an element in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "90df8e98-6119-4454-bb50-8a5fb219d56c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The index of the first occurrence of 3 is: 2\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5, 3]\n",
    "element_to_find = 3\n",
    "index_of_element = my_list.index(element_to_find)\n",
    "\n",
    "print(f\"The index of the first occurrence of {element_to_find} is: {index_of_element}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acd0c1a4-272c-4d91-a9d2-a3e56e6bc839",
   "metadata": {},
   "source": [
    "9. Count the occurrences of an element in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "186a7aad-48db-412e-babd-9ebdc6b6bcdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The element 3 occurs 3 times in the list.\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5, 3, 3]\n",
    "element_to_count = 3\n",
    "count_of_element = my_list.count(element_to_count)\n",
    "\n",
    "print(f\"The element {element_to_count} occurs {count_of_element} times in the list.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2aab23e6-9a66-497a-bccb-7254090e63c1",
   "metadata": {},
   "source": [
    "10. Reverse the order of elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f2f29490-dcb0-4e3d-850d-56a1aacf22ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed list: [5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_list.reverse()\n",
    "\n",
    "print(\"Reversed list:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "793a75fe-648b-4307-ab1b-dc99e7545c84",
   "metadata": {},
   "source": [
    "11. Sort a list in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2474d14f-69e6-431b-a821-af9177f4ad47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ascending order: [1, 2, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "sort_a= [1,5,8,6,7,2,9]\n",
    "sort_a.sort()\n",
    "print(\"ascending order:\", sort_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0677dd43-1d14-4cd7-a82f-e2149cd3079a",
   "metadata": {},
   "source": [
    "12. Sort a list in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c66e40c4-548a-4d54-beaa-69871584b56e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ascending order: [9, 8, 7, 6, 5, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "sort_a= [1,5,8,6,7,2,9]\n",
    "sort_a.sort(reverse=True)\n",
    "print(\"ascending order:\", sort_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cba5e4b-76c6-4796-9ac9-a7a8a47076ce",
   "metadata": {},
   "source": [
    "13. Create a list of even numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a67526b2-7a8b-49ee-932d-b18c45880235",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of odd numbers from 1 to 20: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "odd_numbers = list(range(1, 21, 2))\n",
    "\n",
    "print(\"List of odd numbers from 1 to 20:\", odd_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f9c9eba-5b4f-46db-a8ab-93b4ec23238e",
   "metadata": {},
   "source": [
    "14. Create a list of odd numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "baa82fd4-5bbd-45e9-989d-36fa787cb73a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of odd numbers from 1 to 20: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "odd_numbers = list(range(1, 21, 2))\n",
    "\n",
    "print(\"List of odd numbers from 1 to 20:\", odd_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7a1297e-8296-462c-ba49-22f88236672d",
   "metadata": {},
   "source": [
    "15. Find the sum of all elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "482dfab1-845a-416f-9cc8-7c44b8f5558e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all elements: 15\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    " \n",
    "sum_of_elements = sum(my_list)\n",
    "\n",
    "print(\"Sum of all elements:\", sum_of_elements)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e01e5560-9dcb-4f94-a3ac-bf713d29db8e",
   "metadata": {},
   "source": [
    "16. Find the maximum value in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e7902279-f637-4ca1-abba-67fcecedac99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value: 9\n"
     ]
    }
   ],
   "source": [
    "my_list = [3, 7, 1, 9, 4, 6]\n",
    "max_value = max(my_list)\n",
    "\n",
    "print(\"Maximum value:\", max_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b7ffa9c-f83d-4dcb-beec-f570bb11c135",
   "metadata": {},
   "source": [
    "17. Find the minimum value in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e729cb51-4dfc-4505-92d9-98136a99737d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value: 1\n"
     ]
    }
   ],
   "source": [
    "my_list = [3, 7, 1, 9, 4, 6]\n",
    " \n",
    "min_value = min(my_list)\n",
    "\n",
    "print(\"Minimum value:\", min_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b719e15-493d-455a-b661-e4b32c33f5f5",
   "metadata": {},
   "source": [
    "18. Create a list of squares of numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "79989416-be19-40c8-951d-d61efc317cae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of squares of numbers from 1 to 10: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "squares_list = [x**2 for x in range(1, 11)]\n",
    "\n",
    "print(\"List of squares of numbers from 1 to 10:\", squares_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d114b31-1c3b-4d81-bc00-4aa0564dd01a",
   "metadata": {},
   "source": [
    "19. Create a list of random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0db88251-4895-4d1d-bbd3-1f21d032a292",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of random numbers: [5, 7, 6, 6, 2]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    " \n",
    "random_numbers = [random.randint(1, 10) for _ in range(5)]\n",
    "\n",
    "print(\"List of random numbers:\", random_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "674a5ed5-3d20-492b-bc9b-90dedf3fc65c",
   "metadata": {},
   "source": [
    "20. Remove duplicates from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "80e8a30a-4ac9-4f8e-b027-00de3ca38f58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing duplicates: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 2, 3, 4, 4, 5]\n",
    "unique_list = []\n",
    "for item in my_list:\n",
    "    if item not in unique_list:\n",
    "        unique_list.append(item)\n",
    "\n",
    "print(\"List after removing duplicates:\", unique_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e819f7-6e29-4d9e-ace1-6f33705dea7d",
   "metadata": {},
   "source": [
    "21. Find the common elements between two lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3c222112-aed1-4c01-a523-0247750b8214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements between the two lists: [3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [3, 4, 5, 6, 7]\n",
    " \n",
    "common_elements = list(set(list1).intersection(list2))\n",
    "\n",
    "print(\"Common elements between the two lists:\", common_elements)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a918edc-bf60-4661-94d5-2adc541edb50",
   "metadata": {},
   "source": [
    "22. Find the difference between two lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dd4ac20-ef8e-4738-8e61-facaf83aa81a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference between the two lists: [1, 2, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [3, 4, 5, 6, 7]\n",
    "\n",
    "difference_list = [item for item in list1 + list2 if item not in list1 or item not in list2]\n",
    "\n",
    "print(\"Difference between the two lists:\", difference_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "144fd363-c751-4201-9a7f-6e2106b2e511",
   "metadata": {},
   "source": [
    "23. Merge two lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "1c61b2c8-9c49-4cee-a4f7-23ade86d765d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged list: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    " \n",
    "list1.extend(list2)\n",
    "\n",
    "print(\"Merged list:\", list1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f26dab-1326-4f55-89e1-49278d431aa2",
   "metadata": {},
   "source": [
    "24. Multiply all elements in a list by 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "18e5b106-55ed-4dcc-b691-2a979a56eb8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5]\n",
      "Doubled list: [2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "original_list = [1, 2, 3, 4, 5]\n",
    " \n",
    "doubled_list = [element * 2 for element in original_list]\n",
    "\n",
    "print(\"Original list:\", original_list)\n",
    "print(\"Doubled list:\", doubled_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4a1d19f-4224-434d-837b-d9529da35fb4",
   "metadata": {},
   "source": [
    "25. Filter out all even numbers from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6644a151-a5ac-4de3-9ad7-9ca07d157724",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "Filtered list (without even numbers): [1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    " \n",
    "filtered_list = [number for number in original_list if number % 2 != 0]\n",
    "\n",
    "print(\"Original list:\", original_list)\n",
    "print(\"Filtered list (without even numbers):\", filtered_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f8eaaa0-0c71-4b8b-8610-6b966f372513",
   "metadata": {},
   "source": [
    "26. Convert a list of strings to a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "df573a97-ad72-4690-a753-a634e1b85f04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of strings: ['1', '2', '3', '4', '5']\n",
      "Converted list of integers: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "string_list = ['1', '2', '3', '4', '5']\n",
    " \n",
    "integer_list = [int(element) for element in string_list]\n",
    "\n",
    "print(\"Original list of strings:\", string_list)\n",
    "print(\"Converted list of integers:\", integer_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65e680d9-8069-44b6-a680-ecd12a76904e",
   "metadata": {},
   "source": [
    "27. Convert a list of integers to a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "b8b08949-c3d3-475f-b82e-826e8709b614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of integers: [1, 2, 3, 4, 5]\n",
      "Converted list of strings: ['1', '2', '3', '4', '5']\n"
     ]
    }
   ],
   "source": [
    "integer_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Convert the list of integers to a list of strings\n",
    "string_list = [str(element) for element in integer_list]\n",
    "\n",
    "print(\"Original list of integers:\", integer_list)\n",
    "print(\"Converted list of strings:\", string_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22591c4a-5b15-4d56-a8a2-b0886af53fcb",
   "metadata": {},
   "source": [
    "28. Flatten a nested list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "85f84ccc-b879-418d-946d-aebbcad309de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original nested list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "Flattened list: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "# Flatten the nested list using list comprehension\n",
    "flattened_list = [item for sublist in nested_list for item in sublist]\n",
    "\n",
    "print(\"Original nested list:\", nested_list)\n",
    "print(\"Flattened list:\", flattened_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cb56c02-ee35-46eb-ad0d-6c39e8224c1d",
   "metadata": {},
   "source": [
    "29. Create a list of the first 10 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f2d94536-e2f5-4f1f-9904-5f1d3ebabd32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 10 Fibonacci numbers: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "# Function to generate the first n Fibonacci numbers\n",
    "def generate_fibonacci(n):\n",
    "    fibonacci_list = [0, 1]\n",
    "    while len(fibonacci_list) < n:\n",
    "        next_number = fibonacci_list[-1] + fibonacci_list[-2]\n",
    "        fibonacci_list.append(next_number)\n",
    "    return fibonacci_list\n",
    "\n",
    "# Generate the first 10 Fibonacci numbers\n",
    "first_10_fibonacci = generate_fibonacci(10)\n",
    "\n",
    "print(\"First 10 Fibonacci numbers:\", first_10_fibonacci)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59f63d54-1c71-4c8a-8baf-3e79620e8be2",
   "metadata": {},
   "source": [
    "30. Check if a list is sorted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "31863fd1-5d74-4d10-a7b4-785300b266d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is sorted: True\n",
      "Is sorted: False\n"
     ]
    }
   ],
   "source": [
    "def is_sorted(input_list):\n",
    "    return all(input_list[i] <= input_list[i + 1] for i in range(len(input_list) - 1))\n",
    "\n",
    "# Example usage\n",
    "sorted_list = [1, 2, 3, 4, 5]\n",
    "unsorted_list = [5, 2, 8, 1, 3]\n",
    "\n",
    "print(\"Is sorted:\", is_sorted(sorted_list))\n",
    "print(\"Is sorted:\", is_sorted(unsorted_list))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fda81b7-ae13-4347-81e1-99b1a19f9b61",
   "metadata": {},
   "source": [
    "31. Rotate a list to the left by `n` positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "b122643a-775d-4230-a9df-58782ef7c659",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5]\n",
      "Rotated list: [3, 4, 5, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "def rotate_left(input_list, n):\n",
    "    n = n % len(input_list)   \n",
    "    return input_list[n:] + input_list[:n]\n",
    " \n",
    "original_list = [1, 2, 3, 4, 5]\n",
    "rotated_list = rotate_left(original_list, 2)\n",
    "\n",
    "print(\"Original list:\", original_list)\n",
    "print(\"Rotated list:\", rotated_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "723ecc76-aad1-4e41-80ab-2827ebf4a66f",
   "metadata": {},
   "source": [
    "32. Rotate a list to the right by `n` positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9f07b8a2-4f42-43de-a72b-56e7128d00e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 3, 4, 5]\n",
      "Rotated list: [4, 5, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def rotate_right(input_list, n):\n",
    "    n = n % len(input_list) \n",
    "    return input_list[-n:] + input_list[:-n]\n",
    " \n",
    "original_list = [1, 2, 3, 4, 5]\n",
    " \n",
    "rotated_list = rotate_right(original_list, 2)\n",
    "\n",
    "print(\"Original list:\", original_list)\n",
    "print(\"Rotated list:\", rotated_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b90e2a4-b63a-47a4-8064-f9c6483e765e",
   "metadata": {},
   "source": [
    "33. Create a list of prime numbers up to 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "38b38623-350b-4d80-8abf-a3076cb3b441",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime numbers up to 50: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    if num < 2:\n",
    "        return False\n",
    "    for i in range(2, int(num**0.5) + 1):\n",
    "        if num % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "# Generate a list of prime numbers up to 50\n",
    "prime_numbers = [num for num in range(2, 51) if is_prime(num)]\n",
    "\n",
    "print(\"List of prime numbers up to 50:\", prime_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f45a8c77-f20b-4853-9a6c-4ac2f4902eea",
   "metadata": {},
   "source": [
    "34. Split a list into chunks of size `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f54f5895-e3b7-4282-a1de-87b333342c01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "def chunk_list(input_list, chunk_size):\n",
    " \n",
    "    return [input_list[i:i + chunk_size] for i in range(0, len(input_list), chunk_size)]\n",
    "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "chunk_size = 3\n",
    "result = chunk_list(my_list, chunk_size)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cebd2a17-f1f0-4ac2-a85e-4437eed7e333",
   "metadata": {},
   "source": [
    "35. Find the second largest number in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cdc6352b-c2ab-4b63-895f-c9a32fd7eb65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second largest number: 15\n"
     ]
    }
   ],
   "source": [
    "def find_second_largest(numbers):\n",
    "    if len(numbers) < 2:\n",
    "        return \"List must have at least two elements\"\n",
    "\n",
    "    max_num = max(numbers)\n",
    "    numbers.remove(max_num)\n",
    "    second_largest = max(numbers)\n",
    "\n",
    "    return second_largest\n",
    "my_numbers = [10, 5, 8, 20, 15]\n",
    "result = find_second_largest(my_numbers)\n",
    "print(\"Second largest number:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e7dfb86-8a58-498f-b5b3-4df8645b6378",
   "metadata": {},
   "source": [
    "36. Replace every element in a list with its square."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "679b1757-0483-4716-a4ab-1044417ff603",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "def square_elements(input_list):\n",
    " \n",
    "    return [x**2 for x in input_list]\n",
    " \n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "result = square_elements(my_list)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c52e538-f661-450d-be65-69f921ad652c",
   "metadata": {},
   "source": [
    "37. Convert a list to a dictionary where list elements become keys and their\n",
    "indices become values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a359da17-7359-4ee1-968e-fc8db71ab277",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 0, 'banana': 1, 'orange': 2, 'grape': 3}\n"
     ]
    }
   ],
   "source": [
    "def list_to_dict(input_list):\n",
    "\n",
    "    return {element: index for index, element in enumerate(input_list)}\n",
    "\n",
    "my_list = ['apple', 'banana', 'orange', 'grape']\n",
    "result_dict = list_to_dict(my_list)\n",
    "print(result_dict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63df05ba-a155-415f-b7cc-87cbf841b944",
   "metadata": {},
   "source": [
    "38. Shuffle the elements of a list randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cd784041-c743-49bb-ae6f-fa189902c8b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shuffled List: [5, 1, 3, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "random.shuffle(my_list)\n",
    "\n",
    "print(\"Shuffled List:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa623c4f-e904-4c66-ab17-d63189b3b60d",
   "metadata": {},
   "source": [
    "39. Create a list of the first 10 factorial numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "52f18255-506e-47fd-be69-fd07db5b3cae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 10 factorial numbers: [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    " \n",
    "def factorial(n):\n",
    "    return math.factorial(n)\n",
    "factorial_list = [factorial(i) for i in range(10)]\n",
    "\n",
    "print(\"List of the first 10 factorial numbers:\", factorial_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b2f71ab-bb57-4ecf-a4e7-17b55cfac009",
   "metadata": {},
   "source": [
    "40. Check if two lists have at least one element in common."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "63c2626b-c715-4174-89dc-f825e37508f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lists have at least one common element.\n"
     ]
    }
   ],
   "source": [
    "def have_common_element(list1, list2):\n",
    "    return any(element in list2 for element in list1)\n",
    "\n",
    "list_a = [1, 2, 3, 4, 5]\n",
    "list_b = [5, 6, 7, 8, 9]\n",
    "result = have_common_element(list_a, list_b)\n",
    "\n",
    "if result:\n",
    "    print(\"The lists have at least one common element.\")\n",
    "else:\n",
    "    print(\"The lists do not have any common elements.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6551c9a0-aed9-4e38-a8d0-c9983ec143f5",
   "metadata": {},
   "source": [
    "41. Remove all elements from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4e9c3270-c69f-4222-ab27-5797e20c781d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing all elements: []\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_list.clear()\n",
    "\n",
    "print(\"List after removing all elements:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd457ef-2172-4b2a-949a-c24867a48888",
   "metadata": {},
   "source": [
    "42. Replace negative numbers in a list with 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0666f348-aadb-4f54-a639-8800b73919ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, -2, 3, -4, 5, -6]\n",
      "Modified List (negative numbers replaced with 0): [1, 0, 3, 0, 5, 0]\n"
     ]
    }
   ],
   "source": [
    "original_list = [1, -2, 3, -4, 5, -6]\n",
    "modified_list = [0 if num < 0 else num for num in original_list]\n",
    "\n",
    "print(\"Original List:\", original_list)\n",
    "print(\"Modified List (negative numbers replaced with 0):\", modified_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8845a27-dae9-4e98-814d-77c3bb836541",
   "metadata": {},
   "source": [
    "43. Convert a string into a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8dc93a31-83d2-427f-a96a-b9d60181746c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String: amit kumar\n",
      "List of Words: ['amit', 'kumar']\n"
     ]
    }
   ],
   "source": [
    "my_string = \"amit kumar\"\n",
    "word_list = my_string.split()\n",
    "\n",
    "print(\"Original String:\", my_string)\n",
    "print(\"List of Words:\", word_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb8d8e4b-b8f9-481e-9d2d-03229f424815",
   "metadata": {},
   "source": [
    "44. Convert a list of words into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6b7b902e-2a58-4b8a-8139-2268e230fea0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of Words: ['apple', 'banana', 'orange']\n",
      "Resulting String: apple, banana, orange\n"
     ]
    }
   ],
   "source": [
    "word_list = [\"apple\", \"banana\", \"orange\"]\n",
    "result_string = ', '.join(word_list)\n",
    "\n",
    "print(\"List of Words:\", word_list)\n",
    "print(\"Resulting String:\", result_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9233f70-5c56-4bff-95c5-38f57e7ae4f9",
   "metadata": {},
   "source": [
    "45. Create a list of the first `n` powers of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "23ef8ce0-ba4b-43ca-88c0-9cf6a00815cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 5 powers of 2: [1, 2, 4, 8, 16]\n"
     ]
    }
   ],
   "source": [
    "n = 5  \n",
    "powers_of_2 = [2**i for i in range(n)]\n",
    "\n",
    "print(\"List of the first\", n, \"powers of 2:\", powers_of_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "185fe84b-ec93-40d9-91c8-d923f21f931f",
   "metadata": {},
   "source": [
    "46. Find the longest string in a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "93714891-73b7-4239-8b93-f7879cec1e66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list is empty.\n"
     ]
    }
   ],
   "source": [
    "string_list = []\n",
    "\n",
    "if string_list:\n",
    "    longest_string = max(string_list, key=len)\n",
    "    print(\"List of Strings:\", string_list)\n",
    "    print(\"Longest String:\", longest_string)\n",
    "else:\n",
    "    print(\"The list is empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49fbfe3-e9e8-407e-98d2-1b2e297a47d6",
   "metadata": {},
   "source": [
    "47. Find the shortest string in a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "03a87c91-2ffc-44b6-954b-df971d222b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list is empty.\n"
     ]
    }
   ],
   "source": [
    "string_list = []\n",
    "\n",
    "if string_list:\n",
    "    shortest_string = min(string_list, key=len)\n",
    "    print(\"List of Strings:\", string_list)\n",
    "    print(\"Shortest String:\", shortest_string)\n",
    "else:\n",
    "    print(\"The list is empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc9c4837-c23f-4e21-aef2-7c812f0166fa",
   "metadata": {},
   "source": [
    " 48. Create a list of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a446905e-1992-4b00-ae9c-54b51905e2e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 5 triangular numbers: [1, 3, 6, 10, 15]\n"
     ]
    }
   ],
   "source": [
    "n = 5  \n",
    "triangular_numbers = [sum(range(1, i + 1)) for i in range(1, n + 1)]\n",
    "\n",
    "print(\"List of the first\", n, \"triangular numbers:\", triangular_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cd2f534-1a71-40c3-b848-aab73c768c94",
   "metadata": {},
   "source": [
    "49. Check if a list contains another list as a subsequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "faac22ec-4daa-4ae5-95e2-abdf367037fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The subsequence is present in the larger list.\n"
     ]
    }
   ],
   "source": [
    "def is_subsequence(subsequence, larger_list):\n",
    "    # Initialize indices for both lists\n",
    "    subseq_index = 0\n",
    "    larger_index = 0\n",
    "\n",
    "    # Iterate through the larger list\n",
    "    while larger_index < len(larger_list) and subseq_index < len(subsequence):\n",
    "         \n",
    "        if subsequence[subseq_index] == larger_list[larger_index]:\n",
    "            subseq_index += 1\n",
    " \n",
    "        larger_index += 1\n",
    "    return subseq_index == len(subsequence)\n",
    "\n",
    "larger_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "subsequence_to_check = [3, 5, 8]\n",
    "\n",
    "result = is_subsequence(subsequence_to_check, larger_list)\n",
    "\n",
    "if result:\n",
    "    print(\"The subsequence is present in the larger list.\")\n",
    "else:\n",
    "    print(\"The subsequence is not present in the larger list.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d895b8cf-bd56-4cb2-be47-3c44ff3b4587",
   "metadata": {},
   "source": [
    "50. Swap two elements in a list by their indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0e66e563-fcf1-42b7-b483-d98671299dbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, 2, 3, 4, 5]\n",
      "List after swapping elements: [1, 4, 3, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "def swap_elements(lst, index1, index2):\n",
    "    if 0 <= index1 < len(lst) and 0 <= index2 < len(lst):\n",
    "       \n",
    "        temp = lst[index1]\n",
    "        lst[index1] = lst[index2]\n",
    "        lst[index2] = temp\n",
    "    else:\n",
    "        print(\"Invalid indices. Unable to swap elements.\")\n",
    "\n",
    " \n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "print(\"Original List:\", my_list)\n",
    "\n",
    "# Swap elements at indices 1 and 3\n",
    "swap_elements(my_list, 1, 3)\n",
    "\n",
    "print(\"List after swapping elements:\", my_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cedf62d-4f6a-464e-a0b2-17d4a9d29057",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caa39d01-028a-4ab6-8df8-5cfe74313adf",
   "metadata": {},
   "source": [
    "                                            Tuple Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6599a16-939e-433c-845c-e829943f9264",
   "metadata": {},
   "source": [
    "1. Create a tuple with integers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "91f918d1-b428-4991-9d0a-edec5f10c4f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "print(my_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0355e8ee-ced7-4568-ae41-afd8f272943f",
   "metadata": {},
   "source": [
    "2. Access the third element of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4a541dda-7dad-407e-8875-c093daf31b14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 50)\n",
    " \n",
    "third_element = my_tuple[2]\n",
    "print(third_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9daf0179-a4a8-4950-ae93-459b1a38d01b",
   "metadata": {},
   "source": [
    "3. Find the length of a tuple without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "07ebc053-dd61-4291-9f70-036b8a54dae3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the tuple: 5\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 50)\n",
    "tuple_length = 0\n",
    "for _ in my_tuple:\n",
    "    tuple_length += 1\n",
    "\n",
    " \n",
    "print(\"Length of the tuple:\", tuple_length)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60f8c414-4991-4c27-abc2-0794dea6fb25",
   "metadata": {},
   "source": [
    "4. Count the occurrences of an element in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "07c99695-39b9-4382-a7f0-cde8844a7b24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Occurrences of 30 in the tuple: 3\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 30, 50, 30)\n",
    "element_to_count = 30\n",
    "count = 0\n",
    "\n",
    "for item in my_tuple:\n",
    "    if item == element_to_count:\n",
    "        count += 1\n",
    "print(\"Occurrences of\", element_to_count, \"in the tuple:\", count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d8c070-598f-4cb3-b348-6c92f84e4bec",
   "metadata": {},
   "source": [
    "5. Find the index of the first occurrence of an element in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "83ddd560-be43-4fc3-81db-b85a356d9d2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index of the first occurrence of 30 in the tuple: 2\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 30, 50, 30)\n",
    "element_to_find = 30\n",
    "index = None\n",
    "for i in range(len(my_tuple)):\n",
    "    if my_tuple[i] == element_to_find:\n",
    "        index = i\n",
    "        break  \n",
    "if index is not None:\n",
    "    print(\"Index of the first occurrence of\", element_to_find, \"in the tuple:\", index)\n",
    "else:\n",
    "    print(element_to_find, \"not found in the tuple.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aa80226-f835-43f3-aa5f-2b4766b6253f",
   "metadata": {},
   "source": [
    "6. Check if an element exists in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b2144d01-c3dc-4455-9ef4-bf27bb78e7b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 exists in the tuple.\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 50)\n",
    "element_to_check = 30\n",
    "element_exists = False\n",
    "for item in my_tuple:\n",
    "    if item == element_to_check:\n",
    "        element_exists = True\n",
    "        break   \n",
    "\n",
    "if element_exists:\n",
    "    print(element_to_check, \"exists in the tuple.\")\n",
    "else:\n",
    "    print(element_to_check, \"does not exist in the tuple.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7621d090-03be-459a-ad5e-d20913853bd1",
   "metadata": {},
   "source": [
    "7. Convert a tuple to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b8c07dc1-22d6-4612-9a94-38b4b829bea6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple: (10, 20, 30, 40, 50)\n",
      "List: [10, 20, 30, 40, 50]\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 50)\n",
    "my_list = list(my_tuple)\n",
    "print(\"Tuple:\", my_tuple)\n",
    "print(\"List:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d4b1f6d-aaa1-410f-ae17-d272387cf8a7",
   "metadata": {},
   "source": [
    "8. Convert a list to a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "733da5cd-42bd-49fc-b0c0-b027b28b3bb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: [10, 20, 30, 40, 50]\n",
      "Tuple: (10, 20, 30, 40, 50)\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    " \n",
    "my_tuple = tuple(my_list)\n",
    "\n",
    "print(\"List:\", my_list)\n",
    "print(\"Tuple:\", my_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d1f5a52-ba33-4804-aa95-c6af3d3670cf",
   "metadata": {},
   "source": [
    "9. Unpack the elements of a tuple into variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "af15a7c6-22b3-4f42-8ec0-f979f71af9f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable 1: 10\n",
      "Variable 2: 20\n",
      "Variable 3: 30\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30)\n",
    "var1, var2, var3 = my_tuple\n",
    "\n",
    "print(\"Variable 1:\", var1)\n",
    "print(\"Variable 2:\", var2)\n",
    "print(\"Variable 3:\", var3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d9e8bb0-02ce-4f1b-acd2-5228b128397a",
   "metadata": {},
   "source": [
    "10. Create a tuple of even numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "033c62f5-022c-4365-9d0c-307bb279ec8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of even numbers: (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "even_numbers_tuple = tuple(x for x in range(2, 11, 2))\n",
    "print(\"Tuple of even numbers:\", even_numbers_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bef7d1c2-48d7-444c-a82d-16b60cb2bb7e",
   "metadata": {},
   "source": [
    "11. Create a tuple of odd numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b9333191-d20b-4ff8-b130-669cc7ad39fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of odd numbers: (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    " \n",
    "odd_numbers_tuple = tuple(x for x in range(1, 11, 2))\n",
    " \n",
    "print(\"Tuple of odd numbers:\", odd_numbers_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59c54ad9-14ac-4e97-8a58-7caaf6636f0d",
   "metadata": {},
   "source": [
    "12. Concatenate two tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8744c29a-94d2-4a4f-8a22-26f5a4067b9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concatenated tuple: (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (4, 5, 6)\n",
    "\n",
    "concatenated_tuple = tuple1 + tuple2\n",
    "\n",
    "print(\"Concatenated tuple:\", concatenated_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4d94c68-4620-4063-9307-511468fd7665",
   "metadata": {},
   "source": [
    "13. Repeat a tuple three times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "78c87a72-5fd8-47c7-bb33-1ece567bea43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3)\n",
      "Repeated tuple three times: (1, 2, 3, 1, 2, 3, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "original_tuple = (1, 2, 3)\n",
    " \n",
    "repeated_tuple = original_tuple * 3\n",
    "  \n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(\"Repeated tuple three times:\", repeated_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9ebbfd7-49a6-46a6-a5c0-c012db9cc2d2",
   "metadata": {},
   "source": [
    "14. Check if a tuple is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "be7cfe5d-9ba7-4d6e-b36a-23a386c84fbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple is empty.\n"
     ]
    }
   ],
   "source": [
    "my_tuple = ()\n",
    "if not my_tuple:\n",
    "    print(\"The tuple is empty.\")\n",
    "else:\n",
    "    print(\"The tuple is not empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c900ecc8-2c82-4adf-a62a-4070b6ec9548",
   "metadata": {},
   "source": [
    "15. Create a nested tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "41b7f16e-7472-4686-ab02-9d3b0d54f040",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested Tuple: ((1, 2, 3), ('a', 'b', 'c'), (True, False))\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = ((1, 2, 3), ('a', 'b', 'c'), (True, False))\n",
    "print(\"Nested Tuple:\", nested_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d79d3b33-38f1-4c25-972c-67694f34c05e",
   "metadata": {},
   "source": [
    "16. Access the first element of a nested tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2bb237cd-6df7-4f96-9a6b-063d1daefe50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First element of the nested tuple: 1\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = ((1, 2, 3), ('a', 'b', 'c'), (True, False))\n",
    "first_element = nested_tuple[0][0]\n",
    "\n",
    "print(\"First element of the nested tuple:\", first_element)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8399bf0-6cd3-4f4b-986d-0cbabd62dfc2",
   "metadata": {},
   "source": [
    "17. Create a tuple with a single element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d7813473-16e0-4199-b02c-d3b9ea0b7467",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with a single element: (42,)\n"
     ]
    }
   ],
   "source": [
    "single_element_tuple = (42,)\n",
    "print(\"Tuple with a single element:\", single_element_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0fbe1a8-0460-4cbc-a363-a03113ea5707",
   "metadata": {},
   "source": [
    "18. Compare two tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "647892e0-8d58-4320-b742-36886f64b432",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuples are equal.\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 3)\n",
    "if tuple1 == tuple2:\n",
    "    print(\"Tuples are equal.\")\n",
    "else:\n",
    "    print(\"Tuples are not equal.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49030d16-a093-4780-85be-0add0826e1bc",
   "metadata": {},
   "source": [
    "19. Delete a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "8008080a-16a1-486d-8ad0-82e898138a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "del my_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab8ef5d4-bbac-464f-9e21-c580560ac64c",
   "metadata": {},
   "source": [
    "20. Slice a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a730776d-46a3-4d5c-a18c-76c10f24e502",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (10, 20, 30, 40, 50)\n",
      "Sliced tuple: (20, 30, 40)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30, 40, 50)\n",
    "sliced_tuple = my_tuple[1:4]\n",
    "print(\"Original tuple:\", my_tuple)\n",
    "print(\"Sliced tuple:\", sliced_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a68556a5-e4f1-44ef-b320-5a274e6d2be6",
   "metadata": {},
   "source": [
    "21. Find the maximum value in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "605653aa-c248-4eae-afa9-eac4493dfb6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value in the tuple: 89\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 45, 23, 67, 89, 12)\n",
    "max_value = max(my_tuple)\n",
    "print(\"Maximum value in the tuple:\", max_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a6e022-b6d0-4cb7-b35d-7663df247ff6",
   "metadata": {},
   "source": [
    "22. Find the minimum value in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "a4a61125-6af1-4e44-bb97-7140581a8476",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value in the tuple: 10\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 45, 23, 67, 89, 12)\n",
    "min_value = min(my_tuple)\n",
    "print(\"Minimum value in the tuple:\", min_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80f7e490-a201-4335-a6f6-5a755e1fbb85",
   "metadata": {},
   "source": [
    "23. Convert a string to a tuple of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "1f57201d-e105-410c-acc4-484fb49acf97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String: Hello, World!\n",
      "Tuple of characters: ('H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!')\n"
     ]
    }
   ],
   "source": [
    "my_string = \"Hello, World!\"\n",
    "char_tuple = tuple(my_string)\n",
    "\n",
    "print(\"String:\", my_string)\n",
    "print(\"Tuple of characters:\", char_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6952b41a-42a6-44f3-af8b-ebb688edac0b",
   "metadata": {},
   "source": [
    "24. Convert a tuple of characters to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f955648b-19e9-4faf-8cd0-d28438f51b2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of characters: ('H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!')\n",
      "Resulting string: Hello, World!\n"
     ]
    }
   ],
   "source": [
    "char_tuple = ('H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!') \n",
    "resulting_string = ''.join(char_tuple)\n",
    "\n",
    "print(\"Tuple of characters:\", char_tuple)\n",
    "print(\"Resulting string:\", resulting_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15b0b9eb-00a8-4c29-9d06-8330bb4d378e",
   "metadata": {},
   "source": [
    "25. Create a tuple from multiple data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e04b217e-eee2-4bfd-878a-b84adb2ec248",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mixed Tuple: (1, 'hello', 3.14, True)\n"
     ]
    }
   ],
   "source": [
    "mixed_tuple = (1, 'hello', 3.14, True)\n",
    "print(\"Mixed Tuple:\", mixed_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b23352c-bf3f-4dc8-a622-cd831e2ab3fd",
   "metadata": {},
   "source": [
    "26. Check if two tuples are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8ae18e90-a52d-4a89-8e3c-e2d284b8145f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuples are identical.\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 3)\n",
    "if tuple1 == tuple2:\n",
    "    print(\"Tuples are identical.\")\n",
    "else:\n",
    "    print(\"Tuples are not identical.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ad207f0-1ad2-43ac-a66a-c26561907f2a",
   "metadata": {},
   "source": [
    "27. Sort the elements of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4eb983f7-d76a-4991-b025-30215506e56a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (4, 2, 8, 1, 6)\n",
      "Sorted tuple: (1, 2, 4, 6, 8)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (4, 2, 8, 1, 6)\n",
    "sorted_tuple = tuple(sorted(list(my_tuple)))\n",
    "\n",
    "print(\"Original tuple:\", my_tuple)\n",
    "print(\"Sorted tuple:\", sorted_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27c04146-4c33-46d2-b6d7-d72f674691dd",
   "metadata": {},
   "source": [
    "28. Convert a tuple of integers to a tuple of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "849cbe2d-e49b-4a74-b043-c5273e011d87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of integers: (1, 2, 3, 4, 5)\n",
      "Tuple of strings: ('1', '2', '3', '4', '5')\n"
     ]
    }
   ],
   "source": [
    "tuple_of_integers = (1, 2, 3, 4, 5)\n",
    "tuple_of_strings = tuple(map(str, tuple_of_integers))\n",
    "\n",
    "print(\"Tuple of integers:\", tuple_of_integers)\n",
    "print(\"Tuple of strings:\", tuple_of_strings)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f9834b7-8b77-4fd1-9927-32a7b87608f0",
   "metadata": {},
   "source": [
    "29. Convert a tuple of strings to a tuple of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "66e8a300-0aa6-40df-b06b-abe79b6604ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of strings: ('1', '2', '3', '4', '5')\n",
      "Tuple of integers: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "tuple_of_strings = ('1', '2', '3', '4', '5')\n",
    "tuple_of_integers = tuple(map(int, tuple_of_strings))\n",
    " \n",
    "print(\"Tuple of strings:\", tuple_of_strings)\n",
    "print(\"Tuple of integers:\", tuple_of_integers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c4aa335-833c-4fea-a832-ed23224dcd68",
   "metadata": {},
   "source": [
    "30. Merge two tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0716c048-036b-448b-b54d-0f4b5172f9c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple 1: (1, 2, 3)\n",
      "Tuple 2: ('a', 'b', 'c')\n",
      "Merged tuple: (1, 2, 3, 'a', 'b', 'c')\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = ('a', 'b', 'c')\n",
    "\n",
    "merged_tuple = tuple1 + tuple2\n",
    "\n",
    "print(\"Tuple 1:\", tuple1)\n",
    "print(\"Tuple 2:\", tuple2)\n",
    "print(\"Merged tuple:\", merged_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d17b6bf-7280-4f7e-b3e4-addb640f0cdf",
   "metadata": {},
   "source": [
    "31. Flatten a nested tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ce3165ee-c0dc-4507-a77d-e5eb1450349c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested Tuple: ((1, 2, 3), ('a', 'b', 'c'), (True, False))\n",
      "Flattened Tuple: (1, 2, 3, 'a', 'b', 'c', True, False)\n"
     ]
    }
   ],
   "source": [
    "from itertools import chain\n",
    " \n",
    "nested_tuple = ((1, 2, 3), ('a', 'b', 'c'), (True, False))\n",
    "\n",
    "flattened_tuple = tuple(chain(*nested_tuple))\n",
    "print(\"Nested Tuple:\", nested_tuple)\n",
    "print(\"Flattened Tuple:\", flattened_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c8b6736-a3e8-4795-80af-b313a6267de0",
   "metadata": {},
   "source": [
    "32. Create a tuple of the first 5 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "32d86a5b-5e8c-48d4-a1eb-9b67a9eceb54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first 5 prime numbers: (2, 3, 5, 7, 11)\n"
     ]
    }
   ],
   "source": [
    "prime_numbers = (2, 3, 5, 7, 11)\n",
    "\n",
    "print(\"Tuple of the first 5 prime numbers:\", prime_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e914972f-2296-4d9c-9975-e461d50c11ac",
   "metadata": {},
   "source": [
    "33. Check if a tuple is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7bfd9f2-f9d4-493c-9207-5c248cec38c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_palindrome(t):\n",
    "    return t == t[::-1]\n",
    "palindrome_tuple = (1, 2, 3, 4, 3, 2, 1)\n",
    "print(\"Is the tuple a palindrome?\", is_palindrome(palindrome_tuple))\n",
    " \n",
    "non_palindrome_tuple = (1, 2, 3, 4, 5)\n",
    "print(\"Is the tuple a palindrome?\", is_palindrome(non_palindrome_tuple))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8a120e3-3ac0-43d1-80df-1f706c7b43bc",
   "metadata": {},
   "source": [
    "34. Create a tuple of squares of numbers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "41512e17-fbe6-482b-bcce-da397ed403c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of squares: (1, 4, 9, 16, 25)\n"
     ]
    }
   ],
   "source": [
    "squares_tuple = tuple(x**2 for x in range(1, 6))\n",
    "\n",
    "print(\"Tuple of squares:\", squares_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddffc4d1-8391-455d-aeb0-db621e1a2f3f",
   "metadata": {},
   "source": [
    "35. Filter out all even numbers from a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "05e5ef97-5eb0-4dd2-96cd-d7c44d97b660",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
      "Filtered tuple (odd numbers only): (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "original_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
    "filtered_tuple = tuple(x for x in original_tuple if x % 2 != 0)\n",
    "\n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(\"Filtered tuple (odd numbers only):\", filtered_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f610ef93-9fe6-477c-a132-e6548faa346b",
   "metadata": {},
   "source": [
    "36. Multiply all elements in a tuple by 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f206d18c-1fe0-4e63-a598-9989ad4c4743",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5)\n",
      "Multiplied tuple: (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "original_tuple = (1, 2, 3, 4, 5)\n",
    "multiplied_tuple = tuple(x * 2 for x in original_tuple)\n",
    " \n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(\"Multiplied tuple:\", multiplied_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a43e8f2-fad9-4a9d-9d9b-d2a515224104",
   "metadata": {},
   "source": [
    "37. Create a tuple of random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "c20aedc4-427d-40fb-ba20-d7ac787d689e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of random numbers: (0.22501415149713322, 0.628740190193067, 0.2138731038040742, 0.9090337207243792, 0.7550388729814095)\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "random_numbers_tuple = tuple(random.uniform(0, 1) for _ in range(5))\n",
    "\n",
    "print(\"Tuple of random numbers:\", random_numbers_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f4f89dc-3fdf-407e-b88e-47358fdecdc6",
   "metadata": {},
   "source": [
    "38. Check if a tuple is sorted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "3fd7f9c7-f880-498d-962b-404bac91085c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the tuple sorted? True\n",
      "Is the tuple sorted? False\n"
     ]
    }
   ],
   "source": [
    "def is_sorted(t):\n",
    "    return t == tuple(sorted(t))\n",
    "sorted_tuple = (1, 2, 3, 4, 5)\n",
    "print(\"Is the tuple sorted?\", is_sorted(sorted_tuple))\n",
    "\n",
    "unsorted_tuple = (5, 2, 8, 1, 3)\n",
    "print(\"Is the tuple sorted?\", is_sorted(unsorted_tuple))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "157c4ea4-db36-405d-87dc-bd5065456354",
   "metadata": {},
   "source": [
    "39. Rotate a tuple to the left by `n` positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "e008cbbe-cda1-4028-b9b8-d69033da3552",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5)\n",
      "Rotated left by 2 positions: (3, 4, 5, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "def rotate_left(t, n):\n",
    "    n = n % len(t)  \n",
    "    rotated_tuple = t[n:] + t[:n]\n",
    "    return rotated_tuple\n",
    "\n",
    "original_tuple = (1, 2, 3, 4, 5)\n",
    "n_positions = 2\n",
    "rotated_tuple = rotate_left(original_tuple, n_positions)\n",
    " \n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(f\"Rotated left by {n_positions} positions:\", rotated_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6755d3b9-0132-47f9-a5f9-b880ed1a3da9",
   "metadata": {},
   "source": [
    "40. Rotate a tuple to the right by `n` positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "b819d6b9-ad2c-408e-bb49-83a8aacf60ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5)\n",
      "Rotated right by 2 positions: (4, 5, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "def rotate_right(t, n):\n",
    "    n = n % len(t)  \n",
    "    rotated_tuple = t[-n:] + t[:-n]\n",
    "    return rotated_tuple\n",
    "original_tuple = (1, 2, 3, 4, 5)\n",
    "n_positions = 2\n",
    "rotated_tuple = rotate_right(original_tuple, n_positions)\n",
    " \n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(f\"Rotated right by {n_positions} positions:\", rotated_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a7eb87-1fd9-4b4b-9d9d-052ff715f278",
   "metadata": {},
   "source": [
    "41. Create a tuple of the first 5 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "282c5223-0de1-4f64-9efa-b45f70cf50c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first 5 Fibonacci numbers: (0, 1, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "def generate_fibonacci(n):\n",
    "    fibonacci_numbers = [0, 1]\n",
    "    while len(fibonacci_numbers) < n:\n",
    "        next_number = fibonacci_numbers[-1] + fibonacci_numbers[-2]\n",
    "        fibonacci_numbers.append(next_number)\n",
    "    return tuple(fibonacci_numbers)\n",
    "first_five_fibonacci = generate_fibonacci(5)\n",
    "print(\"Tuple of the first 5 Fibonacci numbers:\", first_five_fibonacci)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8b1f970-388a-47cb-9d28-cbccf2dbf7dd",
   "metadata": {},
   "source": [
    "42. Create a tuple from user input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "3e9ee26e-766f-4f57-a699-d644826c1be2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter elements of the tuple separated by spaces:  (1,5,5,8,8)\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '(1,5,5,8,8)'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[60], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m input_string \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnter elements of the tuple separated by spaces: \u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      2\u001b[0m input_list \u001b[38;5;241m=\u001b[39m input_string\u001b[38;5;241m.\u001b[39msplit()\n\u001b[0;32m----> 4\u001b[0m user_tuple \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minput_list\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUser input as a tuple:\u001b[39m\u001b[38;5;124m\"\u001b[39m, user_tuple)\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '(1,5,5,8,8)'"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter elements of the tuple separated by spaces: \")\n",
    "input_list = input_string.split()\n",
    "\n",
    "user_tuple = tuple(map(int, input_list))\n",
    " \n",
    "print(\"User input as a tuple:\", user_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "311f3f95-a032-4c5c-b279-4645d211be94",
   "metadata": {},
   "source": [
    "43. Swap two elements in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "081e5d80-5cf7-4784-824b-0568169affd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5)\n",
      "Tuple after swapping elements at indices 1 and 3: (1, 4, 3, 2, 5)\n"
     ]
    }
   ],
   "source": [
    "def swap_elements(t, index1, index2):\n",
    "    t_list = list(t)\n",
    " \n",
    "    t_list[index1], t_list[index2] = t_list[index2], t_list[index1]\n",
    "    swapped_tuple = tuple(t_list)\n",
    "    \n",
    "    return swapped_tuple\n",
    "\n",
    "original_tuple = (1, 2, 3, 4, 5)\n",
    "index_to_swap1 = 1\n",
    "index_to_swap2 = 3\n",
    "\n",
    "swapped_tuple = swap_elements(original_tuple, index_to_swap1, index_to_swap2)\n",
    " \n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(f\"Tuple after swapping elements at indices {index_to_swap1} and {index_to_swap2}:\", swapped_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03d48f4e-da1b-4799-8025-6a219415b04b",
   "metadata": {},
   "source": [
    "44. Reverse the elements of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "dee46b76-e590-4225-a485-6852f7724d39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5)\n",
      "Reversed tuple: (5, 4, 3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "def reverse_tuple(t):\n",
    "    reversed_tuple = t[::-1]\n",
    "    return reversed_tuple\n",
    "original_tuple = (1, 2, 3, 4, 5)\n",
    "reversed_tuple = reverse_tuple(original_tuple)\n",
    " \n",
    "print(\"Original tuple:\", original_tuple)\n",
    "print(\"Reversed tuple:\", reversed_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8503bb25-eeae-43b5-81c9-76ea281d5bd0",
   "metadata": {},
   "source": [
    "45. Create a tuple of the first `n` powers of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b21d08b9-9b41-4780-9fc8-b7d215092d50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first 5 powers of 2: (1, 2, 4, 8, 16)\n"
     ]
    }
   ],
   "source": [
    "def generate_powers_of_2(n):\n",
    "    powers_of_2 = tuple(2 ** i for i in range(n))\n",
    "    return powers_of_2\n",
    "first_five_powers_of_2 = generate_powers_of_2(5)\n",
    "print(\"Tuple of the first 5 powers of 2:\", first_five_powers_of_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd34437-5203-47db-9e8c-6b052ea702a8",
   "metadata": {},
   "source": [
    "46. Find the longest string in a tuple of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "e99c1dc0-2e8f-4ffb-89ce-7089fe018963",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of strings: ('apple', 'banana', 'kiwi', 'orange', 'strawberry')\n",
      "Longest string: strawberry\n"
     ]
    }
   ],
   "source": [
    "def find_longest_string(tuple_of_strings):\n",
    "    longest_string = max(tuple_of_strings, key=len)\n",
    "    return longest_string\n",
    "string_tuple = (\"apple\", \"banana\", \"kiwi\", \"orange\", \"strawberry\")\n",
    "longest_string = find_longest_string(string_tuple)\n",
    "print(\"Tuple of strings:\", string_tuple)\n",
    "print(\"Longest string:\", longest_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6939af4-f241-4efe-a676-15ade48e9a6a",
   "metadata": {},
   "source": [
    "47. Find the shortest string in a tuple of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "89d4360e-016d-4e10-891d-b3663b6d6807",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of strings: ('apple', 'banana', 'kiwi', 'orange', 'strawberry')\n",
      "Shortest string: kiwi\n"
     ]
    }
   ],
   "source": [
    "def find_shortest_string(tuple_of_strings):\n",
    "    shortest_string = min(tuple_of_strings, key=len)\n",
    "    return shortest_string\n",
    "string_tuple = (\"apple\", \"banana\", \"kiwi\", \"orange\", \"strawberry\")\n",
    "shortest_string = find_shortest_string(string_tuple)\n",
    "print(\"Tuple of strings:\", string_tuple)\n",
    "print(\"Shortest string:\", shortest_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3217f831-872f-4f1a-bd58-c003b5394438",
   "metadata": {},
   "source": [
    "48. Create a tuple of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "32b6acea-1fa9-470b-ba01-6ea9f8e78ca9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first 5 triangular numbers: (1, 3, 6, 10, 15)\n"
     ]
    }
   ],
   "source": [
    "def generate_triangular_numbers(n):\n",
    "    triangular_numbers = tuple((i * (i + 1)) // 2 for i in range(1, n + 1))\n",
    "    return triangular_numbers\n",
    "first_five_triangular_numbers = generate_triangular_numbers(5)\n",
    "\n",
    "print(\"Tuple of the first 5 triangular numbers:\", first_five_triangular_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90f0dc9c-f3e2-4d0f-8b0e-5ed9e0ef24ab",
   "metadata": {},
   "source": [
    "49. Check if a tuple contains another tuple as a subsequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "df215010-a3bc-4a8a-8743-1483eed36032",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Main tuple: (1, 2, 3, 4, 5, 6, 7, 8)\n",
      "Sub tuple: (3, 4, 5)\n",
      "Contains subsequence: True\n"
     ]
    }
   ],
   "source": [
    "def contains_subsequence(main_tuple, sub_tuple):\n",
    "    len_main = len(main_tuple)\n",
    "    len_sub = len(sub_tuple)\n",
    "\n",
    "    for i in range(len_main - len_sub + 1):\n",
    "        if main_tuple[i:i + len_sub] == sub_tuple:\n",
    "            return True\n",
    "\n",
    "    return False\n",
    "main_tuple = (1, 2, 3, 4, 5, 6, 7, 8)\n",
    "sub_tuple = (3, 4, 5)\n",
    "result = contains_subsequence(main_tuple, sub_tuple)\n",
    "\n",
    "print(\"Main tuple:\", main_tuple)\n",
    "print(\"Sub tuple:\", sub_tuple)\n",
    "print(\"Contains subsequence:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc3a0886-9976-4310-9ac7-474e28e388d6",
   "metadata": {},
   "source": [
    "50. Create a tuple of alternating 1s and 0s of length `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "f4b9c70a-569d-4c39-a5d3-8ee14497ced3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of alternating 1s and 0s: (1, 0, 1, 0, 1, 0, 1, 0)\n"
     ]
    }
   ],
   "source": [
    "def alternating_ones_zeros(n):\n",
    "    alternating_tuple = tuple(1 if i % 2 == 0 else 0 for i in range(n))\n",
    "    return alternating_tuple\n",
    "result_tuple = alternating_ones_zeros(8)\n",
    "print(\"Tuple of alternating 1s and 0s:\", result_tuple)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5e001b0-1a01-429a-9da7-18039ca827be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5acca85a-1d84-4123-a250-61dbca380d1b",
   "metadata": {},
   "source": [
    "                                          Set Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d773d441-fe68-445e-ae7d-5b2cf084d270",
   "metadata": {},
   "source": [
    "1. Create a set with integers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "656e68ce-39bf-4b3f-995d-010468ef3929",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set using curly braces: {1, 2, 3, 4, 5}\n",
      "Set using set() constructor: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set_1 = {1, 2, 3, 4, 5}\n",
    "\n",
    "my_set_2 = set([1, 2, 3, 4, 5])\n",
    "print(\"Set using curly braces:\", my_set_1)\n",
    "print(\"Set using set() constructor:\", my_set_2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bbc1d7d-4c9b-4036-8e94-462c7cf29fad",
   "metadata": {},
   "source": [
    "2. Add an element to a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "19cae41a-b0b4-4309-8a51-ee2e907b781e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated set: {1, 2, 3, 4, 5, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.update({6, 7, 8})\n",
    " \n",
    "print(\"Updated set:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d69c945-93c7-43ab-8bd4-14877649ade9",
   "metadata": {},
   "source": [
    "3. Remove an element from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "435780a6-0f8a-413b-b1b2-e520645471fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated set (after using remove): {1, 2, 4, 5}\n",
      "Error: 10\n",
      "Updated set (after using discard): {1, 2, 5}\n",
      "Updated set (after using discard): {1, 5}\n"
     ]
    }
   ],
   "source": [
    " \n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.remove(3)\n",
    " \n",
    "print(\"Updated set (after using remove):\", my_set)\n",
    "try:\n",
    "    my_set.remove(10)\n",
    "except KeyError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "my_set.discard(4)\n",
    "\n",
    "print(\"Updated set (after using discard):\", my_set)\n",
    "my_set.discard(2)\n",
    "\n",
    "print(\"Updated set (after using discard):\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6da6e0a3-b237-4c7a-91e8-990f4d16333f",
   "metadata": {},
   "source": [
    "4. Check if an element exists in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "dec689cc-e470-45c7-99d8-43424a31db14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 exists in the set.\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "\n",
    "element_to_check = 3\n",
    "\n",
    "if element_to_check in my_set:\n",
    "    print(f\"{element_to_check} exists in the set.\")\n",
    "else:\n",
    "    print(f\"{element_to_check} does not exist in the set.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24986e4-c385-434e-9fb6-d0de8646b737",
   "metadata": {},
   "source": [
    "5. Find the length of a set without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "cfa3c829-4921-45e9-8dac-677aa4bfeb5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the set: 5\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "length = 0\n",
    "for _ in my_set:\n",
    "    length += 1\n",
    " \n",
    "print(\"Length of the set:\", length)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00b84f47-9228-49ae-9600-b582a00d9799",
   "metadata": {},
   "source": [
    "6. Clear all elements from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "939db959-c6c3-44ee-9264-fab2db71f44f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after clearing: set()\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.clear()\n",
    " \n",
    "print(\"Set after clearing:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b79cf65a-6835-4ba9-a568-72c3808d1020",
   "metadata": {},
   "source": [
    "7. Create a set of even numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "f1e8f6d9-0cd2-4530-8189-e9bcc9d391b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of even numbers: {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "even_numbers_set = {num for num in range(1, 11) if num % 2 == 0}\n",
    " \n",
    "print(\"Set of even numbers:\", even_numbers_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2971db55-77ff-42f2-8305-c9d189cc36a6",
   "metadata": {},
   "source": [
    "8. Create a set of odd numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "5a959f87-3b57-471e-9744-47c317be8ed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of odd numbers: {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "odd_numbers_set = {num for num in range(1, 11) if num % 2 != 0}\n",
    " \n",
    "print(\"Set of odd numbers:\", odd_numbers_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51f4992c-9f71-430a-bf9a-b4e948099db0",
   "metadata": {},
   "source": [
    "9. Find the union of two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "02cd579a-5aa9-460f-9115-c417c0003664",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union using union() method: {1, 2, 3, 4, 5, 6, 7, 8}\n",
      "Union using | operator: {1, 2, 3, 4, 5, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    "\n",
    "union_result_method = set1.union(set2)\n",
    "union_result_operator = set1 | set2\n",
    "\n",
    "print(\"Union using union() method:\", union_result_method)\n",
    "print(\"Union using | operator:\", union_result_operator)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cb1e48c-0398-496b-89b8-ae2a875f68fa",
   "metadata": {},
   "source": [
    "10. Find the intersection of two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "44e12215-f5fe-4f79-9552-65893e5adf6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection using intersection() method: {4, 5}\n",
      "Intersection using & operator: {4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    " \n",
    "intersection_result_method = set1.intersection(set2)\n",
    " \n",
    "intersection_result_operator = set1 & set2\n",
    " \n",
    "print(\"Intersection using intersection() method:\", intersection_result_method)\n",
    "print(\"Intersection using & operator:\", intersection_result_operator)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a98c7b90-a404-4499-a6e4-1111ac123068",
   "metadata": {},
   "source": [
    "11. Find the difference between two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "8987ca61-b011-4baf-84af-236b61488039",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference using difference() method: {1, 2, 3}\n",
      "Difference using - operator: {1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    " \n",
    "difference_result_method = set1.difference(set2)\n",
    "difference_result_operator = set1 - set2\n",
    " \n",
    "print(\"Difference using difference() method:\", difference_result_method)\n",
    "print(\"Difference using - operator:\", difference_result_operator)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d064528e-3499-4ed1-8522-cb7b231518d6",
   "metadata": {},
   "source": [
    "12. Check if a set is a subset of another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "19de01ee-92ea-44d5-a22e-c2737edbd281",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is set2 a subset of set1 using issubset(): True\n",
      "Is set2 a subset of set1 using <= operator: True\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {2, 3}\n",
    " \n",
    "is_subset_method = set2.issubset(set1)\n",
    "is_subset_operator = set2 <= set1\n",
    " \n",
    "print(\"Is set2 a subset of set1 using issubset():\", is_subset_method)\n",
    "print(\"Is set2 a subset of set1 using <= operator:\", is_subset_operator)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a8eaa17-adb7-4e83-9498-9fe4df8d33cb",
   "metadata": {},
   "source": [
    "13. Check if a set is a superset of another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "9d80add1-bf4c-43e6-a05b-1c6d9141ec08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is set1 a superset of set2 using issuperset(): True\n",
      "Is set1 a superset of set2 using >= operator: True\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {2, 3}\n",
    "\n",
    "is_superset_method = set1.issuperset(set2)\n",
    "is_superset_operator = set1 >= set2\n",
    " \n",
    "print(\"Is set1 a superset of set2 using issuperset():\", is_superset_method)\n",
    "print(\"Is set1 a superset of set2 using >= operator:\", is_superset_operator)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c77c6a4-599a-4318-a85e-fad5bee00be1",
   "metadata": {},
   "source": [
    "14. Create a set from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "d6216536-4a45-4124-9165-a5873213d936",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set created from a list: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_set = set(my_list)\n",
    " \n",
    "print(\"Set created from a list:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cd4f23a-4f41-439c-b884-8d1ade698d35",
   "metadata": {},
   "source": [
    "15. Convert a set to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "340cea63-e2dc-4c7a-9a54-9a0ea671800e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List converted from a set: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_list = list(my_set)\n",
    "\n",
    " \n",
    "print(\"List converted from a set:\", my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b7fc3fe-bb30-4f2a-97e9-e48a77072edc",
   "metadata": {},
   "source": [
    "16. Remove a random element from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "0f16a0f9-0044-4b59-b46e-b80f3268f614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed element: 1\n",
      "Set after removal: {2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "removed_element = my_set.pop()\n",
    " \n",
    "print(\"Removed element:\", removed_element)\n",
    "print(\"Set after removal:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e23df265-dfe0-48db-af24-2dfd6084d56a",
   "metadata": {},
   "source": [
    "17. Pop an element from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "5120f25b-2645-48a4-a218-8e1a3da8cf79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Popped element: 1\n",
      "Set after popping: {2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    " \n",
    "popped_element = my_set.pop()\n",
    "print(\"Popped element:\", popped_element)\n",
    "print(\"Set after popping:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94efb9bc-79f4-4164-b8bb-0dbdab3e5454",
   "metadata": {},
   "source": [
    "18. Check if two sets have no elements in common."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "6202d91a-79be-4658-989b-585dff45ee54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets have no elements in common.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "\n",
    "no_common_elements = set1.isdisjoint(set2)\n",
    "\n",
    "if no_common_elements:\n",
    "    print(\"The sets have no elements in common.\")\n",
    "else:\n",
    "    print(\"The sets have some common elements.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee7ae16a-bddd-4362-b623-211c09af675a",
   "metadata": {},
   "source": [
    "19. Find the symmetric difference between two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "40f9cda6-7708-416b-9618-66fb156f5042",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symmetric difference using symmetric_difference() method: {1, 2, 3, 6, 7, 8}\n",
      "Symmetric difference using ^ operator: {1, 2, 3, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    "\n",
    "symmetric_difference_method = set1.symmetric_difference(set2)\n",
    "symmetric_difference_operator = set1 ^ set2\n",
    " \n",
    "print(\"Symmetric difference using symmetric_difference() method:\", symmetric_difference_method)\n",
    "print(\"Symmetric difference using ^ operator:\", symmetric_difference_operator)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d0d274b-be35-4d72-9a06-f81aa5c9d03a",
   "metadata": {},
   "source": [
    "20. Update a set with elements from another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "1cf2c643-ba65-4222-850b-8447a2be15ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated set1: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "\n",
    "set1.update(set2)\n",
    "print(\"Updated set1:\", set1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d67bf0a9-ff2c-4088-b044-e028c95a41c6",
   "metadata": {},
   "source": [
    "21. Create a set of the first 5 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "a269b8e6-bf5e-48a9-887e-0438f5a95a6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of the first 5 prime numbers: {2, 3, 5, 7, 11}\n"
     ]
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    if num < 2:\n",
    "        return False\n",
    "    for i in range(2, int(num**0.5) + 1):\n",
    "        if num % i == 0:\n",
    "            return False\n",
    "    return True\n",
    " \n",
    "prime_numbers_set = {2, 3, 5, 7, 11}  \n",
    "print(\"Set of the first 5 prime numbers:\", prime_numbers_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d84d591-fdf0-4e7f-8e04-9bae295ccd89",
   "metadata": {},
   "source": [
    "22. Check if two sets are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "c5143d26-6545-4079-bbe2-c52f702fe747",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets are identical.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {5, 4, 3, 2, 1}   \n",
    "are_identical = set1 == set2\n",
    "\n",
    "if are_identical:\n",
    "    print(\"The sets are identical.\")\n",
    "else:\n",
    "    print(\"The sets are not identical.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caaa9d1d-a70a-4a78-ba1b-f5e164850c8b",
   "metadata": {},
   "source": [
    "23. Create a frozen set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "e582132e-cf33-468b-92e8-7294be2c9154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frozen set: frozenset({1, 2, 3, 4, 5})\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "frozen_set = frozenset(my_set)\n",
    " \n",
    "print(\"Frozen set:\", frozen_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32214ec8-8b4d-4d7f-90f2-80fb5b4c759c",
   "metadata": {},
   "source": [
    "24. Check if a set is disjoint with another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "16a9e2e1-b264-4bd8-9a04-2904e16a4c0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets are disjoint (have no elements in common).\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "are_disjoint = set1.isdisjoint(set2)\n",
    " \n",
    "if are_disjoint:\n",
    "    print(\"The sets are disjoint (have no elements in common).\")\n",
    "else:\n",
    "    print(\"The sets have some common elements.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f69baa7-6396-4a80-a0a7-e5da6b7ed71a",
   "metadata": {},
   "source": [
    "25. Create a set of squares of numbers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "c1abb113-18ab-4057-b70f-8ecd338b404f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of squares: {1, 4, 9, 16, 25}\n"
     ]
    }
   ],
   "source": [
    "squares_set = {num**2 for num in range(1, 6)}\n",
    " \n",
    "print(\"Set of squares:\", squares_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "717cd5c8-be56-442d-a049-efc537350c64",
   "metadata": {},
   "source": [
    "26. Filter out all even numbers from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "66e9a55f-80fd-44ca-ba64-8a78a2743344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered set (without even numbers): {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "original_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
    " \n",
    "filtered_set = {num for num in original_set if num % 2 != 0}\n",
    " \n",
    "print(\"Filtered set (without even numbers):\", filtered_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fed6aeaa-bb11-4b9e-9c4a-6d87c53effab",
   "metadata": {},
   "source": [
    "27. Multiply all elements in a set by 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "e84bffd2-e987-4afe-8310-f07191e3fc7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after multiplying each element by 2: {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "original_set = {1, 2, 3, 4, 5}\n",
    "modified_set = {num * 2 for num in original_set}\n",
    "\n",
    "print(\"Set after multiplying each element by 2:\", modified_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62eb295-33a6-44ae-a7ee-36fb881231b8",
   "metadata": {},
   "source": [
    "28. Create a set of random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "7d91f18c-51c5-4c0b-93ee-36c4f9651feb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of random numbers: {64, 98, 66, 2, 42, 43, 12, 15, 18, 95}\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    " \n",
    "random_set = {random.randint(1, 100) for _ in range(10)}  \n",
    " \n",
    "print(\"Set of random numbers:\", random_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0622af4-2391-4da1-8069-7decee1e2db8",
   "metadata": {},
   "source": [
    "29. Check if a set is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "d7f7820e-e193-4b03-b20f-4b035d2948c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The set is empty.\n"
     ]
    }
   ],
   "source": [
    "empty_set = set()\n",
    "\n",
    "if not empty_set:\n",
    "    print(\"The set is empty.\")\n",
    "else:\n",
    "    print(\"The set is not empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c265b956-c1af-4c37-9c02-6a21216c4816",
   "metadata": {},
   "source": [
    "30. Create a nested set (hint: use frozenset)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "2ed48acc-9fe6-44e1-a1f1-e0fdf21d3d18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested set: {frozenset({3, 4, 5}), frozenset({8, 6, 7}), frozenset({1, 2})}\n"
     ]
    }
   ],
   "source": [
    "nested_set = {frozenset({1, 2}), frozenset({3, 4, 5}), frozenset({6, 7, 8})}\n",
    " \n",
    "print(\"Nested set:\", nested_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "318d1325-4a03-446b-91bf-fed9978ef3eb",
   "metadata": {},
   "source": [
    "31. Remove an element from a set using the discard method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "86f391e8-bdf9-4ccb-8f94-cca25248f110",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after removing element: {1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    " \n",
    "my_set.discard(3)\n",
    " \n",
    "print(\"Set after removing element:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f473173-6bb2-4ac2-8b9a-3da8e4121dad",
   "metadata": {},
   "source": [
    "32. Compare two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9f214569-e48d-439c-813f-00a784834fda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equality check: False\n",
      "Subset check: True\n",
      "Superset check: True\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {3, 4, 5}\n",
    " \n",
    "print(\"Equality check:\", set1 == set2)\n",
    "\n",
    "print(\"Subset check:\", set2.issubset(set1))   \n",
    " \n",
    "print(\"Superset check:\", set1.issuperset(set2)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1c8d634-7ec1-411c-a2de-27af3f2a2fe7",
   "metadata": {},
   "source": [
    "33. Create a set from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "aab51bec-3233-4a28-b071-d18e1aef2274",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set created from the string: {'e', ' ', 'w', 'o', 'h', 'r', 'd', 'l'}\n"
     ]
    }
   ],
   "source": [
    "my_string = \"hello world\"\n",
    " \n",
    "my_set = set(my_string)\n",
    " \n",
    "print(\"Set created from the string:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70fbaeb6-dd5a-4807-9809-7df8fc26d9c7",
   "metadata": {},
   "source": [
    "34. Convert a set of strings to a set of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "acda6af7-17f6-470e-80e8-e99771fc8b63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of integers: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set_of_strings = {\"1\", \"2\", \"3\", \"4\", \"5\"}\n",
    " \n",
    "set_of_integers = {int(x) for x in set_of_strings}\n",
    " \n",
    "print(\"Set of integers:\", set_of_integers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f52a9dc-6b92-4a69-8500-d078fec23b0a",
   "metadata": {},
   "source": [
    "35. Convert a set of integers to a set of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e11b0c01-740d-4755-aede-8ffa7ae948b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of strings: {'5', '4', '3', '2', '1'}\n"
     ]
    }
   ],
   "source": [
    "set_of_integers = {1, 2, 3, 4, 5}\n",
    " \n",
    "set_of_strings = {str(x) for x in set_of_integers}\n",
    " \n",
    "print(\"Set of strings:\", set_of_strings)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed2540d3-ea32-4b3e-b8ae-c5a680d838bb",
   "metadata": {},
   "source": [
    "36. Create a set from a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "02ec0cea-6528-4f56-a19e-5062ca11d4a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set created from the tuple: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    " \n",
    "my_set = set(my_tuple)\n",
    " \n",
    "print(\"Set created from the tuple:\", my_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cd72235-6cd4-4913-b3cb-f6c970a3123a",
   "metadata": {},
   "source": [
    "37. Convert a set to a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "abeb7508-c1b1-4126-8d12-d0e26b82c662",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple converted from the set: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    " \n",
    "my_tuple = tuple(my_set)\n",
    " \n",
    "print(\"Tuple converted from the set:\", my_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c29bbada-9e5f-41f2-8ce0-b99245959485",
   "metadata": {},
   "source": [
    "38. Find the maximum value in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4c7250f2-6b16-4691-bc0a-eba452b58154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value in the set: 8\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 5, 3, 8, 2}\n",
    " \n",
    "max_value = max(my_set)\n",
    " \n",
    "print(\"Maximum value in the set:\", max_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c36f412d-a7a0-4d96-8690-801895f90944",
   "metadata": {},
   "source": [
    "39. Find the minimum value in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ac0057ef-338f-41d6-bae4-f8127d656384",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value in the set: 1\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 5, 3, 8, 2}\n",
    " \n",
    "min_value = min(my_set)\n",
    " \n",
    "print(\"Minimum value in the set:\", min_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab4f9902-1201-443d-86a5-4d585a8730a2",
   "metadata": {},
   "source": [
    "40. Create a set from user input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d5f438e0-7392-478c-be55-e08de3cb14ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter elements separated by spaces:  amit baghel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set created from user input: {'amit', 'baghel'}\n"
     ]
    }
   ],
   "source": [
    "user_input = input(\"Enter elements separated by spaces: \")\n",
    " \n",
    "user_set = set(user_input.split())\n",
    " \n",
    "print(\"Set created from user input:\", user_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "890e5fe0-5b6f-4d38-a15c-348e56b9daba",
   "metadata": {},
   "source": [
    "41. Check if the intersection of two sets is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d21e5e5a-b063-489e-b165-a3b40945b39e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The intersection of the sets is empty.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    " \n",
    "is_empty_intersection = set1.isdisjoint(set2)\n",
    " \n",
    "if is_empty_intersection:\n",
    "    print(\"The intersection of the sets is empty.\")\n",
    "else:\n",
    "    print(\"The intersection of the sets is not empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c94ea6de-faff-461e-9159-95416edaf09c",
   "metadata": {},
   "source": [
    "42. Create a set of the first 5 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4a699680-71c7-48bc-95ca-fa0960774608",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of the first 5 Fibonacci numbers: {0, 1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "def generate_fibonacci(n):\n",
    "    fibonacci_set = set()\n",
    "    a, b = 0, 1\n",
    "    for _ in range(n):\n",
    "        fibonacci_set.add(a)\n",
    "        a, b = b, a + b\n",
    "    return fibonacci_set\n",
    " \n",
    "fibonacci_set = generate_fibonacci(5)\n",
    " \n",
    "print(\"Set of the first 5 Fibonacci numbers:\", fibonacci_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d7e16f6-b1ea-498b-bd3e-7e8e39df5b69",
   "metadata": {},
   "source": [
    "43. Remove duplicates from a list using sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bcc43084-3334-4ae8-8252-8a2bbb449c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing duplicates: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "original_list = [1, 2, 3, 4, 2, 3, 5, 6, 1]\n",
    " \n",
    "unique_list = list(set(original_list))\n",
    " \n",
    "print(\"List after removing duplicates:\", unique_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa6583fa-e338-44fc-8012-58836021f53d",
   "metadata": {},
   "source": [
    "44. Check if two sets have the same elements, regardless of their count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b5375896-c3cc-41da-8747-eb3fc9b873cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets have the same elements, regardless of their count.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {5, 4, 3, 2, 1}\n",
    " \n",
    "if set1 == set2:\n",
    "    print(\"The sets have the same elements, regardless of their count.\")\n",
    "else:\n",
    "    print(\"The sets do not have the same elements.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3d30acc-78e6-4b73-80ff-79ad236c2272",
   "metadata": {},
   "source": [
    "45. Create a set of the first `n` powers of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2c50f98d-c3e8-4580-b97f-337d4c33de21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of the first 5 powers of 2: {1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    " \n",
    "powers_of_2_set = {2 ** i for i in range(n)}\n",
    " \n",
    "print(\"Set of the first\", n, \"powers of 2:\", powers_of_2_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67c69a1c-f36c-4ccb-a3cb-d5c3a75418ec",
   "metadata": {},
   "source": [
    "46. Find the common elements between a set and a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6232997c-df7e-4c29-bc2f-c94d34376c18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements: {3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_list = [3, 4, 5, 6, 7]\n",
    " \n",
    "common_elements = my_set.intersection(my_list)\n",
    " \n",
    "print(\"Common elements:\", common_elements)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48b3d72d-33e3-4bea-a9da-5da18e3581d9",
   "metadata": {},
   "source": [
    "47. Create a set of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e120ebba-a187-4f10-b5ab-0db448300c5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of the first 5 triangular numbers: {1, 3, 6, 10, 15}\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    " \n",
    "triangular_numbers_set = {i * (i + 1) // 2 for i in range(1, n + 1)}\n",
    " \n",
    "print(\"Set of the first\", n, \"triangular numbers:\", triangular_numbers_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f789029b-0b3d-4969-8293-a7667e6c362e",
   "metadata": {},
   "source": [
    "48. Check if a set contains another set as a subset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "86b83324-9ad8-4fcd-a594-07537922fd66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set2 is a subset of set1.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {2, 3}\n",
    " \n",
    "if set2.issubset(set1):\n",
    "    print(\"set2 is a subset of set1.\")\n",
    "else:\n",
    "    print(\"set2 is not a subset of set1.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95188384-9790-404d-a684-7b887d7e6cad",
   "metadata": {},
   "source": [
    "49. Create a set of alternating 1s and 0s of length `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "357f8ca2-3892-49b8-923c-64dc667c4856",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of alternating 1s and 0s: {0, 1}\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    " \n",
    "alternating_set = {1 if i % 2 == 0 else 0 for i in range(n)}\n",
    " \n",
    "print(\"Set of alternating 1s and 0s:\", alternating_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ebfc189-d92b-4def-a6a7-e4ecd3ef62eb",
   "metadata": {},
   "source": [
    "50. Merge multiple sets into one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ade8461d-df58-47fc-b182-626769659e1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged set using union(): {1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set3 = {5, 6, 7}\n",
    " \n",
    "merged_set = set1.union(set2, set3)\n",
    " \n",
    "print(\"Merged set using union():\", merged_set)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db01ccf1-8917-48a5-b4de-ec13a59347ea",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}