20th_August_Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "54ee6de5",
   "metadata": {},
   "source": [
    "# TOPIC: String Based Assignment Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "725b4bc1",
   "metadata": {},
   "source": [
    "# 1. Write a program to reverse a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1959e97a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the reversed string is: tnemngissa dnoces ym si sihT\n"
     ]
    }
   ],
   "source": [
    "string=\"This is my second assignment\"\n",
    "rev_string=string[::-1]\n",
    "print(\"the reversed string is:\",rev_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d00f4bcb",
   "metadata": {},
   "source": [
    "# 2. Check if a string is a palindrome.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "235cdc38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:Madam\n",
      "madam is a palindrome string\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "string=string.lower()\n",
    "stringrev=string[-1::-1]\n",
    "if string==stringrev:\n",
    "    print(string +\" is a palindrome string\")\n",
    "else:\n",
    "    print(string +\" is not a palindrome string\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07b66f40",
   "metadata": {},
   "source": [
    "# 3. Convert a string to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c1e84332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:this is my second assignment\n",
      "upper case string is: THIS IS MY SECOND ASSIGNMENT\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "up_string=string.upper();\n",
    "print(\"upper case string is:\",up_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0c8e16f",
   "metadata": {},
   "source": [
    "# 4. Convert a string to lowercase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "097aa590",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:THis IS My SECond ASSignMENT\n",
      "lower case string is: this is my second assignment\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "lw_string=string.lower();\n",
    "print(\"lower case string is:\",lw_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d88056b",
   "metadata": {},
   "source": [
    "# 5. Count the number of vowels in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ca616e1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:this is my second assignment\n",
      "Number of Vowels in the string:  7\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "count=0\n",
    "string=string.lower()\n",
    "vowel=\"aeiou\"\n",
    "for char in string:\n",
    "    if char in vowel:\n",
    "        count+=1\n",
    "print(\"Number of Vowels in the string: \",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef42441f",
   "metadata": {},
   "source": [
    "# 6. Count the number of consonants in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ef7bf504",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:this is my second assignment\n",
      "Number of consonants in the string:  17\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "count=0\n",
    "string=string.lower()\n",
    "consonants=\"bcdfghjklmnpqrstvwxyz\"\n",
    "for char in string:\n",
    "    if char in consonants:\n",
    "        count+=1\n",
    "print(\"Number of consonants in the string: \",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cf6cc6e",
   "metadata": {},
   "source": [
    "# 7. Remove all whitespaces from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a04bfbf9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:Th  is      is      m  y  seco  n d assignmen   t\n",
      "String after removing all white spaces:\n",
      " Thisismysecondassignment\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "string_new=string.replace(\" \",\"\")\n",
    "print(\"String after removing all white spaces:\\n\",string_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30e63371",
   "metadata": {},
   "source": [
    "# 8. Find the length of a string without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "abdef8bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is a test string\n",
      "The length of the string is: 21\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "count=0\n",
    "for i in string:\n",
    "    count+=1\n",
    "print(\"The length of the string is:\",count)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c370a7f6",
   "metadata": {},
   "source": [
    "# 9. Check if a string contains a specific word.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6e7981c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am a good boy\n",
      "Enter the word to be checked:good\n",
      "The string contains the word 'good' \n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "word=input(\"Enter the word to be checked:\")\n",
    "if word in string:\n",
    "    print(\"The string contains the word '{}' \".format(word))\n",
    "else:\n",
    "    print(\"The string does not contains the word '{}'\".format(word))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be2e01b9",
   "metadata": {},
   "source": [
    "# 10. Replace a word in a string with another word.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b2e6676a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am a good boy\n",
      "Enter the word to be replaced:good\n",
      "Enter the new word:bad\n",
      "The modified string is:\n",
      " I am a bad boy\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "old_word=input(\"Enter the word to be replaced:\")\n",
    "new_word=input(\"Enter the new word:\")\n",
    "mod_string=string.replace(old_word,new_word)\n",
    "print(\"The modified string is:\\n\",mod_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce36fdcb",
   "metadata": {},
   "source": [
    "# 11. Count the occurrences of a word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "edaf2e41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is a sample string.This sample string is to check occurrences of a word.\n",
      "Enter the word whose occurrences is to be calculated:sample\n",
      "The word 'sample' occurs 2 times in the string\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "t_word=input(\"Enter the word whose occurrences is to be calculated:\")\n",
    "words=string.split()\n",
    "count=0\n",
    "for word in words:\n",
    "    if t_word==word:\n",
    "        count+=1\n",
    "print(\"The word '{}' occurs {} times in the string\".format(t_word,count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e522c3af",
   "metadata": {},
   "source": [
    "# 12. Find the first occurrence of a word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7df308f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am a good boy\n",
      "Enter the word whose occurrence is to be found:good\n",
      "'good' occurs first in the 7th index\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "word=input(\"Enter the word whose occurrence is to be found:\")\n",
    "index=string.find(word)\n",
    "if index == -1:\n",
    "    print(\"'{}' does not occur in the string\".format(word))\n",
    "else:\n",
    "    print(\"'{}' occurs first in the {}th index\".format(word,index))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a5d7c2b",
   "metadata": {},
   "source": [
    "# 13. Find the last occurrence of a word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "0667bfec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is to find the last occurrence of the word in the string\n",
      "Enter the word whose occurrence is to be found:the\n",
      "'the' occurs last in the 51th index\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "word=input(\"Enter the word whose occurrence is to be found:\")\n",
    "index=string.rfind(word)\n",
    "if index == -1:\n",
    "    print(\"'{}' does not occur in the string\".format(word))\n",
    "else:\n",
    "    print(\"'{}' occurs last in the {}th index\".format(word,index))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d90f478",
   "metadata": {},
   "source": [
    "# 14. Split a string into a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "21f44ec5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is my second assignment\n",
      "List of words : ['This', 'is', 'my', 'second', 'assignment']\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "words=string.split()\n",
    "print(\"List of words :\",words)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aedd115",
   "metadata": {},
   "source": [
    "# 15. Join a list of words into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "77c4fe35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string formed by joining the words is:\n",
      " This is my second assignment\n"
     ]
    }
   ],
   "source": [
    "words=[\"This\",\"is\",\"my\",\"second\",\"assignment\"]\n",
    "string=' '.join(words)\n",
    "print(\"The string formed by joining the words is:\\n\",string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0e1226",
   "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": 52,
   "id": "392e1e97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:This is my second assignment\n",
      "Modified string where words are seperated by underscore is:\n",
      " This_is_my_second_assignment\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "mod_string=string.replace(\" \",\"_\")\n",
    "print(\"Modified string where words are seperated by underscore is:\\n\",mod_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ac92f24",
   "metadata": {},
   "source": [
    "# 17. Check if a string starts with a specific word or phrase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "191378d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:this is a sample string\n",
      "Enter the starting word or phrase:this\n",
      "The string starts with 'this''\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "s_word=input(\"Enter the starting word or phrase:\")\n",
    "if string.startswith(s_word):\n",
    "    print(\"The string starts with '{}''\".format(s_word))\n",
    "else:\n",
    "    print(\"The string does not starts with '{}''\".format(s_word))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c85b8bb",
   "metadata": {},
   "source": [
    "# 18. Check if a string ends with a specific word or phrase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "1ac17618",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:this is a sample string\n",
      "Enter the ending word or phrase:sample string\n",
      "The string ends with 'sample string''\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "e_word=input(\"Enter the ending word or phrase:\")\n",
    "if string.endswith(e_word):\n",
    "    print(\"The string ends with '{}''\".format(e_word))\n",
    "else:\n",
    "    print(\"The string does not ends with '{}''\".format(e_word))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fc90f85",
   "metadata": {},
   "source": [
    "# 19. Convert a string to title case (e.g., \"hello world\" to \"Hello World\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "de6a0dfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after converting to title case is:\n",
      " Hello World\n"
     ]
    }
   ],
   "source": [
    "string=\"hello world\"\n",
    "mod_string=string.title();\n",
    "print(\"String after converting to title case is:\\n\",mod_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22cd91fb",
   "metadata": {},
   "source": [
    "# 20. Find the longest word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "9516d5cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is my second assignment\n",
      "Longest word in the string is:  assignment\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "words=string.split()\n",
    "longest_word=max(words,key=len)\n",
    "print(\"Longest word in the string is: \",longest_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62af3581",
   "metadata": {},
   "source": [
    "# 21. Find the shortest word in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "2ff2cdc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:This is my second assignment\n",
      "Shortest word in the string is:  is\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "words=string.split()\n",
    "shortest_word=min(words,key=len)\n",
    "print(\"Shortest word in the string is: \",shortest_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe6cb9ab",
   "metadata": {},
   "source": [
    "# 22. Reverse the order of words in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "1c6c4c35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am a good boy\n",
      "String after reversing the order of words is:\n",
      " boy good a am I\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "words=string.split()\n",
    "words=words[::-1]\n",
    "print(\"String after reversing the order of words is:\\n\",\" \".join(words))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44d234a9",
   "metadata": {},
   "source": [
    "# 23. Check if a string is alphanumeric.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "eb3d49a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:test123\n",
      "The string is alphanumeric\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "check=string.isalnum()\n",
    "if check:\n",
    "    print(\"The string is alphanumeric\")\n",
    "else:\n",
    "    print(\"The string is not alphanumeric\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ada752",
   "metadata": {},
   "source": [
    "# 24. Extract all digits from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "0ce19413",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:When I was in class 5 my roll was 123\n",
      "Extracted digits from the string is: 5123\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "digits=\"\"\n",
    "for i in string:\n",
    "    if i.isdigit():\n",
    "        digits+=i\n",
    "print(\"Extracted digits from the string is:\",digits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88803a4a",
   "metadata": {},
   "source": [
    "# 25. Extract all alphabets from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "655449ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:Hello123World456\n",
      "Extracted alphabets from the string is: HelloWorld\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "alpha=\"\"\n",
    "for i in string:\n",
    "    if i.isalpha():\n",
    "        alpha+=i\n",
    "print(\"Extracted alphabets from the string is:\",alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "042e966d",
   "metadata": {},
   "source": [
    "# 26. Count the number of uppercase letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "2055960a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:TufaN IS a GooD BoY\n",
      "Number of uppercase letters in the string is: 8\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "count=0\n",
    "for char in string:\n",
    "    if char.isupper():\n",
    "        count+=1\n",
    "print(\"Number of uppercase letters in the string is:\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cc632e9",
   "metadata": {},
   "source": [
    "# 27. Count the number of lowercase letters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "10fc58b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:TufaN IS a GooD BoY\n",
      "Number of lowercase letters in the string is: 7\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "count=0\n",
    "for char in string:\n",
    "    if char.islower():\n",
    "        count+=1\n",
    "print(\"Number of lowercase letters in the string is:\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "614c8c2c",
   "metadata": {},
   "source": [
    "# 28. Swap the case of each character in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "f9b2bbfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:TUFan Is a GOOd Boy\n",
      "After swapping the case of each character we have:\n",
      " tufAN iS A gooD bOY\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "swapped_string=string.swapcase()\n",
    "print(\"After swapping the case of each character we have:\\n\",swapped_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed9fc36b",
   "metadata": {},
   "source": [
    "# 29. Remove a specific word from a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "c3bdbb5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am good at studies and also I am good at sports\n",
      "Enter the word to be removed:good\n",
      "After removing the word 'good', the modified string is:\n",
      " I am  at studies and also I am  at sports\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "word=input(\"Enter the word to be removed:\")\n",
    "mod_str=string.replace(word,'')\n",
    "print(\"After removing the word '{}', the modified string is:\\n\".format(word),mod_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ff69d4c",
   "metadata": {},
   "source": [
    "# 30. Check if a string is a valid email address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "428d7d51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the email address:tufan.kundu11@gmail.com\n",
      "The email entered is a valid email.\n"
     ]
    }
   ],
   "source": [
    "import re #regular expression module\n",
    "\n",
    "def is_valid_email(email):\n",
    "    pattern = r'^[\\w\\.-]+@+[\\w\\.-]+\\.\\w+$'  \n",
    "    if re.match(pattern, email):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "email = input(\"Enter the email address:\")\n",
    "if is_valid_email(email):\n",
    "    print(\"The email entered is a valid email.\")\n",
    "else:\n",
    "    print(\"The email entered is not a valid email\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "002d0ba6",
   "metadata": {},
   "source": [
    "# 31. Extract the username from an email address string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "4ecddc1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the email id:tufan.kundu11@gmail.com\n",
      "User name is : tufan.kundu11\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the email id:\")\n",
    "user_name=string.split(\"@\")[0]\n",
    "print(\"User name is :\",user_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bd79223",
   "metadata": {},
   "source": [
    "# 32. Extract the domain name from an email address string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "c2b4e3ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the email id:tufan.kundu11@gmail.com\n",
      "domain name is : gmail.com\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the email id:\")\n",
    "domain_name=string.split(\"@\")[1]\n",
    "print(\"domain name is :\",domain_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "888f6010",
   "metadata": {},
   "source": [
    "# 33. Replace multiple spaces in a string with a single space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "3b78b03a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I      am      a     good           boy\n",
      "The modified string after replacing multiple spaces with a single space :\n",
      " I am a good boy\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "mod_string=\" \".join(string.split())\n",
    "print(\"The modified string after replacing multiple spaces with a single space :\\n\",mod_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30ee38c4",
   "metadata": {},
   "source": [
    "# 34. Check if a string is a valid URL.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "6ab50456",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid url\n",
      "Invalid URL\n"
     ]
    }
   ],
   "source": [
    "from urllib.parse import urlparse\n",
    "\n",
    "def is_valid_url(url):\n",
    "    try:\n",
    "        result = urlparse(url)\n",
    "        return all([result.scheme, result.netloc])  # Check if both scheme and netloc are present\n",
    "    except ValueError:\n",
    "        return False\n",
    "\n",
    "# Example URLs\n",
    "url1 = \"https://www.example.com\"\n",
    "url2 = \"invalid-url\"\n",
    "if is_valid_url(url1):\n",
    "    print(\"Valid url\")\n",
    "else:\n",
    "    print(\"Invalid URL\")\n",
    "if is_valid_url(url2):\n",
    "        print(\"Valid url\")\n",
    "else:\n",
    "    print(\"Invalid URL\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb4dda1c",
   "metadata": {},
   "source": [
    "# 35. Extract the protocol (http or https) from a URL string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "8d5a0f1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Protocol 1: https\n",
      "Protocol 2: http\n",
      "Protocol 3: ftp\n"
     ]
    }
   ],
   "source": [
    "def extract_protocol(url):\n",
    "    # Find the index of the first occurrence of \"://\"\n",
    "    protocol_end = url.find(\"://\")\n",
    "\n",
    "    if protocol_end != -1:\n",
    "        # Extract the protocol from the URL\n",
    "        protocol = url[:protocol_end]\n",
    "        return protocol\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "# Example URL strings\n",
    "url1 = \"https://www.example.com\"\n",
    "url2 = \"http://google.com\"\n",
    "url3 = \"ftp://ftp.example.com\"\n",
    "\n",
    "# Extract protocols\n",
    "protocol1 = extract_protocol(url1)\n",
    "protocol2 = extract_protocol(url2)\n",
    "protocol3 = extract_protocol(url3)\n",
    "\n",
    "# Print extracted protocols\n",
    "print(\"Protocol 1:\", protocol1)\n",
    "print(\"Protocol 2:\", protocol2)\n",
    "print(\"Protocol 3:\", protocol3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7546e8",
   "metadata": {},
   "source": [
    "# 36. Find the frequency of each character in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "9b9958a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:assignment\n",
      "character:'a',frequency:1\n",
      "character:'s',frequency:2\n",
      "character:'i',frequency:1\n",
      "character:'g',frequency:1\n",
      "character:'n',frequency:2\n",
      "character:'m',frequency:1\n",
      "character:'e',frequency:1\n",
      "character:'t',frequency:1\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "frequency={}\n",
    "for char in string:\n",
    "    if char in frequency:\n",
    "        frequency[char]+=1\n",
    "    else:\n",
    "        frequency[char]=1\n",
    "for char,freq in frequency.items():\n",
    "    print(\"character:'{}',frequency:{}\".format(char,freq))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045f4c99",
   "metadata": {},
   "source": [
    "# 37. Remove all punctuation from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "8d74c9aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:hi, How are you?\n",
      "Original string: hi, How are you?\n",
      "Cleaned string: hi How are you\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "def remove_punctuation(input_string):\n",
    "    # Create a translation table to remove punctuation\n",
    "    translator = str.maketrans(\"\", \"\", string.punctuation)\n",
    "\n",
    "    # Use the translation table to remove punctuation from the input string\n",
    "    clean_string = input_string.translate(translator)\n",
    "\n",
    "    return clean_string\n",
    "\n",
    "# Example string with punctuation\n",
    "input_str =input(\"Enter the string:\")\n",
    "\n",
    "# Remove punctuation\n",
    "cleaned_str = remove_punctuation(input_str)\n",
    "\n",
    "# Print the cleaned string\n",
    "print(\"Original string:\", input_str)\n",
    "print(\"Cleaned string:\", cleaned_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc666bf9",
   "metadata": {},
   "source": [
    "# 38. Check if a string contains only digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "af2f0d0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:12545\n",
      "The string contains only digits\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "if string.isdigit():\n",
    "    print(\"The string contains only digits\")\n",
    "else:\n",
    "    print(\"The string does not contains only digits\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccd7260e",
   "metadata": {},
   "source": [
    "# 39. Check if a string contains only alphabets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "55bac22c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:Assignment\n",
      "The string contains only alphabets\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the string:\")\n",
    "if string.isalpha():\n",
    "    print(\"The string contains only alphabets\")\n",
    "else:\n",
    "    print(\"The string does not contains only alphabets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c1db824",
   "metadata": {},
   "source": [
    "# 40. Convert a string to a list of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "5b4f17ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:assignment\n",
      "String after converting to a list of characters is:\n",
      " ['a', 's', 's', 'i', 'g', 'n', 'm', 'e', 'n', 't']\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "words=list(string)\n",
    "print(\"String after converting to a list of characters is:\\n\",words)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a79b8365",
   "metadata": {},
   "source": [
    "# 41. Check if two strings are anagrams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "6aae8ee0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the first string:anjulika\n",
      "Enter the second string:akilujna\n",
      "'anjulika' and 'akilujna' are anagrams\n"
     ]
    }
   ],
   "source": [
    "string1=input(\"Enter the first string:\")\n",
    "string2=input(\"Enter the second string:\")\n",
    "string1=string1.replace(\" \",\"\").lower()\n",
    "string2=string2.replace(\" \",\"\").lower()\n",
    "if sorted(string1)==sorted(string2):\n",
    "    print(\"'{}' and '{}' are anagrams\".format(string1,string2))\n",
    "else:\n",
    "    print(\"'{}' and '{}' are not anagrams\".format(string1,string2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ecf9b4c",
   "metadata": {},
   "source": [
    "# 42. Encode a string using a Caesar cipher.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "329306f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoded text: ehoor, zruog!\n"
     ]
    }
   ],
   "source": [
    "# Define a function named caesar_cipher that encodes a string using a Caesar cipher.\n",
    "def caesar_cipher(text, shift):\n",
    "  \"\"\"\n",
    "  Encodes a string using a Caesar cipher.\n",
    "\n",
    "  Args:\n",
    "    text: The string to encode.\n",
    "    shift: The number of positions to shift each letter.\n",
    "\n",
    "  Returns:\n",
    "    The encoded string.\n",
    "  \"\"\"\n",
    "\n",
    "  # Initialize an empty string to store the encoded text.\n",
    "  encoded_text = \"\"\n",
    "\n",
    "  # Iterate through each character in the input text.\n",
    "  for char in text:\n",
    "    # Check if the character is alphabetic.\n",
    "    if char.isalpha():\n",
    "      # Calculate the encoded character's Unicode code point value by shifting it by the specified amount.\n",
    "      # Ensure the value wraps around within the lowercase alphabet range (a-z).\n",
    "      encoded_char = chr((ord(char) + shift - ord('a')) % 26 + ord('a'))\n",
    "    else:\n",
    "      # Keep non-alphabetic characters unchanged.\n",
    "      encoded_char = char\n",
    "\n",
    "    # Add the encoded character to the encoded text.\n",
    "    encoded_text += encoded_char\n",
    "\n",
    "  # Return the resulting encoded text.\n",
    "  return encoded_text\n",
    "\n",
    "# Define the input text and the shift value for encoding.\n",
    "text = \"Hello, world!\"\n",
    "shift = 3\n",
    "\n",
    "# Call the caesar_cipher function to encode the text using the specified shift.\n",
    "encoded_text = caesar_cipher(text, shift)\n",
    "\n",
    "# Print the encoded text.\n",
    "print(\"Encoded text:\", encoded_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f387b26",
   "metadata": {},
   "source": [
    "# 43. Decode a Caesar cipher encoded string.43. Decode a Caesar cipher encoded string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "54a2ea7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoded text: ilmm, world!\n"
     ]
    }
   ],
   "source": [
    "# Define a function to decode a string using a Caesar cipher\n",
    "def caesar_cipher_decoder(text, shift):\n",
    "    \"\"\"\n",
    "    Decodes a string using a Caesar cipher.\n",
    "\n",
    "    Args:\n",
    "        text: The string to decode.\n",
    "        shift: The number of positions to shift each letter.\n",
    "\n",
    "    Returns:\n",
    "        The decoded string.\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize an empty string to store the decoded text\n",
    "    decoded_text = \"\"\n",
    "\n",
    "    # Loop through each character in the input text\n",
    "    for char in text:\n",
    "        # Check if the character is an alphabetic character\n",
    "        if char.isalpha():\n",
    "            # Calculate the decoded character using the shift value\n",
    "            decoded_char = chr((ord(char) - shift - ord('a')) % 26 + ord('a'))\n",
    "        else:\n",
    "            # If the character is not alphabetic, keep it unchanged\n",
    "            decoded_char = char\n",
    "\n",
    "        # Add the decoded character to the decoded text\n",
    "        decoded_text += decoded_char\n",
    "\n",
    "    # Return the fully decoded text\n",
    "    return decoded_text\n",
    "\n",
    "# Example input\n",
    "text = \"lopp, zruog!\"\n",
    "shift = 3\n",
    "\n",
    "# Call the caesar_cipher_decoder function to decode the input text\n",
    "decoded_text = caesar_cipher_decoder(text, shift)\n",
    "\n",
    "# Print the decoded text\n",
    "print(\"Decoded text:\", decoded_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c1619c8",
   "metadata": {},
   "source": [
    "# 44. Find the most frequent word in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "0d03e1c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the stringHello there! Hello here, I am here to say hello\n",
      "Most frequent word: hello\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "from collections import Counter\n",
    "\n",
    "def most_frequent_word(input_string):\n",
    "    # Remove punctuation and convert to lowercase\n",
    "    clean_string = re.sub(r'[^\\w\\s]', '', input_string).lower()\n",
    "\n",
    "    # Split the string into words\n",
    "    words = clean_string.split()\n",
    "\n",
    "    # Use Counter to count word frequencies\n",
    "    word_counter = Counter(words)\n",
    "\n",
    "    # Find the most common word\n",
    "    most_common_word = word_counter.most_common(1)[0][0]\n",
    "\n",
    "    return most_common_word\n",
    "\n",
    "# Example string\n",
    "input_str =input(\"Enter the string\")\n",
    "\n",
    "# Find the most frequent word\n",
    "most_common = most_frequent_word(input_str)\n",
    "\n",
    "# Print the result\n",
    "print(\"Most frequent word:\", most_common)\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee556486",
   "metadata": {},
   "source": [
    "# 45. Find all unique words in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4731aa95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique words: {'world', 'the', 'hows', 'there', 'hello'}\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def unique_words(input_string):\n",
    "    # Remove punctuation and convert to lowercase\n",
    "    clean_string = re.sub(r'[^\\w\\s]', '', input_string).lower()\n",
    "\n",
    "    words = set(clean_string.split())\n",
    "\n",
    "    return words\n",
    "\n",
    "input_str = \"Hello world, hello there! How's the world?\"\n",
    "\n",
    "# Find unique words\n",
    "unique_word_set = unique_words(input_str)\n",
    "\n",
    "# Print the result\n",
    "print(\"Unique words:\", unique_word_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f754feb",
   "metadata": {},
   "source": [
    "# 46. Count the number of syllables in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6a05f484",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'hello' has 2 syllables.\n",
      "'banana' has 3 syllables.\n",
      "'syllable' has 3 syllables.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def count_syllables(word):\n",
    "    # Count vowel groups using regular expression\n",
    "    vowel_groups = re.findall(r'[aeiouy]+', word, re.IGNORECASE)\n",
    "\n",
    "    return len(vowel_groups)\n",
    "\n",
    "# Example words\n",
    "word1 = \"hello\"\n",
    "word2 = \"banana\"\n",
    "word3 = \"syllable\"\n",
    "\n",
    "# Count syllables\n",
    "syllables1 = count_syllables(word1)\n",
    "syllables2 = count_syllables(word2)\n",
    "syllables3 = count_syllables(word3)\n",
    "\n",
    "# Print the results\n",
    "print(f\"'{word1}' has {syllables1} syllables.\")\n",
    "print(f\"'{word2}' has {syllables2} syllables.\")\n",
    "print(f\"'{word3}' has {syllables3} syllables.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2883fd25",
   "metadata": {},
   "source": [
    "# 47. Check if a string contains any special characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "737ee5b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Hello, world!' contains special characters: True\n",
      "'This is a test.' contains special characters: True\n",
      "'Special@Characters' contains special characters: True\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def contains_special_characters(input_string):\n",
    "    # Define a regular expression pattern to match special characters\n",
    "    pattern = re.compile(r'[!@#$%^&*()_+{}\\[\\]:;<>,.?~\\\\/]')\n",
    "\n",
    "    # Use the search() method to find a match\n",
    "    match = pattern.search(input_string)\n",
    "\n",
    "    # Return True if a match is found, False otherwise\n",
    "    return bool(match)\n",
    "\n",
    "# Example strings\n",
    "string1 = \"Hello, world!\"\n",
    "string2 = \"This is a test.\"\n",
    "string3 = \"Special@Characters\"\n",
    "\n",
    "# Check if strings contain special characters\n",
    "result1 = contains_special_characters(string1)\n",
    "result2 = contains_special_characters(string2)\n",
    "result3 = contains_special_characters(string3)\n",
    "\n",
    "# Print the results\n",
    "print(f\"'{string1}' contains special characters:\", result1)\n",
    "print(f\"'{string2}' contains special characters:\", result2)\n",
    "print(f\"'{string3}' contains special characters:\", result3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bfba186",
   "metadata": {},
   "source": [
    "# 48. Remove the nth word from a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4be6b299",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am a good boy\n",
      "Enter the value of n:2\n",
      "Original string: I am a good boy\n",
      "Modified string: I a good boy\n",
      "Removed word: am\n"
     ]
    }
   ],
   "source": [
    "def remove_nth_word(input_string, n):\n",
    "    # Split the input string into words\n",
    "    words = input_string.split()\n",
    "\n",
    "    # Check if n is within a valid range\n",
    "    if n >= 1 and n <= len(words):\n",
    "        # Remove the nth word by excluding it from the words list\n",
    "        removed_word = words.pop(n - 1)\n",
    "\n",
    "        # Join the remaining words to form the modified string\n",
    "        modified_string = ' '.join(words)\n",
    "\n",
    "        return modified_string, removed_word\n",
    "    else:\n",
    "        return None, None\n",
    "\n",
    "# input of string and n value\n",
    "input_str = input(\"Enter the string:\")\n",
    "n_value=int(input(\"Enter the value of n:\"))\n",
    "\n",
    "# Remove the nth word\n",
    "modified_str, removed_word = remove_nth_word(input_str, n_value)\n",
    "\n",
    "# Print the results\n",
    "print(\"Original string:\", input_str)\n",
    "if modified_str is not None:\n",
    "    print(\"Modified string:\", modified_str)\n",
    "    print(\"Removed word:\", removed_word)\n",
    "else:\n",
    "    print(\"Invalid n value.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90eaf836",
   "metadata": {},
   "source": [
    "# 49. Insert a word at the nth position in a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "631ab3f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string:I am a lucky\n",
      "Enter the word to be inserted:man\n",
      "Enter the poition in which word is to be inserted:4\n",
      "Original string: I am a lucky\n",
      "Modified string: I am a lucky man\n"
     ]
    }
   ],
   "source": [
    "def insert_word_at_n(input_string, word_to_insert, n):\n",
    "    # Split the input string into words\n",
    "    words = input_string.split()\n",
    "\n",
    "    # Check if n is within a valid range\n",
    "    if n >= 0 and n <= len(words):\n",
    "        # Insert the word at the nth position in the words list\n",
    "        words.insert(n, word_to_insert)\n",
    "\n",
    "        # Join the words to form the modified string\n",
    "        modified_string = ' '.join(words)\n",
    "\n",
    "        return modified_string\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "# Input of string, word to insert, and n value\n",
    "input_str = input(\"Enter the string:\")\n",
    "word_to_insert =input(\"Enter the word to be inserted:\")\n",
    "n_value =int(input(\"Enter the poition in which word is to be inserted:\")) \n",
    "# Insert the word at the nth position\n",
    "modified_str = insert_word_at_n(input_str, word_to_insert, n_value)\n",
    "\n",
    "# Print the results\n",
    "print(\"Original string:\", input_str)\n",
    "if modified_str is not None:\n",
    "    print(\"Modified string:\", modified_str)\n",
    "else:\n",
    "    print(\"Invalid n value.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "701844c2",
   "metadata": {},
   "source": [
    "# 50. Convert a CSV string to a list of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e4feb965",
   "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": [
    "def csv_string_to_list(csv_string):\n",
    "    # Split the CSV string into lines\n",
    "    lines = csv_string.split('\\n')\n",
    "\n",
    "    # Initialize an empty list to store the result\n",
    "    result = []\n",
    "\n",
    "    for line in lines:\n",
    "        # Split each line into fields using comma as the delimiter\n",
    "        fields = line.split(',')\n",
    "\n",
    "        # Append the fields to the result list as a row\n",
    "        result.append(fields)\n",
    "\n",
    "    return result\n",
    "\n",
    "# Example CSV string\n",
    "csv_data = \"Name, Age, Country\\nJohn, 25, USA\\nAlice, 30, Canada\\nBob, 22, UK\"\n",
    "\n",
    "# Convert CSV string to a list of lists\n",
    "list_of_lists = csv_string_to_list(csv_data)\n",
    "# Print the result\n",
    "for row in list_of_lists:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efccf216",
   "metadata": {},
   "source": [
    "# List Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce6d93df",
   "metadata": {},
   "source": [
    "# 1. Create a list with integers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "03e6f4dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "l=[]\n",
    "for i in range(1,11):\n",
    "    l.append(i)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4148a71",
   "metadata": {},
   "source": [
    "# 2. Find the length of a list without using the `len()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a2bdea5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of the list is : 11\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,3,4,6,\"tuf\",85,\"kindo\",54,98,56,39]\n",
    "count=0\n",
    "for l in list_1:\n",
    "    count+=1\n",
    "print(\"The length of the list is :\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31a22c75",
   "metadata": {},
   "source": [
    "# 3. Append an element to the end of a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "05da18ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the new element to be added to the list:58\n",
      "updated list is :\n",
      " [2, 43, 5, 676, 43, 32, 21, 6, 754, 752, 21, 'tuf', '58']\n"
     ]
    }
   ],
   "source": [
    "list_1=[2,43,5,676,43,32,21,6,754,752,21,\"tuf\"]\n",
    "new_ele=input(\"Enter the new element to be added to the list:\")\n",
    "list_1.append(new_ele)\n",
    "print(\"updated list is :\\n\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1648d2b",
   "metadata": {},
   "source": [
    "# 4. Insert an element at a specific index in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b5361feb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element to be inserted:assignment\n",
      "Enter the index at which element is to be inserted:3\n",
      "Updated list : [1, 2, 3, 'assignment', 4, 5, 'dog', 'led', 576, 484]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,\"dog\",\"led\",576,484]\n",
    "ele=input(\"Enter the element to be inserted:\")\n",
    "n=int(input(\"Enter the index at which element is to be inserted:\"))\n",
    "list_1.insert(n,ele)\n",
    "print(\"Updated list :\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40958f4f",
   "metadata": {},
   "source": [
    "# 5. Remove an element from a list by its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8ca11f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element to be removed:led\n",
      "Updated list: [1, 2, 3, 4, 5, 'dog', 576, 484]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,\"dog\",\"led\",576,484]\n",
    "value=input(\"Enter the element to be removed:\")\n",
    "list_1.remove(value)\n",
    "print(\"Updated list:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c80b7265",
   "metadata": {},
   "source": [
    "# 6. Remove an element from a list by its index.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b3ac7178",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the index of element to be removed:5\n",
      "Updated list: [1, 2, 3, 4, 5, 'led', 576, 484]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,\"dog\",\"led\",576,484]\n",
    "value=int(input(\"Enter the index of element to be removed:\"))\n",
    "list_1.pop(value)\n",
    "print(\"Updated list:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d99ba91",
   "metadata": {},
   "source": [
    "# 7. Check if an element exists in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "84661918",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element to be checked:5\n",
      "5  exists in list\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484]\n",
    "value=int(input(\"Enter the element to be checked:\"))\n",
    "if value in list_1:\n",
    "    print(value,\" exists in list\")\n",
    "else:\n",
    "    print(value,\" does not exists in the list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b73a84",
   "metadata": {},
   "source": [
    "# 8. Find the index of the first occurrence of an element in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "60dc856f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The index of '3' is 2\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484,3,4,3]\n",
    "value=3\n",
    "print(\"The index of '{}' is\".format(value),list_1.index(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85ff4bf6",
   "metadata": {},
   "source": [
    "# 9. Count the occurrences of an element in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "697fd88f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3  occurs 3 times in the list\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484,3,4,3]\n",
    "value=3 #element whose occurence is to be counted\n",
    "print(value,\" occurs {} times in the list\".format(list_1.count(value)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c4e7c06",
   "metadata": {},
   "source": [
    "# 10. Reverse the order of elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "067cad22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list in reversed order is: [3, 4, 3, 484, 576, 784, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484,3,4,3]\n",
    "list_1.reverse()\n",
    "print(\"Updated list in reversed order is:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a1a3e3b",
   "metadata": {},
   "source": [
    "# 11. Sort a list in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ca4e74d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after sorting in ascending order: [1, 2, 3, 3, 3, 4, 4, 5, 484, 576, 784]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484,3,4,3]\n",
    "list_1.sort()\n",
    "print(\"List after sorting in ascending order:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cd21ae1",
   "metadata": {},
   "source": [
    "# 12. Sort a list in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "98242cd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after sorting in descending order: [784, 576, 484, 5, 4, 4, 3, 3, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484,3,4,3]\n",
    "list_1.sort(reverse=True)\n",
    "print(\"List after sorting in descending order:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af8c4c56",
   "metadata": {},
   "source": [
    "# 13. Create a list of even numbers from 1 to 20.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "2e5d89d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list of even numbers from 1 to 20 is:\n",
      " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n"
     ]
    }
   ],
   "source": [
    "list_1=[]\n",
    "for _ in range(2,21,2):\n",
    "    list_1.append(_)\n",
    "print(\"The list of even numbers from 1 to 20 is:\\n\",list_1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27b7a05a",
   "metadata": {},
   "source": [
    "# 14. Create a list of odd numbers from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "1e1b9ff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list of odd numbers from 1 to 20 is:\n",
      " [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "list_1=[]\n",
    "for _ in range(1,21,2):\n",
    "    list_1.append(_)\n",
    "print(\"The list of odd numbers from 1 to 20 is:\\n\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ed40fb",
   "metadata": {},
   "source": [
    "# 15. Find the sum of all elements in a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "19f198f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all the elements of the list is: 55\n"
     ]
    }
   ],
   "source": [
    "list_1=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "s=sum(list_1)\n",
    "print(\"Sum of all the elements of the list is:\",s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "772c0c21",
   "metadata": {},
   "source": [
    "# 16. Find the maximum value in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "62e3457c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value in the list is: 784\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,3,4,5,784,576,484,3,4,3]\n",
    "max_value=max(list_1)\n",
    "print(\"Maximum value in the list is:\",max_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea3c3a46",
   "metadata": {},
   "source": [
    "# 17. Find the minimum value in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1702b17c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manimum value in the list is: -11\n"
     ]
    }
   ],
   "source": [
    "\n",
    "list_1=[-11,-2,30,0,4,5,784,576,484,3,4,3]\n",
    "min_value=min(list_1)\n",
    "print(\"Manimum value in the list is:\",min_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55537ca6",
   "metadata": {},
   "source": [
    "# 18. Create a list of squares of numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "276f28e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List is: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "list_1=[]\n",
    "for i in range(1,11):\n",
    "    list_1.append(i*i)\n",
    "print(\"List is:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e6edf57",
   "metadata": {},
   "source": [
    "# 19. Create a list of random numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "39dc14b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of random integers: [53, 52, 60, 69, 29, 27, 99, 28, 63, 5]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random_integers = [random.randint(1, 100) for _ in range(10)]\n",
    "\n",
    "# Print the list of random integers\n",
    "print(\"List of random integers:\", random_integers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1765b80e",
   "metadata": {},
   "source": [
    "# 20. Remove duplicates from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8c10aa6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original list:\n",
      " [1, 1, 0, 1, 2, 2, 3, 4, 5, 2, 3, 4, 0, 9, 94, 3, 54, 2, 1]\n",
      "List after removing the duplicates:\n",
      " [0, 1, 2, 3, 4, 5, 9, 54, 94]\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,1,0,1,2,2,3,4,5,2,3,4,0,9,94,3,54,2,1]\n",
    "list_2=set(list_1)\n",
    "list_2=list(list_2)\n",
    "print(\"original list:\\n\",list_1)\n",
    "print(\"List after removing the duplicates:\\n\",list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d2e15f",
   "metadata": {},
   "source": [
    "# 21. Find the common elements between two lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d27939fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements between the two lists is:\n",
      " [1, 6, 7, 4, 1, 2, 4, 85]\n"
     ]
    }
   ],
   "source": [
    "l1=[1,6,7,3,4,1,2,8,4,67,85,45]\n",
    "l2=[53,2,6,1,5,9,0,5,4,84,85,2,7]\n",
    "common_element=[]\n",
    "for element in l1:\n",
    "    if element in l2:\n",
    "        common_element.append(element)\n",
    "print(\"Common elements between the two lists is:\\n\",common_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a71faa09",
   "metadata": {},
   "source": [
    "# 22. Find the difference between two lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e2ea48ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference between lists: [50, 4, 90]\n"
     ]
    }
   ],
   "source": [
    "list1 = [2,4,50,25,90]\n",
    "list2 = [8,2,5,25,45]\n",
    "\n",
    "difference = list(set(list1).difference(list2))\n",
    "\n",
    "print(\"Difference between lists:\", difference)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fab0627",
   "metadata": {},
   "source": [
    "# 23. Merge two lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "63309ca7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged list is: [2, 4, 50, 25, 90, 8, 2, 5, 25, 45]\n"
     ]
    }
   ],
   "source": [
    "list1 = [2,4,50,25,90]\n",
    "list2 = [8,2,5,25,45]\n",
    "merged_list=list1+list2\n",
    "print(\"Merged list is:\",merged_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee37398a",
   "metadata": {},
   "source": [
    "# 24. Multiply all elements in a list by 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cc45ecf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "updated list: [2, 4, 6, 8, 10, 12, 14, 16]\n"
     ]
    }
   ],
   "source": [
    "list1=[1,2,3,4,5,6,7,8]\n",
    "for i in range(0,len(list1)):\n",
    "    list1[i]=list1[i] * 2\n",
    "print(\"updated list:\",list1)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b80e7b",
   "metadata": {},
   "source": [
    "# 25. Filter out all even numbers from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "279ef115",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered list without even numbers is: [1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "list1=[1,2,3,4,5,6,7,8,9,10]\n",
    "even_list=[]\n",
    "for i in list1:\n",
    "    if i%2!=0:\n",
    "        even_list.append(i)\n",
    "print(\"Filtered list without even numbers is:\",even_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6202dad",
   "metadata": {},
   "source": [
    "# 26. Convert a list of strings to a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ed69d154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of integers is: [10, 15, 20, 25, 40, 55]\n"
     ]
    }
   ],
   "source": [
    "list1=[\"10\",\"15\",\"20\",\"25\",\"40\",\"55\"]\n",
    "#conversion of list of string to list of integers\n",
    "int_list=[int(i) for i in list1]\n",
    "print(\"List of integers is:\",int_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e687eaa2",
   "metadata": {},
   "source": [
    "# 27. Convert a list of integers to a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "9091bbb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of string is: ['10', '54', '45', '87', '98', '20', '54']\n"
     ]
    }
   ],
   "source": [
    "list1=[10,54,45,87,98,20,54]\n",
    "#conversion of list of integer to list of string\n",
    "str_list=[str(i) for i in list1]\n",
    "print(\"List of string is:\",str_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09cc55e4",
   "metadata": {},
   "source": [
    "# 28. Flatten a nested list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "05ca32e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50]\n"
     ]
    }
   ],
   "source": [
    "# Example nested list\n",
    "nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9],10,50]\n",
    "# Function to flatten a nested list\n",
    "def flatten_list(nested):\n",
    "    flattened = []\n",
    "    for sublist in nested:\n",
    "        if isinstance(sublist, list):\n",
    "            flattened.extend(flatten_list(sublist))\n",
    "        else:\n",
    "            flattened.append(sublist)\n",
    "    return flattened\n",
    "\n",
    "# Flatten the nested list\n",
    "flattened_list = flatten_list(nested_list)\n",
    "\n",
    "# Print the flattened list\n",
    "print(\"Flattened list:\", flattened_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b54d9cfe",
   "metadata": {},
   "source": [
    "# 29. Create a list of the first 10 Fibonacci numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9562ddf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of first 10 fibonacci numbers is:\n",
      " [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "a=0\n",
    "b=1\n",
    "list1=[a,b]\n",
    "for i in range(0,8):\n",
    "    c=a+b\n",
    "    a=b\n",
    "    b=c\n",
    "    list1.append(c)\n",
    "print(\"List of first 10 fibonacci numbers is:\\n\",list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db3675fc",
   "metadata": {},
   "source": [
    "# 30. Check if a list is sorted.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a98f9b67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list is sorted in ascending order\n"
     ]
    }
   ],
   "source": [
    "list1=[1,2,3,4,5,6,7,8,9]\n",
    "def is_sorted(list1):\n",
    "    for i in range(1,len(list1)):\n",
    "        if(list1[i]<list1[i-1]):\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "if is_sorted(list1):\n",
    "    print(\"The list is sorted in ascending order\")\n",
    "else:\n",
    "    print(\"The list is not sorted in ascending order\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "736acd54",
   "metadata": {},
   "source": [
    "# 31. Rotate a list to the left by `n` positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "648454a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated list: [3, 4, 5, 6, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# Function to rotate a list to the left by n positions\n",
    "def rotate_left(lst, n):\n",
    "    n = n % len(lst)  # Normalize n to handle cases where n is larger than the list length\n",
    "    rotated = lst[n:] + lst[:n]\n",
    "    return rotated\n",
    "\n",
    "# Example list\n",
    "my_list = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "# Number of positions to rotate by\n",
    "n = 2\n",
    "\n",
    "# Rotate the list to the left by n positions\n",
    "rotated_list = rotate_left(my_list, n)\n",
    "\n",
    "# Print the rotated list\n",
    "print(\"Rotated list:\", rotated_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27261a07",
   "metadata": {},
   "source": [
    "# 32. Rotate a list to the right by `n` positions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "21ee069f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated list: [5, 6, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Function to rotate a list to the right by n positions\n",
    "def rotate_right(lst, n):\n",
    "    n = n % len(lst)  # Normalize n to handle cases where n is larger than the list length\n",
    "    rotated = lst[-n:] + lst[:-n]\n",
    "    return rotated\n",
    "\n",
    "# Example list\n",
    "my_list = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "# Number of positions to rotate by\n",
    "n = 2\n",
    "\n",
    "# Rotate the list to the left by n positions\n",
    "rotated_list = rotate_right(my_list, n)\n",
    "\n",
    "# Print the rotated list\n",
    "print(\"Rotated list:\", rotated_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc356f47",
   "metadata": {},
   "source": [
    "# 33. Create a list of prime numbers up to 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "0a6f78f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime number upto 50 :\n",
      " [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "list1=[]\n",
    "for i in range(1,51):\n",
    "    c=0\n",
    "    for j in range(1,i+1):\n",
    "        if(i%j==0):\n",
    "            c+=1\n",
    "    if(c==2):\n",
    "        list1.append(j)\n",
    "print(\"List of prime number upto 50 :\\n\",list1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4500f889",
   "metadata": {},
   "source": [
    "# 34. Split a list into chunks of size `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "e5d9b4b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [3, 4], [5, 6], [7, 8], [9]]\n"
     ]
    }
   ],
   "source": [
    "def chunk_list(input_list, chunk_size):\n",
    "    return [input_list[i:i + chunk_size] for i in range(0, len(input_list), chunk_size)]\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "chunk_size = 2\n",
    "result = chunk_list(my_list, chunk_size)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eacbf1ef",
   "metadata": {},
   "source": [
    "# 35. Find the second largest number in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "9daabea2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second largest number: 65\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,1,2,5,40,65,75,-8,45,47]\n",
    "sorted_list = sorted(set(list1))\n",
    "if len(sorted_list) >= 2:\n",
    "    print(\"Second largest number:\", sorted_list[-2])\n",
    "else:\n",
    "    print(\"The list does not contain enough elements.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f86991e0",
   "metadata": {},
   "source": [
    "# 36. Replace every element in a list with its square.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "c92121f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list: [1, 4, 9, 16, 25, 36, 49, 64]\n"
     ]
    }
   ],
   "source": [
    "list1=[1,2,3,4,5,6,7,8]\n",
    "for i in range(0,len(list1)):\n",
    "    list1[i]=list1[i]**2\n",
    "print(\"Updated list:\",list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbde9ca2",
   "metadata": {},
   "source": [
    "# 37. Convert a list to a dictionary where list elements become keys and their indices become values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "959f2903",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nokia': 0, 'samsung': 1, 'vivo': 2, 'oppo': 3, 'xiomi': 4, 'poco': 5}\n"
     ]
    }
   ],
   "source": [
    "list1=[\"nokia\",\"samsung\",\"vivo\",\"oppo\",\"xiomi\",\"poco\"]\n",
    "d={}\n",
    "for i in range(0,len(list1)):\n",
    "    d.update({list1[i]:i})\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e15faa0d",
   "metadata": {},
   "source": [
    "# 38. Shuffle the elements of a list randomly.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "3022c612",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shuffled list: [1, 8, 4, 6, 9, 7, 2, 5, 3, 10]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Shuffle the list randomly\n",
    "random.shuffle(my_list)\n",
    "\n",
    "# Print the shuffled list\n",
    "print(\"Shuffled list:\", my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01f06755",
   "metadata": {},
   "source": [
    "# 39. Create a list of the first 10 factorial numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "b796e7f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of first 10 factorial numbers is: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]\n"
     ]
    }
   ],
   "source": [
    "l1=[]\n",
    "for i in range(1,11):\n",
    "    p=1\n",
    "    for j in range(1,i+1):\n",
    "        p*=j\n",
    "    l1.append(p)\n",
    "print(\"List of first 10 factorial numbers is:\",l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff0a78c7",
   "metadata": {},
   "source": [
    "# 40. Check if two lists have at least one element in common.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "9e56af2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lists have at least one common element.\n"
     ]
    }
   ],
   "source": [
    "l1=[1,5,7,8,10,12,45,78,98,52]\n",
    "l2=[4,5,47,48,56,52,41,45,45,8]\n",
    "\n",
    "def has_common_element(list1, list2):\n",
    "    for item in list1:\n",
    "        if item in list2:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "if has_common_element(l1, l2):\n",
    "    print(\"The lists have at least one common element.\")\n",
    "else:\n",
    "    print(\"The lists do not have any common elements.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbe629a6",
   "metadata": {},
   "source": [
    "# 41. Remove all elements from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "e5f62f87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: [1, 5, 7, 8, 10, 12, 45, 78, 98, 52]\n",
      "After removing all elements: []\n"
     ]
    }
   ],
   "source": [
    "l1=[1,5,7,8,10,12,45,78,98,52]\n",
    "print(\"Before:\",l1)\n",
    "l1.clear()\n",
    "print(\"After removing all elements:\",l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8118c5d",
   "metadata": {},
   "source": [
    "# 42. Replace negative numbers in a list with 0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "473aac71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: [1, 5, -7, 8, 10, -12, 45, -78, 98, 52]\n",
      "Updated list: [1, 5, 0, 8, 10, 0, 45, 0, 98, 52]\n"
     ]
    }
   ],
   "source": [
    "l1=[1,5,-7,8,10,-12,45,-78,98,52]\n",
    "print(\"Initial list:\",l1)\n",
    "for i in range(0,len(l1)):\n",
    "    if l1[i]<0:\n",
    "        l1[i]=0\n",
    "print(\"Updated list:\",l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0ea442b",
   "metadata": {},
   "source": [
    "# 43. Convert a string into a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "67756c2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:I am a good boy\n",
      "String after converting to list of words:\n",
      " ['I', 'am', 'a', 'good', 'boy']\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "words=string.split()\n",
    "print(\"String after converting to list of words:\\n\",words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f540e651",
   "metadata": {},
   "source": [
    "# 44. Convert a list of words into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "4354bac1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the required string is: I am a good boy\n"
     ]
    }
   ],
   "source": [
    "list1=['I', 'am', 'a', 'good', 'boy']\n",
    "string=\" \".join(list1)\n",
    "print(\"the required string is:\",string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fcb4995",
   "metadata": {},
   "source": [
    "# 45. Create a list of the first `n` powers of 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "bae2910e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:5\n",
      "The required list of first 5 powers of 2 is:\n",
      " [1, 2, 4, 8, 16]\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "l1=[]\n",
    "for i in range(n):\n",
    "    l1.append(2**i)\n",
    "print(\"The required list of first {} powers of 2 is:\\n\".format(n),l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "602e58ae",
   "metadata": {},
   "source": [
    "# 46. Find the longest string in a list of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "d03358f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest string in a list of strings is: videocon\n"
     ]
    }
   ],
   "source": [
    "str_list=[\"apple\",\"samsung\",\"nokia\",\"onida\",\"videocon\",\"realme\",\"infinix\"]\n",
    "longest_str=max(str_list, key=len)\n",
    "print(\"Longest string in a list of strings is:\",longest_str)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a1cd416",
   "metadata": {},
   "source": [
    "# 47. Find the shortest string in a list of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "7bd56a96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest string in a list of strings is: apple\n"
     ]
    }
   ],
   "source": [
    "str_list=[\"apple\",\"samsung\",\"nokia\",\"onida\",\"videocon\",\"realme\",\"infinix\"]\n",
    "shortest_str=min(str_list, key=len)\n",
    "print(\"Shortest string in a list of strings is:\",shortest_str)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4224574b",
   "metadata": {},
   "source": [
    "# 48. Create a list of the first `n` triangular numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "358fc855",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:5\n",
      "List of the first 5 triangular numbers: [1, 3, 6, 10, 15]\n"
     ]
    }
   ],
   "source": [
    "l1=[]\n",
    "n=int(input(\"Enter the value of n:\"))\n",
    "for i in range(1,n+1):\n",
    "    l1.append(i*(i+1)//2)\n",
    "print(\"List of the first\", n, \"triangular numbers:\", l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aebebde",
   "metadata": {},
   "source": [
    "# 49. Check if a list contains another list as a subsequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "63351d84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Main list contains the subsequence.\n"
     ]
    }
   ],
   "source": [
    "def is_subsequence(subsequence, main_list):\n",
    "    subseq_index = 0  # Index for the subsequence elements\n",
    "    for element in main_list:\n",
    "        if element == subsequence[subseq_index]:\n",
    "            subseq_index += 1\n",
    "            if subseq_index == len(subsequence):\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "# Example main list and subsequence\n",
    "main_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "subsequence = [3, 5, 8]\n",
    "\n",
    "# Check if the main list contains the subsequence\n",
    "if is_subsequence(subsequence, main_list):\n",
    "    print(\"Main list contains the subsequence.\")\n",
    "else:\n",
    "    print(\"Main list does not contain the subsequence.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "391d2cec",
   "metadata": {},
   "source": [
    "# 50. Swap two elements in a list by their indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "772e8da5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after swapping elements: [1, 2, 3, 8, 5, 6, 7, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3, 4, 5,6,7,8,9]\n",
    "index1 = 3\n",
    "index2 = 7\n",
    "\n",
    "temp = l1[index1]\n",
    "l1[index1] = l1[index2]\n",
    "l1[index2] = temp\n",
    "\n",
    "print(\"List after swapping elements:\", l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5f7fc72",
   "metadata": {},
   "source": [
    "# Tuple Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d2fbcd4",
   "metadata": {},
   "source": [
    "# 1. Create a tuple with integers from 1 to 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "95e96ef2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with integer from 1 to 5 is:\n",
      " (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "tup=(1,2,3,4,5)\n",
    "print(\"Tuple with integer from 1 to 5 is:\\n\",tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4d17dc1",
   "metadata": {},
   "source": [
    "# 2. Access the third element of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f4903e2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The third element of the tuple is: 73\n"
     ]
    }
   ],
   "source": [
    "tup=(14,25,73,84,53)\n",
    "third_ele=tup[2]\n",
    "print(\"The third element of the tuple is:\",third_ele)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64e80ac4",
   "metadata": {},
   "source": [
    "# 3. Find the length of a tuple without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8d88c003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the tuple is: 16\n"
     ]
    }
   ],
   "source": [
    "tup=(1,3,64,23,12,8,23,768,23,5721,865,2148,2163,234,765,15)\n",
    "count=0\n",
    "for i in tup:\n",
    "    count+=1\n",
    "print(\"Length of the tuple is:\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5af30d2f",
   "metadata": {},
   "source": [
    "# 4. Count the occurrences of an element in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "edd36b80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element whose occurrence is to be counted:3\n",
      "The element  3  occurs 4 times in the tuple\n"
     ]
    }
   ],
   "source": [
    "tup=(1,3,64,23,12,8,3,768,23,5721,3,2148,3,234,765,15)\n",
    "n=int(input(\"Enter the element whose occurrence is to be counted:\"))\n",
    "count=0\n",
    "for i in tup:\n",
    "    if n==i:\n",
    "        count+=1\n",
    "print(\"The element \",n,\" occurs {} times in the tuple\".format(count))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "392a3608",
   "metadata": {},
   "source": [
    "# 5. Find the index of the first occurrence of an element in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "28ac3a7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element whose first occurrence is to be found:64\n",
      "The element 64 occurs first in the 2th index\n"
     ]
    }
   ],
   "source": [
    "tup=(1,3,64,23,12,8,3,768,23,5721,3,2148,3,234,765,15)\n",
    "n=int(input(\"Enter the element whose first occurrence is to be found:\"))\n",
    "index=-1\n",
    "for i in range(len(tup)):\n",
    "    if n==tup[i]:\n",
    "        index=i\n",
    "        break\n",
    "if index!=-1:\n",
    "    print(\"The element {} occurs first in the {}th index\".format(n,index))\n",
    "else:\n",
    "    print(\"The element {} is not present in the tuple\".format(n))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0830c96",
   "metadata": {},
   "source": [
    "# 6. Check if an element exists in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e3d7be38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element whose existance is to be checked:23\n",
      "The element 23 is present in the tuple\n"
     ]
    }
   ],
   "source": [
    "tup=(1,3,64,23,12,8,3,768,23,5721,3,2148,3,234,765,15)\n",
    "n=int(input(\"Enter the element whose existance is to be checked:\"))\n",
    "if n in tup:\n",
    "      print(\"The element {} is present in the tuple\".format(n))\n",
    "else:\n",
    "    print(\"The element {} is not present in the tuple\".format(n))\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d6679de",
   "metadata": {},
   "source": [
    "# 7. Convert a tuple to a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "27e27e38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple: (1, 3, 64, 23, 12, 8, 3, 2148, 3, 234, 765, 15)\n",
      "List: [1, 3, 64, 23, 12, 8, 3, 2148, 3, 234, 765, 15]\n"
     ]
    }
   ],
   "source": [
    "tup=(1,3,64,23,12,8,3,2148,3,234,765,15)\n",
    "list1=list(tup)\n",
    "print(\"Tuple:\",tup)\n",
    "print(\"List:\",list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58550f9d",
   "metadata": {},
   "source": [
    "# 8. Convert a list to a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "90f940d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: [1, 3, 64, 23, 12, 8, 3, 2148, 3, 234, 765, 15]\n",
      "Tuple: (1, 3, 64, 23, 12, 8, 3, 2148, 3, 234, 765, 15)\n"
     ]
    }
   ],
   "source": [
    "list1= [1, 3, 64, 23, 12, 8, 3, 2148, 3, 234, 765, 15]\n",
    "tup=tuple(list1)\n",
    "print(\"List:\",list1)\n",
    "print(\"Tuple:\",tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "708aba8c",
   "metadata": {},
   "source": [
    "# 9. Unpack the elements of a tuple into variables.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d5cc73d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1: 10\n",
      "var2: 20\n",
      "var3: 30\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (10, 20, 30)\n",
    "var1, var2, var3 = my_tuple\n",
    "print(\"var1:\", var1)\n",
    "print(\"var2:\", var2)\n",
    "print(\"var3:\", var3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7805ad08",
   "metadata": {},
   "source": [
    "# 10. Create a tuple of even numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a81ee705",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required tuple for even numbers is:\n",
      " (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "list1=[i for i in range(2,11,2)]\n",
    "tup=tuple(list1)\n",
    "print(\"Required tuple for even numbers is:\\n\",tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c3d79d",
   "metadata": {},
   "source": [
    "# 11. Create a tuple of odd numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "acf30567",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required tuple for odd numbers is:\n",
      " (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "list1=[i for i in range(1,11,2)]\n",
    "tup=tuple(list1)\n",
    "print(\"Required tuple for odd numbers is:\\n\",tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "069d7af3",
   "metadata": {},
   "source": [
    "# 12. Concatenate two tuples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7a8404bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After concatenating: (1, 2, 3, 4, 5, 6, 7, 8)\n"
     ]
    }
   ],
   "source": [
    "tuple_1=(1,2,3,4)\n",
    "tuple_2=(5,6,7,8)\n",
    "tuple_3=tuple_1+tuple_2\n",
    "print(\"After concatenating:\",tuple_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d10dd242",
   "metadata": {},
   "source": [
    "# 13. Repeat a tuple three times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "8ee16933",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Repeating a tuple 3 times:\n",
      " (1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "tuple_1=(1,2,3,4)\n",
    "rep_tuple=tuple_1*3\n",
    "print(\"Repeating a tuple 3 times:\\n\",rep_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ef2e44",
   "metadata": {},
   "source": [
    "# 14. Check if a tuple is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "6d4689bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple is not empty\n",
      "Tuple is empty\n"
     ]
    }
   ],
   "source": [
    "tup1=(5,8,9)\n",
    "tup2=()\n",
    "c=0\n",
    "for i in tup1:\n",
    "    c+=1\n",
    "if(c==0):\n",
    "    print(\"Tuple is empty\")\n",
    "else:\n",
    "    print(\"Tuple is not empty\")\n",
    "c=0\n",
    "for i in tup2:\n",
    "    c+=1\n",
    "if(c==0):\n",
    "    print(\"Tuple is empty\")\n",
    "else:\n",
    "    print(\"Tuple is not empty\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc419aaa",
   "metadata": {},
   "source": [
    "# 15. Create a nested tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "54070783",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested tuple:\n",
      " ((1, 2, 3), ('Tufan', 'kundu'), (1.3, 1.5), (True, False), (2+3j))\n"
     ]
    }
   ],
   "source": [
    "nested_tuple=((1,2,3),(\"Tufan\",\"kundu\"),(1.3,1.5),(True,False),2+3j)\n",
    "print(\"Nested tuple:\\n\",nested_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d96880d",
   "metadata": {},
   "source": [
    "# 16. Access the first element of a nested tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "571895b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First element of the nested tuple: (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "nested_tuple=((1,2,3),(\"Tufan\",\"kundu\"),(1.3,1.5),(True,False),2+3j)\n",
    "first_ele=nested_tuple[0]\n",
    "print(\"First element of the nested tuple:\",first_ele)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c59b4d06",
   "metadata": {},
   "source": [
    "# 17. Create a tuple with a single element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "45650727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with single element: (3,)\n"
     ]
    }
   ],
   "source": [
    "tup1=(3,)\n",
    "print(\"Tuple with single element:\",tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f90c2c4",
   "metadata": {},
   "source": [
    "# 18. Compare two tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "6d70c94b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tuple1 == tuple2: False\n",
      "tuple1 != tuple2: True\n",
      "tuple1 < tuple2: True\n",
      "tuple1 <= tuple2: True\n",
      "tuple1 > tuple2: False\n",
      "tuple1 >= tuple2: False\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 4)\n",
    "# Step 2: Compare the two tuples using comparison operators\n",
    "print(\"tuple1 == tuple2:\", tuple1 == tuple2)  # Equality check\n",
    "print(\"tuple1 != tuple2:\", tuple1 != tuple2)  # Inequality check\n",
    "print(\"tuple1 < tuple2:\", tuple1 < tuple2)    # Less than check\n",
    "print(\"tuple1 <= tuple2:\", tuple1 <= tuple2)  # Less than or equal to check\n",
    "print(\"tuple1 > tuple2:\", tuple1 > tuple2)    # Greater than check\n",
    "print(\"tuple1 >= tuple2:\", tuple1 >= tuple2)  # Greater than or equal to check"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40a1d02a",
   "metadata": {},
   "source": [
    "# 19. Delete a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "f74d001c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple: (1, 2, 3, 4)\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'tup1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10816\\1799121861.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Tuple:\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtup1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtup1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"After deletion\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtup1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'tup1' is not defined"
     ]
    }
   ],
   "source": [
    "tup1=(1,2,3,4)\n",
    "print(\"Tuple:\",tup1)\n",
    "del(tup1)\n",
    "print(\"After deletion\",tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc8fe0bb",
   "metadata": {},
   "source": [
    "# 20. Slice a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "091fa009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main tuple: (10, 15, 45, 78, 85, 96, 53, 54, 89, 20, 30)\n",
      "After slicing: (78, 85, 96, 53, 54, 89)\n"
     ]
    }
   ],
   "source": [
    "main_tuple=(10,15,45,78,85,96,53,54,89,20,30)\n",
    "sliced_tuple=main_tuple[3:9]\n",
    "print(\"main tuple:\",main_tuple)\n",
    "print(\"After slicing:\",sliced_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bceab1a",
   "metadata": {},
   "source": [
    "# 21. Find the maximum value in a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ecf50fe1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximun value in the tuple: 205\n"
     ]
    }
   ],
   "source": [
    "tup1=(12,85,45,75,205,0,15,49,98)\n",
    "max_value=max(tup1)\n",
    "print(\"Maximun value in the tuple:\",max_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49e0ee06",
   "metadata": {},
   "source": [
    "# 22. Find the minimum value in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "60f83444",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value in the tuple: -45\n"
     ]
    }
   ],
   "source": [
    "tup1=(12,85,-45,75,205,0,15,49,98)\n",
    "min_value=min(tup1)\n",
    "print(\"Minimum value in the tuple:\",min_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a925a55b",
   "metadata": {},
   "source": [
    "# 23. Convert a string to a tuple of characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "1bfa0742",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after converting to tuple of characters:\n",
      " ('S', 'a', 'm', 'p', 'l', 'e')\n"
     ]
    }
   ],
   "source": [
    "string=\"Sample\"\n",
    "tup1=tuple(string)\n",
    "print(\"String after converting to tuple of characters:\\n\",tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da54fb8d",
   "metadata": {},
   "source": [
    "# 24. Convert a tuple of characters to a string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "80079643",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "required string is: Sample\n"
     ]
    }
   ],
   "source": [
    "tup1=('S', 'a', 'm', 'p', 'l', 'e')\n",
    "string=\"\".join(tup1)\n",
    "print(\"required string is:\",string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb64d9b1",
   "metadata": {},
   "source": [
    "# 25. Create a tuple from multiple data types.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "412b5e3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple from multiple data types:\n",
      " (1, 2, 3, 'Tufan', 'kundu', 1.3, 1.5, True, False, (2+3j))\n"
     ]
    }
   ],
   "source": [
    "tup1=(1,2,3,\"Tufan\",\"kundu\",1.3,1.5,True,False,2+3j)\n",
    "print(\"Tuple from multiple data types:\\n\",tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b59f4a01",
   "metadata": {},
   "source": [
    "# 26. Check if two tuples are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a616b0a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tuple1 and tuple2 are identical: True\n",
      "tuple1 and tuple3 are identical: False\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 3)\n",
    "tuple3 = (4, 5, 6)\n",
    "\n",
    "are_identical1 = tuple1 == tuple2\n",
    "are_identical2 = tuple1 == tuple3\n",
    "\n",
    "print(\"tuple1 and tuple2 are identical:\", are_identical1)\n",
    "print(\"tuple1 and tuple3 are identical:\", are_identical2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "246eb0ee",
   "metadata": {},
   "source": [
    "# 27. Sort the elements of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "2dc57c8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before sorting: (15, -87, -25, 0, 12, 47, 58, 2, -9, 54, 25)\n",
      "After sorting: (-87, -25, -9, 0, 2, 12, 15, 25, 47, 54, 58)\n"
     ]
    }
   ],
   "source": [
    "tup1=(15,-87,-25,0,12,47,58,2,-9,54,25)\n",
    "sorted_tup=tuple(sorted(tup1))\n",
    "print(\"Before sorting:\",tup1)\n",
    "print(\"After sorting:\",sorted_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "555fce95",
   "metadata": {},
   "source": [
    "# 28. Convert a tuple of integers to a tuple of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "2e396f59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before conversion: (78, 85, 96, 53, 54, 89)\n",
      "After conversion: ('78', '85', '96', '53', '54', '89')\n"
     ]
    }
   ],
   "source": [
    "int_tup=(78, 85, 96, 53, 54, 89)\n",
    "str_tup=tuple((str(i) for i in int_tup))\n",
    "print(\"Before conversion:\",int_tup)\n",
    "print(\"After conversion:\",str_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5dd8ed9",
   "metadata": {},
   "source": [
    "# 29. Convert a tuple of strings to a tuple of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "075e1bee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before conversion: ('78', '85', '96', '53', '54', '89')\n",
      "After conversion: (78, 85, 96, 53, 54, 89)\n"
     ]
    }
   ],
   "source": [
    "str_tup=('78', '85', '96', '53', '54', '89')\n",
    "int_tup=tuple((int(i) for i in str_tup))\n",
    "print(\"Before conversion:\",str_tup)\n",
    "print(\"After conversion:\",int_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c80d8a68",
   "metadata": {},
   "source": [
    "# 30. Merge two tuples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "afeddd28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged tuple: (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:\", merged_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aac6910",
   "metadata": {},
   "source": [
    "# 31. Flatten a nested tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "2434786c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened tuple: (1, 2, 3, 4, 5, 6, 7, 8)\n"
     ]
    }
   ],
   "source": [
    "def flatten_tuple(nested_tuple):\n",
    "    flattened = []\n",
    "    for item in nested_tuple:\n",
    "        if isinstance(item, tuple):\n",
    "            flattened.extend(flatten_tuple(item))\n",
    "        else:\n",
    "            flattened.append(item)\n",
    "    return flattened\n",
    "\n",
    "# Step 1: Create a nested tuple\n",
    "nested_tuple = ((1, 2), (3, 4, 5), (6, (7, 8)))\n",
    "\n",
    "# Step 2: Flatten the nested tuple\n",
    "flattened_tuple = tuple(flatten_tuple(nested_tuple))\n",
    "\n",
    "# Step 3: Print the flattened tuple\n",
    "print(\"Flattened tuple:\", flattened_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36ec3392",
   "metadata": {},
   "source": [
    "# 32. Create a tuple of the first 5 prime numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "34a4de56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of first 5 prime numbers is: (2, 3, 5, 7, 11)\n"
     ]
    }
   ],
   "source": [
    "list1=[]\n",
    "for i in range(2,100):\n",
    "    c=0\n",
    "    for j in range(1,i+1):\n",
    "        if i%j==0:\n",
    "            c+=1\n",
    "    if c==2:\n",
    "        list1.append(i)\n",
    "tup1=tuple(list1[:5])\n",
    "print(\"Tuple of first 5 prime numbers is:\",tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d7f36c",
   "metadata": {},
   "source": [
    "# 33. Check if a tuple is a palindrome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "ce74adc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple is palindrome\n"
     ]
    }
   ],
   "source": [
    "org_tup=(1,2,3,2,1)\n",
    "rev_tup=tuple(reversed(org_tup))\n",
    "if org_tup==rev_tup:\n",
    "    print(\"The tuple is palindrome\")\n",
    "else:\n",
    "    print(\"The tuple is not palindrome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "198c542b",
   "metadata": {},
   "source": [
    "# 34. Create a tuple of squares of numbers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "b3aa2817",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of square of numbers from 1 to 5 : (1, 4, 9, 16, 25)\n"
     ]
    }
   ],
   "source": [
    "tup1=tuple([i**2 for i in range(1,6)])\n",
    "print(\"Tuple of square of numbers from 1 to 5 :\",tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a1e887e",
   "metadata": {},
   "source": [
    "# 35. Filter out all even numbers from a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "dec170d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple after filtering all the even number:\n",
      " (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "org_tuple=(1,2,3,4,5,6,7,8,9,10)\n",
    "mod_tuple=tuple(i for i in org_tuple if i%2!=0)\n",
    "print(\"Tuple after filtering all the even number:\\n\",mod_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2bae86f",
   "metadata": {},
   "source": [
    "# 36. Multiply all elements in a tuple by 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "7aea3671",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original tuple: (1, 5, 7, 9, 6, 25, 45, 47, 85)\n",
      "Modified tuple: (2, 10, 14, 18, 12, 50, 90, 94, 170)\n"
     ]
    }
   ],
   "source": [
    "org_tuple=(1,5,7,9,6,25,45,47,85)\n",
    "mod_tuple=tuple(i*2 for i in org_tuple)\n",
    "print(\"original tuple:\",org_tuple)\n",
    "print(\"Modified tuple:\",mod_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cce4ffc2",
   "metadata": {},
   "source": [
    "# 37. Create a tuple of random numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "b125bca3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random tuple: (19, 22, 10, 1, 33, 46, 35, 40, 35, 3)\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "random_tuple=tuple(random.randint(1,50) for i in range(10))\n",
    "print(\"random tuple:\",random_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b81a7652",
   "metadata": {},
   "source": [
    "# 38. Check if a tuple is sorted.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "52177f59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)  is sorted: True\n",
      "(5, 3, 1, 4, 2) is sorted: False\n"
     ]
    }
   ],
   "source": [
    "def check_sort(tup):\n",
    "    for i in range(1,len(tup)):\n",
    "        if tup[i]<tup[i-1]:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "sorted_tuple = (1, 2, 3, 4, 5)\n",
    "unsorted_tuple = (5, 3, 1, 4, 2)\n",
    "\n",
    "is_sorted1 = check_sort(sorted_tuple)\n",
    "is_sorted2 = check_sort(unsorted_tuple)\n",
    "\n",
    "print(sorted_tuple,\" is sorted:\", is_sorted1)\n",
    "print(unsorted_tuple ,\"is sorted:\", is_sorted2)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55cd33a3",
   "metadata": {},
   "source": [
    "# 39. Rotate a tuple to the left by `n` positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "a2324130",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:2\n",
      "Rotated tuple: (3, 4, 5, 6, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "org_tuple=(1,2,3,4,5,6)\n",
    "n=int(input(\"Enter the value of n:\"))\n",
    "n=n%len(org_tuple)\n",
    "rotated_tuple=org_tuple[n:]+org_tuple[:n]\n",
    "print(\"Rotated tuple:\",rotated_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7b2665b",
   "metadata": {},
   "source": [
    "# 40. Rotate a tuple to the right by `n` positions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "08e4208c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:2\n",
      "Rotated tuple: (4, 5, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "org_tuple=(1,2,3,4,5)\n",
    "n=int(input(\"Enter the value of n:\"))\n",
    "n=n%len(org_tuple)\n",
    "rotated_tuple=org_tuple[-n:]+org_tuple[:-n]\n",
    "print(\"Rotated tuple:\",rotated_tuple)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74d442b7",
   "metadata": {},
   "source": [
    "# 41. Create a tuple of the first 5 Fibonacci numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "c75f4b15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of first 5 fibonacci number:\n",
      " (0, 1, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "a=0\n",
    "b=1\n",
    "fibo=[a,b]\n",
    "for i in range(3):\n",
    "    c=a+b\n",
    "    fibo.append(c)\n",
    "    a=b\n",
    "    b=c\n",
    "fibo=tuple(fibo)\n",
    "print(\"Tuple of first 5 fibonacci number:\\n\",fibo)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fe17021",
   "metadata": {},
   "source": [
    "# 42. Create a tuple from user input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "809e1693",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the items seperated by comas:dog,frog,man,run,pet,yet\n",
      "Tuple from user input: ('dog', 'frog', 'man', 'run', 'pet', 'yet')\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter the items seperated by comas:\")\n",
    "list1=string.split(\",\")\n",
    "tuple1=tuple(list1)\n",
    "print(\"Tuple from user input:\",tuple1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c785b17b",
   "metadata": {},
   "source": [
    "# 43. Swap two elements in a tuple.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "0899d42e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After swapping two elements in the tuple:\n",
      " (1, 5, 7, 62, 95, 45, 8, 54, 85, 65)\n"
     ]
    }
   ],
   "source": [
    "org_tuple=(1,5,7,8,95,45,62,54,85,65)\n",
    "list1=list(org_tuple)\n",
    "index_1=3\n",
    "index_2=6\n",
    "temp=list1[3]\n",
    "list1[3]=list1[6]\n",
    "list1[6]=temp\n",
    "swap_tup=tuple(list1)\n",
    "print(\"After swapping two elements in the tuple:\\n\",swap_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb016a9",
   "metadata": {},
   "source": [
    "# 44. Reverse the elements of a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "d1d0728d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed tuple: (12, 10, 8, 6, 4, 2)\n"
     ]
    }
   ],
   "source": [
    "tup1=(2,4,6,8,10,12)\n",
    "reversed_tup=tuple(reversed(tup1))\n",
    "print(\"Reversed tuple:\",reversed_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6864bb0d",
   "metadata": {},
   "source": [
    "# 45. Create a tuple of the first `n` powers of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "a4f3ed58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:6\n",
      "Tuple of first 6 power of 2: (1, 2, 4, 8, 16, 32)\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "tup1=tuple(2**i for i in range(n))\n",
    "print(\"Tuple of first {} power of 2:\".format(n),tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "490bad13",
   "metadata": {},
   "source": [
    "# 46. Find the longest string in a tuple of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "649a9ceb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest string in tuple: assignment\n"
     ]
    }
   ],
   "source": [
    "tup1=(\"This\",\"is\",\"my\",\"second\",\"assignment\")\n",
    "l1=tup1\n",
    "longest_string=max(l1,key=len)\n",
    "print(\"Longest string in tuple:\",longest_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2542f70",
   "metadata": {},
   "source": [
    "# 47. Find the shortest string in a tuple of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "98e1cedc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest string in tuple: is\n"
     ]
    }
   ],
   "source": [
    "tup1=(\"This\",\"is\",\"my\",\"second\",\"assignment\")\n",
    "l1=tup1\n",
    "shortest_string=min(l1,key=len)\n",
    "print(\"Shortest string in tuple:\",shortest_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d30c89a0",
   "metadata": {},
   "source": [
    "# 48. Create a tuple of the first `n` triangular numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "96be5a88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:5\n",
      "Tuple of the first 5 triangular numbers: (1, 3, 6, 10, 15)\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "tup1 = tuple((i * (i + 1)) // 2 for i in range(1, n + 1))\n",
    "print(\"Tuple of the first\", n, \"triangular numbers:\", tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9382ae0",
   "metadata": {},
   "source": [
    "# 49. Check if a tuple contains another tuple as a subsequence.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "68b19b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Main tuple contains subsequence tuple: True\n"
     ]
    }
   ],
   "source": [
    "def contains_subsequence(main_tuple, sub_tuple):\n",
    "    sub_length = len(sub_tuple)\n",
    "    for i in range(len(main_tuple) - sub_length + 1):\n",
    "        if main_tuple[i:i+sub_length] == sub_tuple:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "# Main tuple\n",
    "main_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
    "\n",
    "# Subsequence tuple\n",
    "sub_tuple = (3, 4, 5)\n",
    "\n",
    "contains_subseq = contains_subsequence(main_tuple, sub_tuple)\n",
    "\n",
    "print(\"Main tuple contains subsequence tuple:\", contains_subseq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34e0902e",
   "metadata": {},
   "source": [
    "# 50. Create a tuple of alternating 1s and 0s of length `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "5990f196",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of alternating 1s and 0s: (0, 1, 0, 1, 0, 1, 0, 1, 0, 1)\n"
     ]
    }
   ],
   "source": [
    "alt_tup=tuple(i%2 for i in range(10))\n",
    "print(\"Tuple of alternating 1s and 0s:\", alt_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e25b8bf7",
   "metadata": {},
   "source": [
    "# Set Based Practice Problem :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b1855e9",
   "metadata": {},
   "source": [
    "# 1. Create a set with integers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "93dd5508",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of integer: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set_1={1,2,3,4,5}\n",
    "print(\"Set of integer:\",set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54acb7e7",
   "metadata": {},
   "source": [
    "# 2. Add an element to a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "c4d7a078",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of the integer to be added:15\n",
      "Original set: {1, 2, 3, 4, 5}\n",
      "Updated set: {1, 2, 3, 4, 5, 15}\n"
     ]
    }
   ],
   "source": [
    "set_1={1,2,3,4,5}\n",
    "value=int(input(\"Enter the value of the integer to be added:\"))\n",
    "print(\"Original set:\",set_1)\n",
    "set_1.add(value)\n",
    "print(\"Updated set:\",set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe493c9",
   "metadata": {},
   "source": [
    "# 3. Remove an element from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "ae75900d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value from the set to be removed:5\n",
      "original set: {1, 2, 3, 4, 5, 15}\n",
      "After removing: {1, 2, 3, 4, 15}\n"
     ]
    }
   ],
   "source": [
    "set_1= {1, 2, 3, 4, 5, 15}\n",
    "n=int(input(\"Enter the value from the set to be removed:\"))\n",
    "print(\"original set:\",set_1)\n",
    "set_1.remove(n)\n",
    "print(\"After removing:\",set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a88cca7c",
   "metadata": {},
   "source": [
    "# 4. Check if an element exists in a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "69e6860a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element whose existance is to be checked:2\n",
      "2  is present in the set\n"
     ]
    }
   ],
   "source": [
    "set_1= {1, 2, 3, 4, 5, 15}\n",
    "n=int(input(\"Enter the element whose existance is to be checked:\"))\n",
    "if n in set_1:\n",
    "    print(n,\" is present in the set\")\n",
    "else:\n",
    "    print(n,\" is not present in the set\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "932846d8",
   "metadata": {},
   "source": [
    "# 5. Find the length of a set without using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "c121eb9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the set is:  6\n"
     ]
    }
   ],
   "source": [
    "set_1= {1, 2, 3, 4, 5, 15}\n",
    "count=0\n",
    "for i in set_1:\n",
    "    count+=1\n",
    "print(\"Length of the set is: \",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5054546",
   "metadata": {},
   "source": [
    "# 6. Clear all elements from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "d616a446",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original set: {1, 2, 3, 4, 5, 15}\n",
      "After clearing: set()\n"
     ]
    }
   ],
   "source": [
    "set_1= {1, 2, 3, 4, 5, 15}\n",
    "print(\"Original set:\",set_1)\n",
    "set_1.clear()\n",
    "print(\"After clearing:\",set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e789de",
   "metadata": {},
   "source": [
    "# 7. Create a set of even numbers from 1 to 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "7855afac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of even number: {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "even_set=set([i for i in range(1,11) if i%2==0])\n",
    "print(\"Set of even number:\",even_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e66d482",
   "metadata": {},
   "source": [
    "# 8. Create a set of odd numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "fd85c361",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of odd number: {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "odd_set=set([i for i in range(1,11) if i%2!=0])\n",
    "print(\"Set of odd number:\",odd_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49689978",
   "metadata": {},
   "source": [
    "# 9. Find the union of two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "97759251",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 1: {8, 2, 4, 6}\n",
      "set 2: {1, 3, 5, 7, 9}\n",
      "union of sets: {1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "set_1={2,4,6,8}\n",
    "set_2={1,3,5,7,9}\n",
    "u_set=set_1.union(set_2)\n",
    "print(\"set 1:\",set_1)\n",
    "print(\"set 2:\",set_2)\n",
    "print(\"union of sets:\",u_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88a3371e",
   "metadata": {},
   "source": [
    "# 10. Find the intersection of two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "1d2d9e79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 1: {2, 4, 6, 7, 8}\n",
      "set 2: {1, 3, 5, 7, 9}\n",
      "intersection of sets: {7}\n"
     ]
    }
   ],
   "source": [
    "set_1={2,4,6,7,8}\n",
    "set_2={1,3,5,7,9}\n",
    "i_set=set_1.intersection(set_2)\n",
    "print(\"set 1:\",set_1)\n",
    "print(\"set 2:\",set_2)\n",
    "print(\"intersection of sets:\",i_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8058a813",
   "metadata": {},
   "source": [
    "# 11. Find the difference between two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "c4ca763d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 1: {2, 4, 6, 7, 8}\n",
      "set 2: {1, 3, 5, 7, 9}\n",
      "difference of sets: {8, 2, 4, 6}\n"
     ]
    }
   ],
   "source": [
    "set_1={2,4,6,7,8}\n",
    "set_2={1,3,5,7,9}\n",
    "d_set=set_1.difference(set_2)\n",
    "print(\"set 1:\",set_1)\n",
    "print(\"set 2:\",set_2)\n",
    "print(\"difference of sets:\",d_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8f8dd23",
   "metadata": {},
   "source": [
    "# 12. Check if a set is a subset of another set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "dd4368d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 2 is subset of set 1: True\n"
     ]
    }
   ],
   "source": [
    "set_1={1,2,3,4,5,6,7,8,9}\n",
    "set_2={1,3,5,7,9}\n",
    "check=set_2.issubset(set_1)\n",
    "print(\"set 2 is subset of set 1:\",check)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab454476",
   "metadata": {},
   "source": [
    "# 13. Check if a set is a superset of another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "036fb8d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 1 is superset of set 2: True\n"
     ]
    }
   ],
   "source": [
    "set_1={1,2,3,4,5,6,7,8,9}\n",
    "set_2={1,3,5,7,9}\n",
    "check=set_1.issuperset(set_2)\n",
    "print(\"set 1 is superset of set 2:\",check)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "469976f3",
   "metadata": {},
   "source": [
    "# 14. Create a set from a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "5255efc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list: [1, 2, 4, 5, 1, 2, 7, 8, 9, 1, 4, 5]\n",
      "set: {1, 2, 4, 5, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "list_1=[1,2,4,5,1,2,7,8,9,1,4,5]\n",
    "r_set=set(list_1)\n",
    "print(\"list:\",list_1)\n",
    "print(\"set:\",r_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "401663f3",
   "metadata": {},
   "source": [
    "# 15. Convert a set to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "94b035df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set: {1, 2, 4, 5, 7, 8, 9}\n",
      "List: [1, 2, 4, 5, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "set_1={1, 2, 4, 5, 7, 8, 9}\n",
    "list_1=list(set_1)\n",
    "print(\"Set:\",set_1)\n",
    "print(\"List:\",list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b64301fc",
   "metadata": {},
   "source": [
    "# 16. Remove a random element from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "3e59b872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original set: {1, 2, 4, 5, 7, 8, 9}\n",
      "After removing random element: {1, 4, 5, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "org_set={1, 2, 4, 5, 7, 8, 9}\n",
    "print(\"Original set:\",org_set)\n",
    "random_element = random.choice(list(org_set))\n",
    "org_set.remove(random_element)\n",
    "print(\"After removing random element:\",org_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb1a0d37",
   "metadata": {},
   "source": [
    "# 17. Pop an element from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "bf83f73c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original set: {1, 2, 4, 5, 7, 8, 9}\n",
      "Popped element: 1\n",
      "After pop: {2, 4, 5, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "org_set={1, 2, 4, 5, 7, 8, 9}\n",
    "print(\"Original set:\",org_set)\n",
    "popped_ele=org_set.pop()\n",
    "print(\"Popped element:\",popped_ele)\n",
    "print(\"After pop:\",org_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8926f2c5",
   "metadata": {},
   "source": [
    "# 18. Check if two sets have no elements in common.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "0af81f2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets have no common element\n"
     ]
    }
   ],
   "source": [
    "set_1={1,3,5,7,9}\n",
    "set_2={2,4,6,8,10}\n",
    "common_ele=set_1.intersection(set_2)\n",
    "if not common_ele:\n",
    "    print(\"The sets have no common element\")\n",
    "else:\n",
    "    print(\"The set have common elements:\",common_ele)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97b8df75",
   "metadata": {},
   "source": [
    "# 19. Find the symmetric difference between two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "55f44d45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 1: {2, 5, 6, 7, 9}\n",
      "set 2: {2, 4, 6, 8, 10}\n",
      "symmentric difference: {4, 5, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "set_1={6,2,5,7,9}\n",
    "set_2={2,4,6,8,10}\n",
    "sym_diff=set_1.symmetric_difference(set_2)\n",
    "print(\"set 1:\",set_1)\n",
    "print(\"set 2:\",set_2)\n",
    "print(\"symmentric difference:\",sym_diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb901304",
   "metadata": {},
   "source": [
    "# 20. Update a set with elements from another set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "695c6838",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set 1: {2, 4, 6, 7, 8}\n",
      "set 2: {1, 3, 5, 7, 9}\n",
      "Updated set: {1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "set_1={2,4,6,7,8}\n",
    "set_2={1,3,5,7,9}\n",
    "print(\"set 1:\",set_1)\n",
    "print(\"set 2:\",set_2)\n",
    "set_1.update(set_2)\n",
    "print(\"Updated set:\",set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4ce98d7",
   "metadata": {},
   "source": [
    "# 21. Create a set of the first 5 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "a9c5de55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of first 5 prime number: {2, 3, 5, 7, 11}\n"
     ]
    }
   ],
   "source": [
    "l1=[]\n",
    "for i in range(1,100):\n",
    "    c=0\n",
    "    for j in range(1,i+1):\n",
    "        if(i%j==0):\n",
    "            c+=1\n",
    "    if c==2:\n",
    "        l1.append(i)\n",
    "prime_set=set(l1[:5])\n",
    "print(\"Set of first 5 prime number:\",prime_set)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "461858ef",
   "metadata": {},
   "source": [
    "# 22. Check if two sets are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "42e161e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets are identical.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {3, 1, 5, 2, 4}  \n",
    "if set1 == set2:\n",
    "    print(\"The sets are identical.\")\n",
    "else:\n",
    "    print(\"The sets are not identical.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4281470d",
   "metadata": {},
   "source": [
    "# 23. Create a frozen set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "1b0a3d27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frozen Set: frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})\n"
     ]
    }
   ],
   "source": [
    "elements = [1,2,3,4,5,6,7,8,9,10]\n",
    "my_frozen_set = frozenset(elements)\n",
    "print(\"Frozen Set:\", my_frozen_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5a6b037",
   "metadata": {},
   "source": [
    "# 24. Check if a set is disjoint with another set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "24215ccd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are the sets disjoint? True\n"
     ]
    }
   ],
   "source": [
    "set_1={1,3,5,7,9}\n",
    "set_2={2,4,6,8,10}\n",
    "check=set_1.isdisjoint(set_2)\n",
    "print(\"Are the sets disjoint?\",check)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30836f8b",
   "metadata": {},
   "source": [
    "# 25. Create a set of squares of numbers from 1 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "c7d9bf10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required set: {1, 4, 9, 16, 25}\n"
     ]
    }
   ],
   "source": [
    "sq_set=set([i**2 for i in range(1,6)])\n",
    "print(\"Required set:\",sq_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d5000db",
   "metadata": {},
   "source": [
    "# 26. Filter out all even numbers from a set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "e0fd759c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main set: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "After filtering: {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "main_set={1,2,3,4,5,6,7,8,9,10}\n",
    "filtered=[]\n",
    "for i in main_set:\n",
    "    if i%2!=0:\n",
    "        filtered.append(i)\n",
    "filtered=set(filtered)\n",
    "print(\"main set:\",main_set)\n",
    "print(\"After filtering:\",filtered)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e2bd3bf",
   "metadata": {},
   "source": [
    "# 27. Multiply all elements in a set by 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "ce4cb150",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Main set: {1, 3, 5, 7, 9}\n",
      "After multiplying: {2, 6, 10, 14, 18}\n"
     ]
    }
   ],
   "source": [
    "set_1={1, 3, 5, 7, 9}\n",
    "up_set=set([i*2 for i in set_1])\n",
    "print(\"Main set:\",set_1)\n",
    "print(\"After multiplying:\",up_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54bca1fe",
   "metadata": {},
   "source": [
    "# 28. Create a set of random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "6a0635c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated set of random numbers: {12, 19, 86, 59, 61}\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "num_random_numbers = 5\n",
    "\n",
    "random_number_set = set()\n",
    "\n",
    "for _ in range(num_random_numbers):\n",
    "    random_num = random.randint(1, 100)  \n",
    "    random_number_set.add(random_num)\n",
    "\n",
    "print(\"Generated set of random numbers:\", random_number_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5f38296",
   "metadata": {},
   "source": [
    "# 29. Check if a set is empty.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "60010fa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The set is empty.\n"
     ]
    }
   ],
   "source": [
    "set_1=set()\n",
    "if not set_1:\n",
    "    print(\"The set is empty.\")\n",
    "else:\n",
    "    print(\"The set is not empty.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dfee847",
   "metadata": {},
   "source": [
    "# 30. Create a nested set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "400d5a44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested Set: {frozenset({1, 2, 3, 4, 5}), frozenset({6, 7, 8, 9, 10})}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {6, 7, 8, 9, 10}\n",
    "\n",
    "\n",
    "frozen_set1 = frozenset(set1)\n",
    "frozen_set2 = frozenset(set2)\n",
    "\n",
    "nested_set = {frozen_set1, frozen_set2}\n",
    "\n",
    "print(\"Nested Set:\", nested_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb2d6a6c",
   "metadata": {},
   "source": [
    "# 31. Remove an element from a set using the discard method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "b16d0304",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the element to be removed:3\n",
      "Original set {1, 2, 3, 4, 5}\n",
      "After removing {1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "n=int(input(\"Enter the element to be removed:\"))\n",
    "print(\"Original set\",set1)\n",
    "set1.discard(n)\n",
    "print(\"After removing\",set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6bf2150",
   "metadata": {},
   "source": [
    "# 32. Compare two sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "cd31ba2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1: {1, 2, 3, 4, 5}\n",
      "Set 2: {4, 5, 6, 7, 8}\n",
      "Is set1 a subset of set2? False\n",
      "Is set2 a subset of set1? False\n",
      "Intersection: {4, 5}\n",
      "Union: {1, 2, 3, 4, 5, 6, 7, 8}\n",
      "Elements in set1 but not in set2: {1, 2, 3}\n",
      "Elements in set2 but not in set1: {8, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    "\n",
    "is_subset = set1.issubset(set2)\n",
    "\n",
    "# Check if set2 is a subset of set1\n",
    "is_superset = set1.issuperset(set2)\n",
    "\n",
    "# Find the intersection of the sets\n",
    "intersection = set1.intersection(set2)\n",
    "\n",
    "# Find the union of the sets\n",
    "union = set1.union(set2)\n",
    "\n",
    "# Find the elements that are in set1 but not in set2\n",
    "difference1 = set1.difference(set2)\n",
    "\n",
    "# Find the elements that are in set2 but not in set1\n",
    "difference2 = set2.difference(set1)\n",
    "\n",
    "# Step 3: Print the results\n",
    "print(\"Set 1:\", set1)\n",
    "print(\"Set 2:\", set2)\n",
    "print(\"Is set1 a subset of set2?\", is_subset)\n",
    "print(\"Is set2 a subset of set1?\", is_superset)\n",
    "print(\"Intersection:\", intersection)\n",
    "print(\"Union:\", union)\n",
    "print(\"Elements in set1 but not in set2:\", difference1)\n",
    "print(\"Elements in set2 but not in set1:\", difference2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df4102ed",
   "metadata": {},
   "source": [
    "# 33. Create a set from a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "a790f2a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string:assignment\n",
      "Set of string: {'s', 'm', 'n', 'a', 'e', 'i', 'g', 't'}\n"
     ]
    }
   ],
   "source": [
    "string=input(\"Enter a string:\")\n",
    "ch_set=set(string)\n",
    "print(\"Set of string:\",ch_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c835aa6",
   "metadata": {},
   "source": [
    "# 34. Convert a set of strings to a set of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "150d3781",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String set: {'333', '121', '999', '222'}\n",
      "Integer set: {121, 333, 222, 999}\n"
     ]
    }
   ],
   "source": [
    "str_set={\"121\",\"222\",\"333\",\"999\"}\n",
    "int_set=set()\n",
    "for string in str_set:\n",
    "    value=int(string)\n",
    "    int_set.add(value)\n",
    "print(\"String set:\",str_set)\n",
    "print(\"Integer set:\",int_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f7dbb8f",
   "metadata": {},
   "source": [
    "# 35. Convert a set of integers to a set of strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "444df8d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer set: {121, 333, 222, 999}\n",
      "String set: {'333', '121', '999', '222'}\n"
     ]
    }
   ],
   "source": [
    "int_set={121, 333, 222, 999}\n",
    "str_set=set()\n",
    "for i in int_set:\n",
    "    value=str(i)\n",
    "    str_set.add(value)\n",
    "print(\"Integer set:\",int_set)\n",
    "print(\"String set:\",str_set)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baf46f7a",
   "metadata": {},
   "source": [
    "# 36. Create a set from a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "e2ded855",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tupple: (1, 3, 5, 7, 9)\n",
      "Set: {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "tup=(1, 3, 5, 7, 9)\n",
    "set_1=set(tup)\n",
    "print(\"Tupple:\",tup)\n",
    "print(\"Set:\",set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fc2c484",
   "metadata": {},
   "source": [
    "# 37. Convert a set to a tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "6401bf2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set: {1, 3, 5, 7, 9}\n",
      "Tupple: (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "set1= {1, 3, 5, 7, 9}\n",
    "tup=tuple(set1)\n",
    "print(\"Set:\",set1)\n",
    "print(\"Tupple:\",tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46734279",
   "metadata": {},
   "source": [
    "# 38. Find the maximum value in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "6b217f91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum value in the set: 88\n"
     ]
    }
   ],
   "source": [
    "set1={1,2,25,45,78,54,62,0,12,-85,88,45}\n",
    "max_value=max(set1)\n",
    "print(\"maximum value in the set:\",max_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "060680fb",
   "metadata": {},
   "source": [
    "# 39. Find the minimum value in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "a1656294",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimum value in the set: -85\n"
     ]
    }
   ],
   "source": [
    "set1={1,2,25,45,78,54,62,0,12,-85,88,45}\n",
    "min_value=min(set1)\n",
    "print(\"minimum value in the set:\",min_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61e8bc6e",
   "metadata": {},
   "source": [
    "# 40. Create a set from user input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "ed8ebbd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter elements for the set (type 'done' to finish):\n",
      "> 5\n",
      "> 9\n",
      "> 45\n",
      "> 68\n",
      "> 45\n",
      "> done\n",
      "Final set: {'9', '68', '5', '45'}\n"
     ]
    }
   ],
   "source": [
    "user_set = set()\n",
    "\n",
    "print(\"Enter elements for the set (type 'done' to finish):\")\n",
    "while True:\n",
    "    user_input = input(\"> \")  \n",
    "    if user_input.lower() == 'done':\n",
    "        break  \n",
    "\n",
    "    user_set.add(user_input)\n",
    "\n",
    "print(\"Final set:\", user_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edd6f6dd",
   "metadata": {},
   "source": [
    "# 41. Check if the intersection of two sets is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "36a5ce18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The intersection of the two sets is not empty.\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    "\n",
    "intersection_result = set1.intersection(set2)\n",
    "\n",
    "if not intersection_result:\n",
    "    print(\"The intersection of the two sets is empty.\")\n",
    "else:\n",
    "    print(\"The intersection of the two sets is not empty.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fedb4f1f",
   "metadata": {},
   "source": [
    "# 42. Create a set of the first 5 Fibonacci numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "85a1240f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of first 5 fibonacci number:\n",
      " {0, 1, 2, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "a=0\n",
    "b=1\n",
    "fibo={a,b}\n",
    "for i in range(4):\n",
    "    c=a+b\n",
    "    fibo.add(c)\n",
    "    a=b\n",
    "    b=c\n",
    "print(\"Tuple of first 5 fibonacci number:\\n\",fibo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b152bb7b",
   "metadata": {},
   "source": [
    "# 43. Remove duplicates from a list using sets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "4964af26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list: [1, 2, 4, 1, 5, 4, 7, 1, 2, 4, 6, 8, 6, 9, 5, 7]\n",
      "After removing duplicates: [1, 2, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "org_list=[1,2,4,1,5,4,7,1,2,4,6,8,6,9,5,7]\n",
    "mod_list=list(set(org_list))\n",
    "print(\"Original list:\",org_list)\n",
    "print(\"After removing duplicates:\",mod_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f65bd74d",
   "metadata": {},
   "source": [
    "# 44. Check if two sets have the same elements, regardless of their count.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "c915b553",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets do not have the same elements.\n"
     ]
    }
   ],
   "source": [
    "def have_same_elements(set1, set2):\n",
    "    sorted_list1 = sorted(list(set1))\n",
    "    sorted_list2 = sorted(list(set2))\n",
    "    return sorted_list1 == sorted_list2\n",
    "\n",
    "set1 = {1, 2, 3, 2, 4}\n",
    "set2 = {3, 1, 2}\n",
    "\n",
    "result = have_same_elements(set1, set2)\n",
    "\n",
    "if result:\n",
    "    print(\"The sets have the same elements.\")\n",
    "else:\n",
    "    print(\"The sets do not have the same elements.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54e395d9",
   "metadata": {},
   "source": [
    "# 45. Create a set of the first `n` powers of 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "3804250c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:6\n",
      "Tuple of first 6 power of 2: {32, 1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "set1=set(2**i for i in range(n))\n",
    "print(\"Tuple of first {} power of 2:\".format(n),set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86935a4",
   "metadata": {},
   "source": [
    "# 46. Find the common elements between a set and a list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "936775bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements: [7, 9, 12, 15]\n"
     ]
    }
   ],
   "source": [
    "my_set = {3, 7, 9, 12, 15}\n",
    "my_list = [7, 12, 5, 9,15,75,85]\n",
    "common_elements = []\n",
    "\n",
    "for element in my_set:\n",
    "    if element in my_list:\n",
    "        common_elements.append(element)\n",
    "\n",
    "print(\"Common elements:\", common_elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b641136e",
   "metadata": {},
   "source": [
    "# 47. Create a set of the first `n` triangular numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "a87ef2cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the value of n:6\n",
      "Set of the first 6 triangular numbers: {1, 3, 6, 10, 15, 21}\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Enter the value of n:\"))\n",
    "set1 = set((i * (i + 1)) // 2 for i in range(1, n + 1))\n",
    "print(\"Set of the first\", n, \"triangular numbers:\", set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3804a79c",
   "metadata": {},
   "source": [
    "# 48. Check if a set contains another set as a subset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "2db02afc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set2 is a subset of set1\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {3, 4}\n",
    "is_subset = set2.issubset(set1)\n",
    "\n",
    "if is_subset:\n",
    "    print(\"set2 is a subset of set1\")\n",
    "else:\n",
    "    print(\"set2 is not a subset of set1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3c67eb0",
   "metadata": {},
   "source": [
    "# 49. Create a set of alternating 1s and 0s of length `n`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "fb7cec93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of alternating 1s and 0s: {0, 1}\n"
     ]
    }
   ],
   "source": [
    "alt_set=set(i%2 for i in range(10))\n",
    "print(\"Set of alternating 1s and 0s:\", alt_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4b833a4",
   "metadata": {},
   "source": [
    "# 50. Merge multiple sets into one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "c1967708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged Set: {1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set3 = {5, 6, 7}\n",
    "merged_set = set1.union(set2, set3)\n",
    "print(\"Merged Set:\", merged_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1db3c71",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}