20th_August_Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "041f5813",
   "metadata": {},
   "source": [
    "# TOPIC: String Based Assignment Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1df6f9",
   "metadata": {},
   "source": [
    "#### 1. Write a program to reverse a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1d62444c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n",
      "Reversed String is dlrow olleH\n"
     ]
    }
   ],
   "source": [
    "#User Input String \n",
    "UserInput = input()\n",
    "\n",
    "#Reversing string \n",
    "Reverse = UserInput[::-1]\n",
    "\n",
    "#Print\n",
    "print('Reversed String is',Reverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04981a2a",
   "metadata": {},
   "source": [
    "#### 2. Check if a string is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b842b44f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String:    Level \n",
      "String is Palindrome\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "#Cleaning String\n",
    "CleanedUserString = UserInput.strip().lower()\n",
    "\n",
    "# Palindrome Logic \n",
    "ReverseString = CleanedUserString[::-1]\n",
    "\n",
    "if CleanedUserString == ReverseString:\n",
    "    print('String is Palindrome')\n",
    "else: \n",
    "    print('String is Not Palindrome')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9437b7db",
   "metadata": {},
   "source": [
    "#### 3. Convert a string to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "833dd226",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "Upper Case String is  HELLO WORLD\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "# Using upper() string function to convert to upper case\n",
    "Upper = UserInput.upper()\n",
    "\n",
    "print('Upper Case String is ',Upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "666fee29",
   "metadata": {},
   "source": [
    "#### 4. Convert a string to lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "38148263",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello WORLD\n",
      "Upper Case String is  hello world\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "# Using lower() string function to convert to lower case\n",
    "Lower = UserInput.lower()\n",
    "\n",
    "print('Upper Case String is ',Lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a44b1ac",
   "metadata": {},
   "source": [
    "#### 5. Count the number of vowels in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "470c8de6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "Count of Vowels in your String is  3\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserString = input('Enter Your String: ')\n",
    "\n",
    "#Declaring Variable to Get count vowels \n",
    "CountVowels = 0\n",
    "\n",
    "# Programming Logic \n",
    "for i in UserString:\n",
    "    if i in ('a','e','i','o','u'):\n",
    "        CountVowels = CountVowels + 1\n",
    "\n",
    "#Showing Output \n",
    "print('Count of Vowels in your String is ',CountVowels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6b5451b",
   "metadata": {},
   "source": [
    "#### 6. Count the number of consonants in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6a9a68aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: hello world\n",
      "Count of Vowels in your String is  8\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserString = input('Enter Your String: ')\n",
    "\n",
    "#Declaring Variable to Get count consonants \n",
    "ConsonantsVowels = 0\n",
    "\n",
    "# Programming Logic \n",
    "for i in UserString:\n",
    "    if i not in ('a','e','i','o','u'):\n",
    "        ConsonantsVowels = ConsonantsVowels + 1\n",
    "\n",
    "#Showing Output \n",
    "print('Count of Vowels in your String is ',ConsonantsVowels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb080ab",
   "metadata": {},
   "source": [
    "#### 7. Remove all whitespaces from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "edfc13fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world  \n",
      "String Without Space is Helloworld\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserString = input('Enter Your String: ')\n",
    "\n",
    "#Logic to Remove Spaces using string function \n",
    "StrWithoutSpace = \"\".join(UserString.split(\" \")) \n",
    "#So this will take user string split it with space and output of userString.split(\" \") will be a list of all word\n",
    "# \"\".join will join all the words in list without space\n",
    "\n",
    "\n",
    "print('String Without Space is',StrWithoutSpace)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "014407e0",
   "metadata": {},
   "source": [
    "\n",
    "#### 8. Find the length of a string without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0a4331ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "Length of String is 11\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Counter = 0 \n",
    "\n",
    "#Programming Logic \n",
    "for i in UserInput:\n",
    "    Counter += 1 \n",
    "print('Length of String is',Counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32e8e69",
   "metadata": {},
   "source": [
    "#### 9. Check if a string contains a specific word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "42b01843",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "String to Check in Your Input: world\n",
      "Yes world Exists in Hello world\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "#Checking word \n",
    "Check = input('String to Check in Your Input: ')\n",
    "\n",
    "#I used lower() to avoid case sensitivity\n",
    "if Check.lower() in UserInput.lower():\n",
    "    print('Yes, {} Exists in {}'.format(Check,UserInput))\n",
    "else:\n",
    "    print(\"No, {} Doesn't Exist in {}\".format(Check,UserInput))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "350224a9",
   "metadata": {},
   "source": [
    "\n",
    "#### 10. Replace a word in a string with another word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "05766b7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world, world Hello will be replaced\n",
      "Enter Which word You want to Replace: Hello\n",
      "Enter by which word you want to replace: Hii\n",
      "Replaced String is  Hii world, world Hii will be replaced\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "#Replace Word from \n",
    "Replacable = input('Enter word Which You want to Replace: ')\n",
    "\n",
    "#Replace Word\n",
    "Replace = input('Enter by which word you want to replace: ')\n",
    "\n",
    "#Logic \n",
    "ReplacedString = UserInput.replace(Replacable,Replace)\n",
    "\n",
    "print('Replaced String is ',ReplacedString)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7369f622",
   "metadata": {},
   "source": [
    "#### 11. Count the occurrences of a word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "052bc546",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world hello world \n",
      "Which word you want to find Occurence:world\n",
      "occurrences of world is 2\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Check = input('Which word you want to find Occurence:')\n",
    "\n",
    "#Occurance\n",
    "Count = UserInput.count(Check)\n",
    "\n",
    "print('occurrences of {} is {}'.format(Check,Count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3352ddb7",
   "metadata": {},
   "source": [
    "#### 12. Find the first occurrence of a word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7d19b58b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world its world\n",
      "Which word you want to find First Occurence:world\n",
      "occurrences of world is at 6 index\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Check = input('Which word you want to find First Occurence:')\n",
    "\n",
    "#Occurance\n",
    "Count = UserInput.find(Check)\n",
    "\n",
    "print('First occurrence of {} is at {} index'.format(Check,Count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28c13491",
   "metadata": {},
   "source": [
    "#### 13. Find the last occurrence of a word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "12622c0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world hellow world \n",
      "Which word you want to find First Occurence:world\n",
      "First occurrence of world is at 19 index\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Check = input('Which word you want to find Last Occurence:')\n",
    "\n",
    "#Occurance\n",
    "Count = UserInput.rfind(Check)\n",
    "\n",
    "print('Last occurrence of {} is at {} index'.format(Check,Count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d49ec739",
   "metadata": {},
   "source": [
    "#### 14. Split a string into a list of words.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ab378e9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world, Welcome to python programming\n",
      "['Hello', 'world,', 'Welcome', 'to', 'python', 'programming']\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "#Splitting String \n",
    "print(UserInput.split(' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49e6cbec",
   "metadata": {},
   "source": [
    "#### 15. Join a list of words into a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2a521037",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world, Welcome to python programming\n"
     ]
    }
   ],
   "source": [
    "ListOfWords = ['Hello', 'world,', 'Welcome', 'to', 'python', 'programming']\n",
    "\n",
    "#Joining String\n",
    "print(\" \".join(ListOfWords))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44a208c5",
   "metadata": {},
   "source": [
    "#### 16. Convert a string where words are separated by spaces to one where words are separated by underscores.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f9d9bd26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world, Welcome to python programming\n",
      "Hello_world,_Welcome_to_python_programming\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "# Converting to list\n",
    "ListOfWords = UserInput.split(' ')\n",
    "\n",
    "#Joining String\n",
    "print(\"_\".join(ListOfWords))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e35b93b",
   "metadata": {},
   "source": [
    "#### 17. Check if a string starts with a specific word or phrase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "f2ef72e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "String to Check in Your Input: Hello\n",
      "Yes, It is Starting with Hello\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "#Checking word \n",
    "Check = input('Check if you string starts with: ')\n",
    "\n",
    "if UserInput.startswith(Check):\n",
    "    print('Yes, It is Starting with', Check)\n",
    "else:\n",
    "    print('Not, its not starting with',Check)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7593fc57",
   "metadata": {},
   "source": [
    "#### 18. Check if a string ends with a specific word or phrase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e3b1f506",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "Check if you string Ends with: world\n",
      "Yes, It is Ending with world\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "#Checking word \n",
    "Check = input('Check if you string Ends with: ')\n",
    "\n",
    "if UserInput.endswith(Check):\n",
    "    print('Yes, It is Ending with', Check)\n",
    "else:\n",
    "    print('Not, its not Ending with',Check)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa554387",
   "metadata": {},
   "source": [
    "#### 19. Convert a string to title case (e.g., \"hello world\" to \"Hello World\").\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "70d20c93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world, Welcome to python prorgamming\n",
      "Hello World, Welcome To Python Prorgamming\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Title = UserInput.title()\n",
    "\n",
    "print(Title)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72c0e7f0",
   "metadata": {},
   "source": [
    "#### 20. Find the longest word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "1bf2ad7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello, world welcome to python programming in Notebook\n",
      "Longest Word In String is 11 Letters and its programming \n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Split = UserInput.split(' ')\n",
    "\n",
    "MaxLen = 0\n",
    "Word = ''\n",
    "for i in Split:\n",
    "    if len(i) > MaxLen:\n",
    "        MaxLen = len(i)\n",
    "        Word = i\n",
    "        \n",
    "print('Longest Word In String is {} Letters and its {} '.format(MaxLen,Word))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9ce2f62",
   "metadata": {},
   "source": [
    "#### 21. Find the shortest word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "dceb1aa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world, Welcome to python Programming\n",
      "Shortest Word In String is 2 Letters and its to \n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ').strip()\n",
    "\n",
    "Split = UserInput.split(' ')\n",
    "\n",
    "MinLen = float('inf')\n",
    "Word = ''\n",
    "for i in Split:\n",
    "    if len(i) < MinLen:\n",
    "        MinLen = len(i)\n",
    "        Word = i\n",
    "        \n",
    "print('Shortest Word In String is {} Letters and its {} '.format(MinLen,Word))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45f05472",
   "metadata": {},
   "source": [
    "#### 22. Reverse the order of words in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "a9d3faa0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world\n",
      "Reversed word is  world Hello\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "# Splitting into List\n",
    "SplitUserValue = UserInput.split(' ')\n",
    "\n",
    "# reversing splitted string \n",
    "ReversedList = SplitUserValue[::-1]\n",
    "\n",
    "#Joining reversed string\n",
    "ReverseJoin = \" \".join(ReversedList)\n",
    "\n",
    "\n",
    "print('Reversed word is ',ReverseJoin)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c988028",
   "metadata": {},
   "source": [
    "#### 23. Check if a string is alphanumeric.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "1705908a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: hello123\n",
      "Yes String is Alpha Numeric\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "if (UserInput).isalnum():\n",
    "    print('Yes String is Alpha Numeric')\n",
    "else: \n",
    "    print('No, String is not Alpha Numeric')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "412443ca",
   "metadata": {},
   "source": [
    "#### 24. Extract all digits from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "bcdf78ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: hello 123 helo 341\n",
      "123341\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "digit = \"\"\n",
    "\n",
    "for i in UserInput:\n",
    "    if i.isdigit():\n",
    "        digit += i\n",
    "print(digit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdfc9241",
   "metadata": {},
   "source": [
    "#### 25. Extract all alphabets from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "2279efc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: hello123world\n",
      "helloworld\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "Alpha = \"\"\n",
    "\n",
    "for i in UserInput:\n",
    "    if i.isalpha():\n",
    "        Alpha += i\n",
    "print(Alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5d68c5d",
   "metadata": {},
   "source": [
    "#### 26. Count the number of uppercase letters in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "4e2a5d62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: HelloWorld]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "CountUpper = 0\n",
    "\n",
    "for i in UserInput:\n",
    "    if i.isupper():\n",
    "        CountUpper += 1\n",
    "        \n",
    "print(CountUpper)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe40176",
   "metadata": {},
   "source": [
    "#### 27. Count the number of lowercase letters in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "43d4cf8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello World\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "CountLower = 0\n",
    "\n",
    "for i in UserInput:\n",
    "    if i.islower():\n",
    "        CountLower += 1\n",
    "        \n",
    "print(CountLower)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db73dbc9",
   "metadata": {},
   "source": [
    "#### 28. Swap the case of each character in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "3a65229d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello World\n",
      "hELLO wORLD\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "print(UserInput.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68fc003f",
   "metadata": {},
   "source": [
    "#### 29. Remove a specific word from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "ab46c80d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello world, Welcome to Python programming \n",
      "Enter String you want to remove: Python\n",
      "Hello world, Welcome to  programming \n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "UserInput = input('Enter Your String: ')\n",
    "\n",
    "# Remove Word \n",
    "Remove = input('Enter String you want to remove: ')\n",
    "\n",
    "print(UserInput.replace(Remove,\"\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88bb828d",
   "metadata": {},
   "source": [
    "#### 30. Check if a string is a valid email address.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "e1a57d36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello@not.g.s\n",
      "Its A Valid Email\n"
     ]
    }
   ],
   "source": [
    "#regular expression module\n",
    "import re \n",
    "\n",
    "# Taking User Input String \n",
    "Email = input('Enter Your String: ')\n",
    "\n",
    "pattern = r'^[\\w\\.-]+@[\\w\\.-]+\\.\\w+$'  # Regular expression pattern for a basic email validation\n",
    "if re.match(pattern, Email):\n",
    "    print('Its A Valid Email')\n",
    "else:\n",
    "    print('Its not A Valid Email')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e61bd438",
   "metadata": {},
   "source": [
    "#### 31. Extract the username from an email address string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "5a4e9f1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Hello@gmail.com\n",
      "UserName is  Hello\n"
     ]
    }
   ],
   "source": [
    "#regular expression module\n",
    "import re \n",
    "\n",
    "# Taking User Input String \n",
    "Email = input('Enter Your String: ')\n",
    "\n",
    "Username = Email.split('@')[0]\n",
    "\n",
    "print('UserName is',Username)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ac3b668",
   "metadata": {},
   "source": [
    "#### 32. Extract the domain name from an email address string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "34ebb69a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String: Xyz@google.com\n",
      "Domain is google.com\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "Email = input('Enter Your String: ')\n",
    "\n",
    "Domain = Email.split('@')[1]\n",
    "\n",
    "print('Domain is',Domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae26f6b2",
   "metadata": {},
   "source": [
    "#### 33. Replace multiple spaces in a string with a single space.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "686145cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Your String:    hello w  world \n",
      "String Without Spaces: hello w world\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "userString = input('Enter Your String: ')\n",
    "\n",
    "SplittedList = userString.split(' ')\n",
    "NewList = []\n",
    "for i in SplittedList:\n",
    "    if i != '':\n",
    "        NewList.append(i)\n",
    "\n",
    "WithoutSpace = \" \".join(NewList)\n",
    "\n",
    "print('String Without Spaces:',WithoutSpace)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1079e53",
   "metadata": {},
   "source": [
    "#### 34. Check if a string is a valid URL.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "124958b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter URL: https://www.something.com/\n",
      "Its A Valid URL\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "# Taking User Input String \n",
    "userString = input('Enter URL: ')\n",
    "\n",
    "regex = \"((http|https)://)(www.)?\" + \"[a-zA-Z0-9@:%._\\\\+~#?&//=]{2,256}\\\\.[a-z]\" + \"{2,6}\\\\b([-a-zA-Z0-9@:%._\\\\+~#?&//=]*)\"\n",
    "\n",
    "\n",
    "if re.match(regex, userString):\n",
    "    print('Its A Valid URL')\n",
    "else:\n",
    "    print('Its not A Valid URL')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52720eb0",
   "metadata": {},
   "source": [
    "#### 35. Extract the protocol (http or https) from a URL string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "ee0a7096",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter URL: https://www.something.com/\n",
      "Protocol is  https\n"
     ]
    }
   ],
   "source": [
    "# Taking User Input String \n",
    "userString = input('Enter URL: ')\n",
    "\n",
    "Protocol = userString.split('://')[0]\n",
    "\n",
    "print('Protocol is',Protocol)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5554d93",
   "metadata": {},
   "source": [
    "#### 36. Find the frequency of each character in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "630e627b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter URL: Hello world\n",
      "Key=H Frequency=1\n",
      "Key=e Frequency=1\n",
      "Key=l Frequency=3\n",
      "Key=o Frequency=2\n",
      "Key=  Frequency=1\n",
      "Key=w Frequency=1\n",
      "Key=r Frequency=1\n",
      "Key=d Frequency=1\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ')\n",
    "\n",
    "Frequency = {}\n",
    "\n",
    "for char in userString:\n",
    "    if char in Frequency:\n",
    "        Frequency[char] += 1  \n",
    "    else:\n",
    "        Frequency[char] = 1\n",
    "\n",
    "for key,value in Frequency.items():\n",
    "    print('Key={} Frequency={}'.format(key,value))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466521c8",
   "metadata": {},
   "source": [
    "#### 37. Remove all punctuation from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d7d3d38b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Hello! World!\n",
      "Cleaned String: Hello World\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ')\n",
    "\n",
    "#List of punctuations\n",
    "punctuation_list = \"\"\"!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~\"\"\"\n",
    "\n",
    "translator = str.maketrans('', '', punctuation_list)\n",
    "\n",
    "clean_string = userString.translate(translator)\n",
    "\n",
    "print('Cleaned String:',clean_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85798a89",
   "metadata": {},
   "source": [
    "#### 38. Check if a string contains only digits.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f6cf5541",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: 123\n",
      "It Contains Only Digit\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ')\n",
    "\n",
    "if userString.isdigit():\n",
    "    print('It Contains Only Digit')\n",
    "else:\n",
    "    print('It Does not contain only digits')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f627886d",
   "metadata": {},
   "source": [
    "#### 39. Check if a string contains only alphabets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4bbd6653",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Hello\n",
      "It Contains Only Alphabet\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ')\n",
    "\n",
    "if userString.isalpha():\n",
    "    print('It Contains Only Alphabet')\n",
    "else:\n",
    "    print('It Does not contain only Alphabet')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f884749f",
   "metadata": {},
   "source": [
    "#### 40. Convert a string to a list of characters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "96dc4869",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Hello world\n",
      "['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ')\n",
    "\n",
    "#Empty List\n",
    "L1 = []\n",
    "\n",
    "L1.extend(userString)\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c23d867",
   "metadata": {},
   "source": [
    "#### 41. Check if two strings are anagrams.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "f0680e5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter First Word:Knee\n",
      "Enter Secodn word:keen\n",
      "Both Are Anagrams\n"
     ]
    }
   ],
   "source": [
    "String1 = input('Enter First Word:').strip().lower()\n",
    "String2 = input('Enter Secodn word:').strip().lower()\n",
    "\n",
    "if sorted(String1) == sorted(String2):\n",
    "    print('Both Are Anagrams')\n",
    "else:\n",
    "    print('Both Are Not Anagrams')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b11a0124",
   "metadata": {},
   "source": [
    "#### 42. Encode a string using a Caesar cipher.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "1840d423",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String:Hello World\n",
      "Encoded Text: khoor zruog\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String:').lower()\n",
    "key = 3\n",
    "Encoded_Text = \"\"\n",
    "\n",
    "for i in userString:\n",
    "    if i.isalpha():\n",
    "        Encoded_Text += chr((ord(i) + 3 - ord('a'))%26 + ord('a'))\n",
    "    else:\n",
    "        Encoded_Text += i\n",
    "print('Encoded Text:',Encoded_Text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67c7d8d3",
   "metadata": {},
   "source": [
    "#### 43. Decode a Caesar cipher encoded string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "e9317a77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: khoor zruog\n",
      "Decoded Text: hello world\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ')\n",
    "key = 3\n",
    "Decoded_Text = \"\"\n",
    "\n",
    "for i in userString:\n",
    "    if i.isalpha():\n",
    "        Decoded_Text += chr((ord(i) - 3 - ord('a'))%26 + ord('a'))\n",
    "    else:\n",
    "        Decoded_Text += i\n",
    "print('Decoded Text:',Decoded_Text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64d1bd50",
   "metadata": {},
   "source": [
    "#### 44. Find the most frequent word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "7bb66b9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Hello World Hello Hello Hello\n",
      "Most frequent Word is  Hello\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ').strip()\n",
    "\n",
    "SplittedString = userString.split(' ')\n",
    "\n",
    "Frequency = {}\n",
    "\n",
    "for i in SplittedString:\n",
    "    if i in Frequency:\n",
    "        Frequency[i] += 1  \n",
    "    else:\n",
    "        Frequency[i] = 1\n",
    "\n",
    "        \n",
    "MostFrequentWord = max(Frequency, key=Frequency.get)    \n",
    "\n",
    "print('Most frequent Word is ',MostFrequentWord)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b914d0f",
   "metadata": {},
   "source": [
    "#### 45. Find all unique words in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "32e1365f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Hello world Hello hello\n",
      "{'Hello', 'hello', 'world'}\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ').strip()\n",
    "\n",
    "SplittedString = set(userString.split(' '))\n",
    "\n",
    "print(SplittedString)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3348e6b5",
   "metadata": {},
   "source": [
    "#### 46. Count the number of syllables in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "e749849a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Hello Ello\n",
      "Number of Syllabes in Hello Ello is 4\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String: ').strip()\n",
    "\n",
    "syllables = ['a','e','i','o','u','y']\n",
    "\n",
    "counter = 0 \n",
    "for i in userString:\n",
    "    if i.lower() in syllables:\n",
    "        counter += 1\n",
    "\n",
    "print('Number of Syllabes in {} is {}'.format(userString,counter))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745ca17d",
   "metadata": {},
   "source": [
    "#### 47. Check if a string contains any special characters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "caccb3b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String:Hello\n",
      "It Does Not Contain Special Character\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String:')\n",
    "\n",
    "Special_Characters = \"\"\"!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~\"\"\"\n",
    "\n",
    "for i in userString:\n",
    "    if i in Special_Characters:\n",
    "        print('Yes, it Contains Special Character')\n",
    "        break\n",
    "else:\n",
    "    print('It Does Not Contain Special Character')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b021a7",
   "metadata": {},
   "source": [
    "#### 48. Remove the nth word from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "77b9a9c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String:12\n",
      "From Which Place You Want to remove:1\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_24168/3217862609.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mNewList\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mL1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0muserString\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mL1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String:')\n",
    "Index = int(input('From Which Place You Want to remove:'))\n",
    "\n",
    "#Empty List\n",
    "L1 = []\n",
    "\n",
    "NewList = L1.extend(userString)\n",
    "\n",
    "L1.remove(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "8da5357e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String:Hello World\n",
      "From Which Place You Want to remove:9\n",
      "new String is  Hello Word\n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String:')\n",
    "Index = int(input('From Which Place You Want to remove:'))\n",
    "\n",
    "#Removing using string slicing\n",
    "NewString = userString[:Index] + userString[Index+1:]\n",
    "\n",
    "print('new String is ',NewString)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0167cf9",
   "metadata": {},
   "source": [
    "#### 49. Insert a word at the nth position in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "308b8753",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String:Hello World \n",
      "From Which Place You Want to remove:10 \n",
      "Enter Word to Insert:World\n",
      "new String is  Hello Worl World d \n"
     ]
    }
   ],
   "source": [
    "userString = input('Enter String:')\n",
    "Index = int(input('From Which Place You Want to remove:'))\n",
    "Word = input('Enter Word to Insert:')\n",
    "\n",
    "#Removing using string slicing\n",
    "NewString = userString[:Index] + \" \" + Word + \" \" +userString[Index:]\n",
    "\n",
    "print('new String is ',NewString)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c69bb32",
   "metadata": {},
   "source": [
    "#### 50. Convert a CSV string to a list of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "88fb0430",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Name', ' Age', ' Country']\n",
      "['John', ' 25', ' USA']\n",
      "['Alice', ' 30', ' Canada']\n",
      "['Bob', ' 22', ' UK']\n"
     ]
    }
   ],
   "source": [
    "csv_data = \"Name, Age, Country\\nJohn, 25, USA\\nAlice, 30, Canada\\nBob, 22, UK\"\n",
    "\n",
    "SplitCSV = csv_data.split('\\n')\n",
    "\n",
    "for i in range(len(SplitCSV)):\n",
    "    X = SplitCSV[i]\n",
    "    SplitCSV[i] = X.split(',')\n",
    "    \n",
    "for raw in SplitCSV:\n",
    "    print(raw)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ea12ae7",
   "metadata": {},
   "source": [
    "# List Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c8203c",
   "metadata": {},
   "source": [
    "#### 1. Create a list with integers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "83d3c38b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List = list(range(1,11))\n",
    "\n",
    "List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a804bfc",
   "metadata": {},
   "source": [
    "#### 2. Find the length of a list without using the `len()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "91226db0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "L1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "counter = 0\n",
    "\n",
    "for i in L1:\n",
    "    counter += 1\n",
    "    \n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cec4f829",
   "metadata": {},
   "source": [
    "#### 3. Append an element to the end of a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "33c87d1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1.append(11)\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95170e47",
   "metadata": {},
   "source": [
    "#### 4. Insert an element at a specific index in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "4b3fc00c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'Hello', 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1.insert(2,'Hello')\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "488fe7c7",
   "metadata": {},
   "source": [
    "#### 5. Remove an element from a list by its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "e987ece3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,'Hello' ,2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1.remove('Hello')\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d485f036",
   "metadata": {},
   "source": [
    "#### 6. Remove an element from a list by its index.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "6fdb4fc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,'Hello' ,2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1.pop(1)\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "908f9347",
   "metadata": {},
   "source": [
    "#### 7. Check if an element exists in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "dd48f970",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes it exist\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,'Hello' ,2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "Check = 10\n",
    "if Check in L1:\n",
    "    print('Yes it exist')\n",
    "else:\n",
    "    print('it does not exist')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b38a6ce9",
   "metadata": {},
   "source": [
    "#### 8. Find the index of the first occurrence of an element in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "c466d51e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Index is 6\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,'Hello' ,2, 3, 4, 5,8, 6, 7, 8, 9, 10]\n",
    "\n",
    "check =  8\n",
    "\n",
    "print('First Index is',L1.index(check))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8734dcc9",
   "metadata": {},
   "source": [
    "#### 9. Count the occurrences of an element in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "df98d6b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count of 8 is 2\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,'Hello' ,2, 3, 4, 5,8, 6, 7, 8, 9, 10]\n",
    "\n",
    "check =  8\n",
    "\n",
    "print('count of {} is {}'.format(check,L1.count(check)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31b5ac1c",
   "metadata": {},
   "source": [
    "#### 10. Reverse the order of elements in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "a85e51af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 8, 5, 4, 3, 2, 'Hello', 1]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [1,'Hello' ,2, 3, 4, 5,8, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f21cbbdd",
   "metadata": {},
   "source": [
    "#### 11. Sort a list in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "b303f695",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 9, 10]"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [1,5 ,2, 3, 4, 5,8, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1.sort()\n",
    "\n",
    "L1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3225afd1",
   "metadata": {},
   "source": [
    "#### 12. Sort a list in descending order.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "91d5a5b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 8, 7, 6, 5, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [1,5 ,2, 3, 4, 5,8, 6, 7, 8, 9, 10]\n",
    "\n",
    "L1.sort(reverse=True)\n",
    "\n",
    "L1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44939595",
   "metadata": {},
   "source": [
    "#### 13. Create a list of even numbers from 1 to 20.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "66a7f80c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List = list(range(2,21,2))\n",
    "\n",
    "List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2d34b8c",
   "metadata": {},
   "source": [
    "#### 14. Create a list of odd numbers from 1 to 20.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "b8a162ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List = list(range(1,21,2))\n",
    "\n",
    "List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f66416f",
   "metadata": {},
   "source": [
    "#### 15. Find the sum of all elements in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "45570dcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "210"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List = list(range(1,21))\n",
    "\n",
    "sum(List)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f89f0f0",
   "metadata": {},
   "source": [
    "#### 16. Find the maximum value in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "cadc25f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
    "\n",
    "max(List)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1d3c54",
   "metadata": {},
   "source": [
    "#### 17. Find the minimum value in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "acd93f24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "List = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
    "\n",
    "min(List)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c52662",
   "metadata": {},
   "source": [
    "#### 18. Create a list of squares of numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "0db7c3cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i*i for i in range(1,10) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b34cf24",
   "metadata": {},
   "source": [
    "#### 19. Create a list of random numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "48bbf4cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[71, 96, 100, 97, 96, 77, 47, 49, 79, 42, 99, 15, 47, 29, 2, 34, 60, 44, 63]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "List = [ random.randint(1,100) for i in range(1,20)]\n",
    "\n",
    "print(List)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d6e38de",
   "metadata": {},
   "source": [
    "#### 20. Remove duplicates from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "4bc91309",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 69, 8, 41, 10, 73, 76, 13, 56, 25, 90, 27, 60, 61, 30, 63]\n"
     ]
    }
   ],
   "source": [
    "L1 = [56, 27, 27, 63, 63, 60, 8, 61, 13, 99, 41, 69, 76, 25, 10, 10, 90, 30, 73]\n",
    "\n",
    "RemoveDupes = list(set(L1))\n",
    "\n",
    "print(RemoveDupes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df0d0266",
   "metadata": {},
   "source": [
    "#### 21. Find the common elements between two lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "c8968e53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3,4,5,9]\n",
    "L2 = [4,5,6,7,10]\n",
    "\n",
    "Common = []\n",
    "for i in L1:\n",
    "    if i in L2:\n",
    "        Common.append(i)\n",
    "\n",
    "print(Common)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd088e6",
   "metadata": {},
   "source": [
    "#### 22. Find the difference between two lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "1529ec2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3,4]\n",
    "L2 = [4,5,6,7]\n",
    "\n",
    "Common = []\n",
    "for i in L1:\n",
    "    if i not in L2:\n",
    "        Common.append(i)\n",
    "        \n",
    "for i in L2:\n",
    "    if i not in L1:\n",
    "        Common.append(i)\n",
    "\n",
    "print(Common)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2bb7ef6",
   "metadata": {},
   "source": [
    "#### 23. Merge two lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "e6258590",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3,4]\n",
    "L2 = [4,5,6,7]\n",
    "\n",
    "print(L1+L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f15227",
   "metadata": {},
   "source": [
    "#### 24. Multiply all elements in a list by 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "4162a577",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "L1 = [1,2,3,4]\n",
    "\n",
    "By2List = [i*2 for i in L1]\n",
    "\n",
    "print(By2List)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ee7b9ee",
   "metadata": {},
   "source": [
    "#### 25. Filter out all even numbers from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "83f36e43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[96, 100, 96, 42, 2, 34, 60, 44]\n"
     ]
    }
   ],
   "source": [
    "L1 = [71, 96, 100, 97, 96, 77, 47, 49, 79, 42, 99, 15, 47, 29, 2, 34, 60, 44, 63]\n",
    "\n",
    "FilterEven = [i for i in L1 if i%2==0]\n",
    "\n",
    "print(FilterEven)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "274a493a",
   "metadata": {},
   "source": [
    "#### 26. Convert a list of strings to a list of integers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "1c470a7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "L1 = ['1','2','3','4']\n",
    "\n",
    "IntString = [int(i) for i in L1]\n",
    "\n",
    "print(IntString)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a63c0245",
   "metadata": {},
   "source": [
    "#### 27. Convert a list of integers to a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "d62714a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['71', '96', '100', '97', '96', '77', '47', '49', '79', '42', '99', '15', '47', '29', '2', '34', '60', '44', '63']\n"
     ]
    }
   ],
   "source": [
    "L1 = [71, 96, 100, 97, 96, 77, 47, 49, 79, 42, 99, 15, 47, 29, 2, 34, 60, 44, 63]\n",
    "\n",
    "IntString = [str(i) for i in L1]\n",
    "\n",
    "print(IntString)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8142be73",
   "metadata": {},
   "source": [
    "#### 28. Flatten a nested list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "6bd70379",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened list: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]\n",
    "\n",
    "\n",
    "flattened = []\n",
    "for sublist in nested:\n",
    "    if isinstance(sublist, list):\n",
    "         flattened.extend(sublist)\n",
    "    else:\n",
    "        flattened.append(sublist)\n",
    "\n",
    "\n",
    "\n",
    "print(\"Flattened list:\", flattened)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea90b1f4",
   "metadata": {},
   "source": [
    "#### 29. Create a list of the first 10 Fibonacci numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "da54b3cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "FibFirst = 0 \n",
    "FibNext = 1\n",
    "\n",
    "FibSeries = []\n",
    "\n",
    "for i in range(1,11):\n",
    "    FibSeries.append(FibFirst)\n",
    "    \n",
    "    X = FibNext \n",
    "    FibNext = X + FibFirst\n",
    "    FibFirst = X\n",
    "    \n",
    "    \n",
    "    \n",
    "print(FibSeries)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c33f08ab",
   "metadata": {},
   "source": [
    "#### 30. Check if a list is sorted.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "id": "e510b887",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List is Sorted\n"
     ]
    }
   ],
   "source": [
    "List1 = [1,2,3,4]\n",
    "\n",
    "for i in range(len(List1)-1):\n",
    "    if List1[i] > List1[i+1]:\n",
    "        print('Not Sorted')\n",
    "        break\n",
    "else:\n",
    "    print('List is Sorted')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d2f2958",
   "metadata": {},
   "source": [
    "#### 31. Rotate a list to the left by `n` positions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "30e01605",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated List [3, 4, 5, 6, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "List1 = [1,2,3,4,5,6]\n",
    "Rotate = 2\n",
    "NormRotate = Rotate%len(List1)\n",
    "\n",
    "RoteatedList = List1[NormRotate:] + List1[:NormRotate]\n",
    "\n",
    "print('Rotated List', RoteatedList)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f24e495",
   "metadata": {},
   "source": [
    "#### 32. Rotate a list to the right by `n` positions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5283694f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated List [5, 6, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "List1 = [1,2,3,4,5,6]\n",
    "Rotate = 2\n",
    "NormRotate = Rotate%len(List1)\n",
    "\n",
    "RoteatedList = List1[-NormRotate:] + List1[:-NormRotate]\n",
    "\n",
    "print('Rotated List', RoteatedList)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3334e47",
   "metadata": {},
   "source": [
    "#### 33. Create a list of prime numbers up to 50.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c07e0873",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime numbers between 1 and 50: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "primes = []\n",
    "\n",
    "for num in range(2, 51):\n",
    "    is_prime = True\n",
    "    for i in range(2, int(num/2) + 1):\n",
    "        if num % i == 0:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        primes.append(num)\n",
    "\n",
    "print(\"Prime numbers between 1 and 50:\", primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56a2a3bf",
   "metadata": {},
   "source": [
    "#### 34. Split a list into chunks of size `n`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2cd9e0d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n",
      "[7, 11, 13]\n",
      "[17, 19, 23]\n",
      "[29, 31, 37]\n",
      "[41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n",
    "\n",
    "# Chunk size\n",
    "n = 3\n",
    "\n",
    "# Initialize an empty list to store chunks\n",
    "chunks = []\n",
    "\n",
    "# Loop through the list in steps of 'n' and create chunks\n",
    "for i in range(0, len(my_list), n):\n",
    "    chunk = my_list[i:i + n]\n",
    "    chunks.append(chunk)\n",
    "\n",
    "# Print the list of chunks\n",
    "for chunk in chunks:\n",
    "    print(chunk)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbf50e4f",
   "metadata": {},
   "source": [
    "#### 35. Find the second largest number in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "60623f2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43\n"
     ]
    }
   ],
   "source": [
    "L1 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n",
    "\n",
    "L1.remove(max(L1))\n",
    "\n",
    "print(max(L1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c3adf91",
   "metadata": {},
   "source": [
    "#### 36. Replace every element in a list with its square.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "90dda638",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9, 25, 49, 121, 169, 289, 361, 529, 841, 961, 1369, 1681, 1849, 2209]\n"
     ]
    }
   ],
   "source": [
    "L1 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n",
    "\n",
    "L1 = [i*i for i in L1]\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a94c2575",
   "metadata": {},
   "source": [
    "#### 37. Convert a list to a dictionary where list elements become keys and their indices become values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7dded25f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 0, 'banana': 1, 'cherry': 2, 'date': 3}\n"
     ]
    }
   ],
   "source": [
    "my_list = ['apple', 'banana', 'cherry', 'date']\n",
    "\n",
    "# Initialize an empty dictionary\n",
    "my_dict = {}\n",
    "\n",
    "# Loop through the list and create the dictionary\n",
    "for index, value in enumerate(my_list): #Enumerate give both index and value\n",
    "    my_dict[value] = index\n",
    "\n",
    "# Print the resulting dictionary\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d109131",
   "metadata": {},
   "source": [
    "#### 38. Shuffle the elements of a list randomly.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7aa66159",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 7, 6, 2, 10, 4, 9, 8, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "my_list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n",
    "\n",
    "# Shuffle the list in place\n",
    "random.shuffle(my_list)\n",
    "\n",
    "# Print the shuffled list\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab0de50b",
   "metadata": {},
   "source": [
    "#### 39. Create a list of the first 10 factorial numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "03201bff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "my_list = [math.factorial(i) for i in range(1,11) ]\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5de6f51f",
   "metadata": {},
   "source": [
    "#### 40. Check if two lists have at least one element in common.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b78add8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lists have at least one element in common.\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [4, 5, 6, 7, 8]\n",
    "\n",
    "# Convert the lists to sets and find their intersection\n",
    "set1 = set(list1)\n",
    "set2 = set(list2)\n",
    "intersection = set1.intersection(set2)\n",
    "\n",
    "# Check if there's at least one common element\n",
    "if len(intersection) > 0:\n",
    "    print(\"The lists have at least one element in common.\")\n",
    "else:\n",
    "    print(\"The lists have no common elements.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c080419",
   "metadata": {},
   "source": [
    "#### 41. Remove all elements from a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "620bf6e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n",
    "\n",
    "my_list.clear()\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b14fade0",
   "metadata": {},
   "source": [
    "#### 42. Replace negative numbers in a list with 0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f57e76d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[85, 29, 69, 8, 0, 80, 0, 46, 0, 16, 0, 0, 17, 0, 43, 0, 33, 20, 0]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "my_list = [random.randint(-100,100) for i in range(1,20)]\n",
    "\n",
    "PositiveList = []\n",
    "\n",
    "for i in my_list:\n",
    "    if i<0: \n",
    "        PositiveList.append(0)\n",
    "    else:\n",
    "        PositiveList.append(i)\n",
    "\n",
    "print(PositiveList)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90d212ac",
   "metadata": {},
   "source": [
    "#### 43. Convert a string into a list of words.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fa6827bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello,', 'World', 'Welcome', 'to', 'python', 'programming']\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, World Welcome to python programming\"\n",
    "\n",
    "word_list = text.split()\n",
    "\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b93c60a",
   "metadata": {},
   "source": [
    "#### 44. Convert a list of words into a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5b4633d",
   "metadata": {},
   "outputs": [],
   "source": [
    "word_list = ['Hello,', 'World', 'Welcome', 'to', 'python', 'programming']\n",
    "\n",
    "text = ' '.join(word_list)\n",
    "\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6458cced",
   "metadata": {},
   "source": [
    "#### 45. Create a list of the first `n` powers of 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "ed6c5857",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 10 powers of 2: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]\n"
     ]
    }
   ],
   "source": [
    "n = 10 \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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b3d1daa",
   "metadata": {},
   "source": [
    "#### 46. Find the longest string in a list of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "c31fa1bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The longest string in the list is: programming\n"
     ]
    }
   ],
   "source": [
    "string_list = ['Hello,', 'World', 'Welcome', 'to', 'python', 'programming']\n",
    "\n",
    "# Initialize a variable to store the longest string\n",
    "longest_string = \"\"\n",
    "\n",
    "for string in string_list:\n",
    "    if len(string) > len(longest_string):\n",
    "        longest_string = string\n",
    "\n",
    "print(\"The longest string in the list is:\", longest_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a11661d",
   "metadata": {},
   "source": [
    "#### 47. Find the shortest string in a list of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "32f7b062",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shortest string in the list is: to\n"
     ]
    }
   ],
   "source": [
    "string_list = ['Hello,', 'World', 'Welcome', 'to', 'python', 'programming']\n",
    "\n",
    "# Initialize a variable to store the shortest string\n",
    "shortest_string = None\n",
    "\n",
    "for string in string_list:\n",
    "    if shortest_string is None or len(string) < len(shortest_string):\n",
    "        shortest_string = string\n",
    "\n",
    "print(\"The shortest string in the list is:\", shortest_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b5347fb",
   "metadata": {},
   "source": [
    "#### 48. Create a list of the first `n` triangular numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "01d962ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 50 triangular numbers: [1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, 120, 136, 153, 171, 190, 210, 231, 253, 276, 300, 325, 351, 378, 406, 435, 465, 496, 528, 561, 595, 630, 666, 703, 741, 780, 820, 861, 903, 946, 990, 1035, 1081, 1128, 1176, 1225, 1275]\n"
     ]
    }
   ],
   "source": [
    "n = 50  # Change 'n' to the desired number of triangular numbers\n",
    "triangular_numbers = [i * (i + 1) // 2 for i in range(1, n + 1)]\n",
    "\n",
    "print(\"List of the first\", n, \"triangular numbers:\", triangular_numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98971e30",
   "metadata": {},
   "source": [
    "#### 49. Check if a list contains another list as a subsequence.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "3f870f22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list1 contains list2 as a subsequence.\n"
     ]
    }
   ],
   "source": [
    "# Example lists\n",
    "list1 = [1, 2, 3, 4, 5, 6]\n",
    "list2 = [2, 4, 6]\n",
    "\n",
    "# Initialize pointers for list1 and list2\n",
    "i, j = 0, 0\n",
    "\n",
    "# Iterate through both lists\n",
    "while i < len(list1) and j < len(list2):\n",
    "    if list1[i] == list2[j]:\n",
    "        j += 1\n",
    "    i += 1\n",
    "\n",
    "# Check if j reaches the length of list2, indicating list2 is a subsequence\n",
    "if j == len(list2):\n",
    "    print(\"list1 contains list2 as a subsequence.\")\n",
    "else:\n",
    "    print(\"list1 does not contain list2 as a subsequence.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71139769",
   "metadata": {},
   "source": [
    "#### 50. Swap two elements in a list by their indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "de1044a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after swapping elements: [1, 4, 3, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Indices of elements to swap\n",
    "index1 = 1\n",
    "index2 = 3\n",
    "\n",
    "# Check if the indices are valid\n",
    "if 0 <= index1 < len(my_list) and 0 <= index2 < len(my_list):\n",
    "    # Swap the elements\n",
    "    my_list[index1], my_list[index2] = my_list[index2], my_list[index1]\n",
    "    print(\"List after swapping elements:\", my_list)\n",
    "else:\n",
    "    print(\"Invalid indices for swapping.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4637d335",
   "metadata": {},
   "source": [
    "# Tuple Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eae6912f",
   "metadata": {},
   "source": [
    "#### 1. Create a tuple with integers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "b63d8fa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "Tup1 = tuple(range(1,6))\n",
    "print(Tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d98768ff",
   "metadata": {},
   "source": [
    "#### 2. Access the third element of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "24d0b729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "Tup1 = (1,2,3,4,56,7,8)\n",
    "\n",
    "print(Tup1[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3d294f9",
   "metadata": {},
   "source": [
    "#### 3. Find the length of a tuple without using the `len()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "22171f55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "Tup1 = (1,2,3,4,56,7,8)\n",
    "counter = 0\n",
    "for i in Tup1:\n",
    "    counter += 1\n",
    "    \n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1d1ad7b",
   "metadata": {},
   "source": [
    "#### 4. Count the occurrences of an element in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f1efb74a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The element 2 appears 4 times in the tuple.\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 2, 3, 4, 2, 5, 2)\n",
    "\n",
    "element_to_count = 2\n",
    "\n",
    "count = my_tuple.count(element_to_count)\n",
    "\n",
    "print(f\"The element {element_to_count} appears {count} times in the tuple.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc6f53e",
   "metadata": {},
   "source": [
    "#### 5. Find the index of the first occurrence of an element in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "c04c6730",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first occurrence of 2 is at index 1.\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 2, 3, 4, 2, 5, 2)\n",
    "\n",
    "element_to_find = 2\n",
    "\n",
    "index = my_tuple.index(element_to_find)\n",
    "\n",
    "print(f\"The first occurrence of {element_to_find} is at index {index}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8585bc4b",
   "metadata": {},
   "source": [
    "#### 6. Check if an element exists in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "6d1dcabf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, element Exist\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 2, 3, 4, 2, 5, 2)\n",
    "\n",
    "element_to_find = 5\n",
    "\n",
    "if element_to_find in my_tuple:\n",
    "    print('Yes, element Exist')\n",
    "else: \n",
    "    print('Element Does Not Exist')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c960fc59",
   "metadata": {},
   "source": [
    "#### 7. Convert a tuple to a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "88cb24b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 3, 4, 2, 5, 2]\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 2, 3, 4, 2, 5, 2)\n",
    "\n",
    "my_list = list(my_tuple)\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abfab11e",
   "metadata": {},
   "source": [
    "#### 8. Convert a list to a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "67860b4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 2, 3, 4, 2, 5, 2)\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 2, 3, 4, 2, 5, 2]\n",
    "\n",
    "my_tuple = tuple(my_list)\n",
    "\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62fdba1e",
   "metadata": {},
   "source": [
    "#### 9. Unpack the elements of a tuple into variables.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "e8290121",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1: 1\n",
      "var2: 2\n",
      "var3: 3\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3)\n",
    "\n",
    "# Unpack the elements of the tuple into variables\n",
    "var1, var2, var3 = my_tuple\n",
    "\n",
    "# Print the variables\n",
    "print(\"var1:\", var1)\n",
    "print(\"var2:\", var2)\n",
    "print(\"var3:\", var3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57a9f328",
   "metadata": {},
   "source": [
    "#### 10. Create a tuple of even numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "af60854e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4, 6, 8, 10)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple =tuple(x for x in range(2, 11, 2))\n",
    "\n",
    "\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8fff54d",
   "metadata": {},
   "source": [
    "#### 11. Create a tuple of odd numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "a68dda01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3, 5, 7, 9)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple =tuple(x for x in range(1, 11, 2))\n",
    "\n",
    "\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa4712a3",
   "metadata": {},
   "source": [
    "#### 12. Concatenate two tuples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "3b1c2d67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "tup1 = (1,2,3,4)\n",
    "tup2 = (4,5,6,7)\n",
    "\n",
    "print(tup1+tup2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f41e6499",
   "metadata": {},
   "source": [
    "#### 13. Repeat a tuple three times.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "a2d3e7ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "tup1 = (4,5,6,7)\n",
    "\n",
    "print(tup1*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acb09581",
   "metadata": {},
   "source": [
    "#### 14. Check if a tuple is empty.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "33bf3a5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple is empty.\n"
     ]
    }
   ],
   "source": [
    "my_tuple = ()\n",
    "\n",
    "if len(my_tuple) == 0:\n",
    "    print(\"The tuple is empty.\")\n",
    "else:\n",
    "    print(\"The tuple is not empty.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "291d3cbd",
   "metadata": {},
   "source": [
    "#### 15. Create a nested tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "24eadc92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n",
      "(3, 4)\n",
      "(5, 6)\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = ((1, 2), (3, 4), (5, 6))\n",
    "\n",
    "for i in nested_tuple:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e19d88a9",
   "metadata": {},
   "source": [
    "#### 16. Access the first element of a nested tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "93fce34b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = ((1, 2), (3, 4), (5, 6))\n",
    "\n",
    "first_element = nested_tuple[0][0]\n",
    "\n",
    "print(first_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd74cf1",
   "metadata": {},
   "source": [
    "#### 17. Create a tuple with a single element.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "fbfc1e6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42,)\n"
     ]
    }
   ],
   "source": [
    "single_element_tuple = (42,)\n",
    "\n",
    "print(single_element_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8cafd67",
   "metadata": {},
   "source": [
    "#### 18. Compare two tuples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "df703e92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuples are not equal.\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 4)\n",
    "\n",
    "if tuple1 == tuple2:\n",
    "    print(\"The tuples are equal.\")\n",
    "else:\n",
    "    print(\"The tuples are not equal.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cd1a0fd",
   "metadata": {},
   "source": [
    "#### 19. Delete a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a61e11f",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2, 3)\n",
    "del my_tuple\n",
    "# Now, 'my_tuple' no longer exists.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95305d0c",
   "metadata": {},
   "source": [
    "#### 20. Slice a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "218f58d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "sliced_tuple = my_tuple[1:4]  # This will create a new tuple (2, 3, 4)\n",
    "\n",
    "print(sliced_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "403fb888",
   "metadata": {},
   "source": [
    "#### 21. Find the maximum value in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "ebd1d162",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)\n",
    "max_value = max(my_tuple)\n",
    "\n",
    "print(max_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de7af43",
   "metadata": {},
   "source": [
    "#### 22. Find the minimum value in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "a50b3df2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)\n",
    "min_value = min(my_tuple)\n",
    "\n",
    "print(min_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a085bf94",
   "metadata": {},
   "source": [
    "#### 23. Convert a string to a tuple of characters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "f4ff2062",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!')\n"
     ]
    }
   ],
   "source": [
    "my_string = \"Hello, World!\"\n",
    "char_tuple = tuple(char for char in my_string)\n",
    "\n",
    "print(char_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18504d75",
   "metadata": {},
   "source": [
    "#### 24. Convert a tuple of characters to a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "6e2d1f06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "char_tuple = ('H', 'e', 'l', 'l', 'o')\n",
    "my_string = ''.join(char_tuple)\n",
    "\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e621256",
   "metadata": {},
   "source": [
    "#### 25. Create a tuple from multiple data types.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "69c58142",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'apple', 3.14, True)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 'apple', 3.14, True)\n",
    "\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4722aac6",
   "metadata": {},
   "source": [
    "#### 26. Check if two tuples are identical.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "060331a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The two tuples are identical.\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 3)\n",
    "if tuple1 == tuple2:\n",
    "    print(\"The two tuples are identical.\")\n",
    "else:\n",
    "    print('The Two tuples are not Identical')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16984dcd",
   "metadata": {},
   "source": [
    "#### 27. Sort the elements of a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "19fa457a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (5, 3, 1, 4, 2)\n",
    "sorted_tuple = tuple(sorted(my_tuple))\n",
    "\n",
    "print(sorted_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdb5a3df",
   "metadata": {},
   "source": [
    "#### 28. Convert a tuple of integers to a tuple of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "fdf0d0a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('1', '2', '3', '4', '5')\n"
     ]
    }
   ],
   "source": [
    "int_tuple = (1, 2, 3, 4, 5)\n",
    "str_tuple = tuple(str(num) for num in int_tuple)\n",
    "\n",
    "print(str_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d334a0a5",
   "metadata": {},
   "source": [
    "#### 29. Convert a tuple of strings to a tuple of integers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "8bdda59d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "str_tuple = ('1', '2', '3', '4', '5')\n",
    "int_tuple = tuple(int(num) for num in str_tuple)\n",
    "\n",
    "print(int_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "219ddeb6",
   "metadata": {},
   "source": [
    "#### 30. Merge two tuples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "8ff0f92e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (4, 5, 6)\n",
    "merged_tuple = tuple1 + tuple2\n",
    "\n",
    "print(merged_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa7dc39c",
   "metadata": {},
   "source": [
    "#### 31. Flatten a nested tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "f392b3af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 7, 4, 5, 6, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = (1, (2, 3), (4, (5, 6)), 7)\n",
    "\n",
    "flat_list = []\n",
    "\n",
    "stack = [nested_tuple]\n",
    "\n",
    "while stack:\n",
    "    current = stack.pop()\n",
    "    for item in current:\n",
    "        if isinstance(item, tuple):\n",
    "            stack.append(item)\n",
    "        else:\n",
    "            flat_list.append(item)\n",
    "\n",
    "flat_tuple = tuple(flat_list)\n",
    "\n",
    "print(flat_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66d0debd",
   "metadata": {},
   "source": [
    "#### 32. Create a tuple of the first 5 prime numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "89d30eaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first 10 prime numbers are: (2, 3, 5, 7, 11, 13, 17, 19, 23, 29)\n"
     ]
    }
   ],
   "source": [
    "primes = []\n",
    "n \n",
    "\n",
    "num = 2  \n",
    "\n",
    "while len(primes) < n:\n",
    "    is_prime = True\n",
    "    for i in range(2, int(num / 2) + 1):\n",
    "        if num % i == 0:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        primes.append(num)\n",
    "    num += 1\n",
    "\n",
    "print(f\"The first {n} prime numbers are: {tuple(primes)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0a4a540",
   "metadata": {},
   "source": [
    "#### 33. Check if a tuple is a palindrome.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "d4c9119f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 2, 1)\n",
    "is_palindrome = my_tuple == my_tuple[::-1]\n",
    "\n",
    "print(is_palindrome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99230767",
   "metadata": {},
   "source": [
    "#### 34. Create a tuple of squares of numbers from 1 to 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "bd7d1b72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 4, 9, 16, 25)\n"
     ]
    }
   ],
   "source": [
    "squares_tuple = tuple(i**2 for i in range(1, 6))\n",
    "\n",
    "print(squares_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80f0e148",
   "metadata": {},
   "source": [
    "#### 35. Filter out all even numbers from a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "13edc7dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
    "filtered_tuple = tuple(x for x in my_tuple if x % 2 != 0)\n",
    "\n",
    "print(filtered_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13354a40",
   "metadata": {},
   "source": [
    "#### 36. Multiply all elements in a tuple by 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "ee885de4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "doubled_tuple = tuple(x * 2 for x in my_tuple)\n",
    "\n",
    "print(doubled_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b89c89",
   "metadata": {},
   "source": [
    "#### 37. Create a tuple of random numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "54e95ce2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 7, 6, 10, 2)\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random_numbers = tuple(random.randint(1, 10) for _ in range(5))\n",
    "\n",
    "print(random_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c294410",
   "metadata": {},
   "source": [
    "#### 38. Check if a tuple is sorted.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "99df1f7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, Tuple is sorted\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "is_sorted = my_tuple == tuple(sorted(my_tuple))\n",
    "\n",
    "if is_sorted:\n",
    "    print('Yes, Tuple is sorted')\n",
    "else:\n",
    "    print('Tuple is not sorted')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06a69c0c",
   "metadata": {},
   "source": [
    "#### 39. Rotate a tuple to the left by `n` positions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "4adc9b06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4, 5, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "n = 2\n",
    "rotated_tuple = my_tuple[n:] + my_tuple[:n]\n",
    "print(rotated_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8db618b",
   "metadata": {},
   "source": [
    "#### 40. Rotate a tuple to the right by `n` positions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "97be6aa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 5, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "n = 2\n",
    "rotated_tuple = my_tuple[-n:] + my_tuple[:-n]\n",
    "print(rotated_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecaf7e7f",
   "metadata": {},
   "source": [
    "#### 41. Create a tuple of the first 5 Fibonacci numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "9d51b112",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first 5 Fibonacci numbers are: (0, 1, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "\n",
    "# Initialize the first two Fibonacci numbers\n",
    "fibonacci_numbers = [0, 1]\n",
    "\n",
    "# Generate the Fibonacci series up to the nth element\n",
    "while len(fibonacci_numbers) < n:\n",
    "    next_fibonacci = fibonacci_numbers[-1] + fibonacci_numbers[-2]\n",
    "    fibonacci_numbers.append(next_fibonacci)\n",
    "\n",
    "# Display the first 'n' Fibonacci numbers\n",
    "\n",
    "Fib_Tuple = tuple(fibonacci_numbers)\n",
    "print(f\"The first {n} Fibonacci numbers are: {Fib_Tuple}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af80fcd4",
   "metadata": {},
   "source": [
    "#### 42. Create a tuple from user input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "c60e2987",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter values separated by spaces: Hello world \n",
      "('Hello', 'world', '')\n"
     ]
    }
   ],
   "source": [
    "user_input = input(\"Enter values separated by spaces: \")\n",
    "\n",
    "input_list = user_input.split(' ')\n",
    "\n",
    "input_tuple =tuple(input_list)\n",
    "\n",
    "print(input_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b1dcab",
   "metadata": {},
   "source": [
    "#### 43. Swap two elements in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "31cd0038",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swapped tuple: (1, 4, 3, 2, 5)\n"
     ]
    }
   ],
   "source": [
    "# Create a tuple\n",
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "\n",
    "# Swap elements at indices 1 and 3\n",
    "index1 = 1\n",
    "index2 = 3\n",
    "swapped_tuple = tuple(\n",
    "    my_tuple[i] if i not in (index1, index2) else\n",
    "    my_tuple[index2] if i == index1 else\n",
    "    my_tuple[index1]\n",
    "    for i in range(len(my_tuple))\n",
    ")\n",
    "\n",
    "# Print the swapped tuple\n",
    "print(\"Swapped tuple:\", swapped_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da966ea4",
   "metadata": {},
   "source": [
    "#### 44. Reverse the elements of a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "ef845533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 4, 3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "reversed_tuple = my_tuple[::-1]\n",
    "\n",
    "print(reversed_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36fc80f8",
   "metadata": {},
   "source": [
    "#### 45. Create a tuple of the first `n` powers of 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "17e6c530",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "powers_of_2 = tuple(2 ** i for i in range(n))\n",
    "\n",
    "print(powers_of_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "984c2a4f",
   "metadata": {},
   "source": [
    "#### 46. Find the longest string in a tuple of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "8a8cac24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n"
     ]
    }
   ],
   "source": [
    "string_tuple = (\"apple\", \"banana\", \"cherry\", \"date\")\n",
    "longest_string = max(string_tuple, key=len)\n",
    "\n",
    "print(longest_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89230045",
   "metadata": {},
   "source": [
    "#### 47. Find the shortest string in a tuple of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "827a034d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "date\n"
     ]
    }
   ],
   "source": [
    "string_tuple = (\"apple\", \"banana\", \"cherry\", \"date\")\n",
    "shortest_string = min(string_tuple, key=len)\n",
    "\n",
    "print(shortest_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3cbfc55",
   "metadata": {},
   "source": [
    "#### 48. Create a tuple of the first `n` triangular numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "c14856ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 6, 10, 15)\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "triangular_numbers = tuple((i * (i + 1)) // 2 for i in range(1, n + 1))\n",
    "\n",
    "print(triangular_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "117c0977",
   "metadata": {},
   "source": [
    "#### 49. Check if a tuple contains another tuple as a subsequence.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "b7622d02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes it is a subsequence\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3, 4, 5)\n",
    "tuple2 = (2, 3, 4)\n",
    "is_subsequence = any(tuple1[i:i+len(tuple2)] == tuple2 for i in range(len(tuple1) - len(tuple2) + 1))\n",
    "\n",
    "if is_subsequence:\n",
    "    print('Yes it is a subsequence')\n",
    "else:\n",
    "    print('Not its not subsequence')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "515dc11a",
   "metadata": {},
   "source": [
    "#### 50. Create a tuple of alternating 1s and 0s of length `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "f64ecd43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 0, 1, 0, 1, 0, 1, 0, 1, 0)\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "alternating_tuple = tuple(1 if i % 2 == 0 else 0 for i in range(n))\n",
    "\n",
    "print(alternating_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e217080",
   "metadata": {},
   "source": [
    "# Set Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92cf3e9a",
   "metadata": {},
   "source": [
    "#### 1. Create a set with integers from 1 to 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "b2e4ca2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {i for i in range(1,6)}\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "827d53d7",
   "metadata": {},
   "source": [
    "#### 2. Add an element to a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "ae718b8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3}\n",
    "my_set.add(4)\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f83d794a",
   "metadata": {},
   "source": [
    "#### 3. Remove an element from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "9bf828c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.remove(4)\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745fd64b",
   "metadata": {},
   "source": [
    "#### 4. Check if an element exists in a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "ab8656cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 exists in the set.\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "element = 3\n",
    "if element in my_set:\n",
    "    print(f\"{element} exists in the set.\")\n",
    "else:\n",
    "    print(f\"{element} doesn't exists in the set.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a38073e",
   "metadata": {},
   "source": [
    "#### 5. Find the length of a set without using the `len()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "a504865a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of the set is 5.\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "count = 0\n",
    "for _ in my_set:\n",
    "    count += 1\n",
    "print(f\"The length of the set is {count}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2e61cf2",
   "metadata": {},
   "source": [
    "#### 6. Clear all elements from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "60975990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.clear()\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc959a53",
   "metadata": {},
   "source": [
    "#### 7. Create a set of even numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "4b9a6a57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "even_set = {x for x in range(1, 11) if x % 2 == 0}\n",
    "\n",
    "print(even_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e7b56d",
   "metadata": {},
   "source": [
    "#### 8. Create a set of odd numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "1b75e07f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "odd_set = {x for x in range(1, 11) if x % 2 != 0}\n",
    "\n",
    "print(odd_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d1d003",
   "metadata": {},
   "source": [
    "#### 9. Find the union of two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "83de751f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "union_set = set1.union(set2)\n",
    "# or\n",
    "# union_set = set1 | set2\n",
    "\n",
    "print(union_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fee99056",
   "metadata": {},
   "source": [
    "#### 10. Find the intersection of two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "726a4a15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "intersection_set = set1.intersection(set2)\n",
    "# or\n",
    "# intersection_set = set1 & set2\n",
    "\n",
    "print(intersection_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eb90f49",
   "metadata": {},
   "source": [
    "#### 11. Find the difference between two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "f591f40d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "difference_set = set1.difference(set2)\n",
    "# or\n",
    "#difference_set = set1 - set2\n",
    "\n",
    "print(difference_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb98e468",
   "metadata": {},
   "source": [
    "#### 12. Check if a set is a subset of another set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "99f83e96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "its a Subset\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {1, 2, 3, 4, 5}\n",
    "is_subset = set1.issubset(set2)\n",
    "# or\n",
    "is_subset = set1 <= set2\n",
    "\n",
    "if is_subset:\n",
    "    print('its a Subset')\n",
    "else:\n",
    "    print('Its Not Subset')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b7e4796",
   "metadata": {},
   "source": [
    "#### 13. Check if a set is a superset of another set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "de8d8322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "its a SuperSet\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {1, 2, 3}\n",
    "is_superset = set1.issuperset(set2)\n",
    "# or\n",
    "is_superset = set1 >= set2\n",
    "\n",
    "if is_superset:\n",
    "    print('its a SuperSet')\n",
    "else:\n",
    "    print('Its Not SuperSet')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ece21b0",
   "metadata": {},
   "source": [
    "#### 14. Create a set from a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "a5f27874",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_set = set(my_list)\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4af77ab",
   "metadata": {},
   "source": [
    "#### 15. Convert a set to a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "248eaed0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_list = list(my_set)\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e52d594",
   "metadata": {},
   "source": [
    "#### 16. Remove a random element from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "fa22eed5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "removed_element = my_set.pop()\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1fd4bce",
   "metadata": {},
   "source": [
    "#### 17. Pop an element from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "76ba4268",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "removed_element = my_set.pop()\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52fb1afb",
   "metadata": {},
   "source": [
    "#### 18. Check if two sets have no elements in common.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "3822c75b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have Common Elements\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "Common_Element = set1.isdisjoint(set2)\n",
    "\n",
    "if Common_Element:\n",
    "    print('Have Common Elements')\n",
    "else:\n",
    "    print('Does not Have common elements')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f125385e",
   "metadata": {},
   "source": [
    "#### 19. Find the symmetric difference between two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "4fa69397",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {3, 4, 5, 6}\n",
    "symmetric_diff = set1.symmetric_difference(set2)\n",
    "# or\n",
    "# symmetric_diff = set1 ^ set2\n",
    "\n",
    "print(symmetric_diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf57564c",
   "metadata": {},
   "source": [
    "#### 20. Update a set with elements from another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "13d22a0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set1.update(set2)\n",
    "# or\n",
    "# set1 |= set2\n",
    "\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "617e25d4",
   "metadata": {},
   "source": [
    "#### 21. Create a set of the first 5 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "e4cb1e37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first 5 prime numbers are: {2, 3, 5, 7, 11}\n"
     ]
    }
   ],
   "source": [
    "primes = set()\n",
    "n = 5\n",
    "\n",
    "num = 2  \n",
    "\n",
    "while len(primes) < n:\n",
    "    is_prime = True\n",
    "    for i in range(2, int(num / 2) + 1):\n",
    "        if num % i == 0:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        primes.add(num)\n",
    "    num += 1\n",
    "\n",
    "print(f\"The first {n} prime numbers are: {primes}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfeceeb3",
   "metadata": {},
   "source": [
    "#### 22. Check if two sets are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "6534bbc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both sets are identical\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 2, 1}\n",
    "are_identical = set1 == set2\n",
    "\n",
    "if are_identical:\n",
    "    print('Both sets are identical')\n",
    "else:\n",
    "    print('No both are not identical')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcc433e4",
   "metadata": {},
   "source": [
    "#### 23. Create a frozen set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "4eb4944e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frozenset({1, 2, 3})\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3}\n",
    "frozen_set = frozenset(my_set)\n",
    "\n",
    "print(frozen_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c467f268",
   "metadata": {},
   "source": [
    "#### 24. Check if a set is disjoint with another set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "5c0593e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set is disjoint with another set\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "are_disjoint = set1.isdisjoint(set2)\n",
    "\n",
    "if are_disjoint:\n",
    "    print('Set is disjoint with another set')\n",
    "else:\n",
    "    print('Set is not disjoint with antoher set')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faaebd5d",
   "metadata": {},
   "source": [
    "#### 25. Create a set of squares of numbers from 1 to 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "bfcc5631",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 4, 9, 16, 25}\n"
     ]
    }
   ],
   "source": [
    "squares_set = {x**2 for x in range(1, 6)}\n",
    "\n",
    "print(squares_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd20211e",
   "metadata": {},
   "source": [
    "#### 26. Filter out all even numbers from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "61ba4eb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5, 6, 7, 8}\n",
    "filtered_set = {x for x in my_set if x % 2 != 0}\n",
    "\n",
    "print(filtered_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e945e6e2",
   "metadata": {},
   "source": [
    "#### 27. Multiply all elements in a set by 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "82c1c723",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "multiplied_set = {x * 2 for x in my_set}\n",
    "\n",
    "print(multiplied_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68d043a7",
   "metadata": {},
   "source": [
    "#### 28. Create a set of random numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "08c3a21f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 5, 8}\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random_set = set(random.randint(1, 10) for _ in range(5))\n",
    "\n",
    "print(random_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cba9e4e2",
   "metadata": {},
   "source": [
    "#### 29. Check if a set is empty.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "fedf8bf4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The set is empty\n"
     ]
    }
   ],
   "source": [
    "my_set = set()  # An empty set\n",
    "if not my_set:\n",
    "    print(\"The set is empty\")\n",
    "else:\n",
    "    print('Set is not empty')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d31e606f",
   "metadata": {},
   "source": [
    "#### 30. Create a nested set (hint: use frozenset)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "0b86f2dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, frozenset({2, 3})}\n"
     ]
    }
   ],
   "source": [
    "nested_set = {1, frozenset({2, 3})}\n",
    "\n",
    "print(nested_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55a44d80",
   "metadata": {},
   "source": [
    "#### 31. Remove an element from a set using the discard method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "c53f8415",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.discard(3)  # Removes 3 from the set if it's present\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59759a9e",
   "metadata": {},
   "source": [
    "#### 32. Compare two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "1b994143",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both set are equal\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 2, 1}\n",
    "are_equal = set1 == set2  # This will return True\n",
    "\n",
    "if are_equal:\n",
    "    print('Both set are equal')\n",
    "else:\n",
    "    print('Both Set are not Equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7a728be",
   "metadata": {},
   "source": [
    "#### 33. Create a set from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "cd6198d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'h', 'o', 'l', 'e'}\n"
     ]
    }
   ],
   "source": [
    "my_string = \"hello\"\n",
    "char_set = {char for char in my_string}\n",
    "\n",
    "print(char_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9884f72",
   "metadata": {},
   "source": [
    "#### 34. Convert a set of strings to a set of integers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "745f341c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "string_set = {\"1\", \"2\", \"3\"}\n",
    "int_set = {int(x) for x in string_set}\n",
    "\n",
    "print(int_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaee6b63",
   "metadata": {},
   "source": [
    "#### 35. Convert a set of integers to a set of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "71566550",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'1', '3', '2'}\n"
     ]
    }
   ],
   "source": [
    "int_set = {1, 2, 3}\n",
    "string_set = {str(x) for x in int_set}\n",
    "\n",
    "print(string_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8430949b",
   "metadata": {},
   "source": [
    "#### 36. Create a set from a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "ac1118a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3)\n",
    "my_set = set(my_tuple)\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1a2ee1e",
   "metadata": {},
   "source": [
    "#### 37. Convert a set to a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "fbcf5808",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3}\n",
    "my_tuple = tuple(my_set)\n",
    "\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf054761",
   "metadata": {},
   "source": [
    "#### 38. Find the maximum value in a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "1bed1505",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "max_value = max(my_set)\n",
    "\n",
    "print(max_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edfd6ead",
   "metadata": {},
   "source": [
    "#### 39. Find the minimum value in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "956ae9d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "min_value = min(my_set)\n",
    "\n",
    "print(min_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd3fb08b",
   "metadata": {},
   "source": [
    "#### 40. Create a set from user input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "227383e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter values separated by spaces: Hello world\n",
      "{'Hello', 'world'}\n"
     ]
    }
   ],
   "source": [
    "user_input = input(\"Enter values separated by spaces: \")\n",
    "input_list = user_input.split()\n",
    "user_set = set(input_list)\n",
    "\n",
    "print(user_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8ba5fc9",
   "metadata": {},
   "source": [
    "#### 41. Check if the intersection of two sets is empty.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "7dba805f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection of two sets is empty\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "\n",
    "intersection_empty = set1.intersection(set2) == set()\n",
    "\n",
    "if intersection_empty:\n",
    "    print('Intersection of two sets is empty')\n",
    "else:\n",
    "    print('Intersection of two sets is not empty')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b37a4def",
   "metadata": {},
   "source": [
    "#### 42. Create a set of the first 5 Fibonacci numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "602afecd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first 5 Fibonacci numbers in a set are: {0, 1, 2, 3, 34, 5, 8, 13, 21}\n"
     ]
    }
   ],
   "source": [
    "fibonacci_set = set()\n",
    "\n",
    "# Initialize the first two Fibonacci numbers\n",
    "a, b = 0, 1\n",
    "\n",
    "# Generate the first 5 Fibonacci numbers and add them to the set\n",
    "for i in range(10):\n",
    "    fibonacci_set.add(a)\n",
    "    a, b = b, a + b\n",
    "\n",
    "# Display the set of the first 5 Fibonacci numbers\n",
    "print(\"The first 5 Fibonacci numbers in a set are:\", fibonacci_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa0cd28",
   "metadata": {},
   "source": [
    "#### 43. Remove duplicates from a list using sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "12e2d2d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 2, 3, 4, 4, 5]\n",
    "unique_list = list(set(my_list))\n",
    "\n",
    "print(unique_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05d77263",
   "metadata": {},
   "source": [
    "#### 44. Check if two sets have the same elements, regardless of their count.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "b0718fdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both Set have same elements\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 2, 1, 1, 2, 3}\n",
    "have_same_elements = set1 == set2  # This will return True\n",
    "\n",
    "if have_same_elements:\n",
    "    print('Both Set have same elements')\n",
    "else:\n",
    "    print('Both do not have same elements')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4303e225",
   "metadata": {},
   "source": [
    "#### 45. Create a set of the first `n` powers of 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "34f19549",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "powers_of_2_set = {2**i for i in range(n)}\n",
    "\n",
    "print(powers_of_2_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df5992a3",
   "metadata": {},
   "source": [
    "#### 46. Find the common elements between a set and a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "bb4fa126",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_list = [3, 4, 5, 6, 7]\n",
    "common_elements = my_set.intersection(my_list)\n",
    "\n",
    "print(common_elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7954d08c",
   "metadata": {},
   "source": [
    "#### 47. Create a set of the first `n` triangular numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "777b8487",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 6, 10, 15)\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "triangular_set = {i * (i + 1) // 2 for i in range(1, n + 1)}\n",
    "\n",
    "print(triangular_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67675a7",
   "metadata": {},
   "source": [
    "#### 48. Check if a set contains another set as a subset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "162a2390",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, Set2 is a subset of set1\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5, 6}\n",
    "set2 = {2, 3, 4}\n",
    "is_subset = set2.issubset(set1)  # This will return True because set2 is a subset of set1\n",
    "\n",
    "if is_subset:\n",
    "    print('Yes, Set2 is a subset of set1')\n",
    "else:\n",
    "    print('No, Set2 is not a subset of set1')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91df54cd",
   "metadata": {},
   "source": [
    "\n",
    "#### 49. Create a set of alternating 1s and 0s of length `n`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "995d3546",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1}\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "alternating_set = {1 if i % 2 == 0 else 0 for i in range(n)}\n",
    "\n",
    "print(alternating_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01d1657e",
   "metadata": {},
   "source": [
    "#### 50. Merge multiple sets into one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "eb8089f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{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)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}