A2_Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e04a3f90-77dd-47ff-97a8-dd0f1617899c",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Hello sir ,\n",
    "\n",
    "I would like to bring to your attention that I inadvertently used the eval() function in my assignment.\n",
    "I understand the concerns regarding its potential security risks and acknowledge that its usage was not \n",
    "appropriate in this context.\n",
    "I kindly request that my use of eval() be disregarded during the evaluation of my assignment, and I \n",
    "assure you that I will adhere to best practices and guidelines in future assignments.\n",
    "\n",
    "Thank you for your understanding.\n",
    "\n",
    "Yours sincerely,\n",
    "AKSHAT SAXENA\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00dcda78-4662-45c6-a166-a59204a1dc38",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "328a7c8a-61fa-488f-bac8-20ef492eade9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# String Based Assignment Problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3f423bf3-24e4-46b8-9a46-c47f42da63f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed string is  .anexaS tahskA si eman yM\n"
     ]
    }
   ],
   "source": [
    "'''Q1 Write a program to reverse a string.'''\n",
    "\n",
    "s = input(\"Enter a string :\")\n",
    "reverse_string=s[::-1]\n",
    "print(\"Reversed string is \",reverse_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "80690455-8913-4ed1-b6fe-7a9efb0f0ec5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Hello , How are you?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The input string is not a palindrome.\n"
     ]
    }
   ],
   "source": [
    "'''Q2 Check if a string is a palindrome.'''\n",
    "\n",
    "k = input(\"Enter a string :\")\n",
    "removed_whitespaces = k.replace(\" \", \"\").lower()\n",
    "reversed = removed_whitespaces[::-1]\n",
    "if reversed == removed_whitespaces:\n",
    "    print(\"The input string is a palindrome.\")\n",
    "else:\n",
    "    print(\"The input string is not a palindrome.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8f8fc5c7-74af-4c9a-a12f-94ab033eb8a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uppercase string is  MY NAME IS AKSHAT SAXENA.\n"
     ]
    }
   ],
   "source": [
    "'''Q3 Convert a string to uppercase.'''\n",
    "\n",
    "a = input(\"Enter a string :\")\n",
    "uppercase_string = a.upper()\n",
    "print(\"Uppercase string is \",uppercase_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1ac0fd82-9261-4b67-966e-bd000aeb9583",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowercase string is  my name is akshat saxena.\n"
     ]
    }
   ],
   "source": [
    "'''Q4 Convert a string to lowercase.'''\n",
    "\n",
    "a = input(\"Enter a string :\")\n",
    "lowercase_string = a.lower()\n",
    "print(\"Lowercase string is \",lowercase_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "29cf4d28-df2e-4f1f-9d94-f3438ce9f055",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Hey! How are you doing?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of vowels in string provided is  8\n"
     ]
    }
   ],
   "source": [
    "'''Q5 Count the number of vowels in a string.'''\n",
    "\n",
    "b = input(\"Enter a string :\")\n",
    "vowels = b.count(\"A\") + b.count(\"E\") + b.count(\"I\") + b.count(\"O\") + b.count(\"U\") + b.count(\"a\") + b.count(\"e\") + b.count(\"i\") + b.count(\"o\") + b.count(\"u\")\n",
    "print(\"Number of vowels in string provided is \",vowels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9f9f6552-4b28-40c9-98b0-7c5f88fd960f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of consonants in string provided is  12\n"
     ]
    }
   ],
   "source": [
    "'''Q6 Count the number of consonants in a string.'''\n",
    "\n",
    "consonant = 0\n",
    "s = input(\"Enter a string :\")\n",
    "length = len(s)\n",
    "v = \"BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz\"\n",
    "for i in range(length):\n",
    "    if s[i] in v:\n",
    "        consonant += 1\n",
    "print(\"Number of consonants in string provided is \",consonant)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1adbccd2-2806-4771-90d0-12a080ccd427",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified string without spaces is  MynameisAkshatSaxena.\n"
     ]
    }
   ],
   "source": [
    "'''Q7 Remove all whitespaces from a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "modified_string = \"\"\n",
    "for i in string:\n",
    "    if i != \" \":\n",
    "        modified_string += i\n",
    "print(\"Modified string without spaces is \",modified_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "17249954-7774-4c53-8a8b-da60cc830908",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of string provided is  25\n"
     ]
    }
   ],
   "source": [
    "'''Q8 Find the length of a string without using the `len()` function.'''\n",
    "\n",
    "count = 0\n",
    "string = input(\"Enter a string :\")\n",
    "for i in string:\n",
    "    count += 1\n",
    "print(\"Length of string provided is \",count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "20a0ea12-1900-4120-9145-1c66f0530897",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n",
      "Enter the specific word to be checked : IS\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IS is not present in string\n"
     ]
    }
   ],
   "source": [
    "'''Q9 Check if a string contains a specific word.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "word = input(\"Enter the specific word to be checked :\")\n",
    "if word in string:\n",
    "    print(word ,\"is present in string\")\n",
    "else:\n",
    "    print(word ,\"is not present in string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "149611a6-2106-44cb-96f0-ffcc14475c91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Today is Sunday.\n",
      "Enter the specific word to be replaced : Sunday\n",
      "Enter the new word : Monday\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New string with replaced word is  Today is Monday.\n"
     ]
    }
   ],
   "source": [
    "'''Q10 Replace a word in a string with another word.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "word = input(\"Enter the specific word to be replaced :\")\n",
    "new_word = input(\"Enter the new word :\")\n",
    "replace_string = string.replace(word , new_word)\n",
    "print(\"New string with replaced word is \",replace_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "69c83d8d-ed6a-470a-8c55-7ee1b68cdaf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I daily go to school . I love my schooling .\n",
      "Enter the word to be counted : school\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The occurances of school in string provided is 1\n"
     ]
    }
   ],
   "source": [
    "'''Q11 Count the occurrences of a word in a string.'''\n",
    "\n",
    "word_count = 0\n",
    "string = input(\"Enter a string :\")\n",
    "word = input(\"Enter the word to be counted :\")\n",
    "f = string.split()\n",
    "for i in range(len(f)):\n",
    "    if word == f[i]:\n",
    "        word_count += 1    \n",
    "print(\"The occurances of\", word ,\"in string provided is\",word_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "80a33542-4c2d-4b36-ba96-d4b1550220d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena.\n",
      "Enter the word to be searched : Akshat\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first occurance of Akshat is 11\n"
     ]
    }
   ],
   "source": [
    "'''Q12 Find the first occurrence of a word in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "word = input(\"Enter the word to be searched :\")\n",
    "o = string.find(word)\n",
    "if o == -1:\n",
    "    print(\"Entered word is not in string\")\n",
    "else:\n",
    "    print(\"The first occurance of\" ,word ,\"is\" ,o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "57ee907b-21df-48c2-b794-eb68f8cc566e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Hello Hello eyes on screen . If eyes focus over then their will be a mistake .\n",
      "Enter the word to be searched : Hello\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The last occurance of Hello is 6\n"
     ]
    }
   ],
   "source": [
    "'''Q13 Find the last occurrence of a word in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "length = len(string)\n",
    "word = input(\"Enter the word to be searched :\")\n",
    "reverse_string = string[::-1]\n",
    "l = reverse_string.find(word[::-1])\n",
    "if l == -1:\n",
    "    print(\"Entered word is not in string\")\n",
    "else:\n",
    "    print(\"The last occurance of\" ,word ,\"is\" ,length - l -len(word))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "136eda34-4e65-457c-9d58-62fe0b66be98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n",
      "Enter the word to split the string on :  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Splitted string is  ['My', 'name', 'is', 'Akshat', 'Saxena', '.']\n"
     ]
    }
   ],
   "source": [
    "'''Q14 Split a string into a list of words.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "word_split = input(\"Enter the word to split the string on :\")\n",
    "l = string.split(word_split)\n",
    "print(\"Splitted string is \",l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8150c37c-6de5-42d3-abe4-a5a2777cbce3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter list of words : [\"I\", \"study\", \"in\", \"PW SKILLS\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joined list of words into a string is  I study in PW SKILLS\n"
     ]
    }
   ],
   "source": [
    "'''Q15 Join a list of words into a string.'''\n",
    "\n",
    "list_of_words = eval(input(\"Enter list of words :\"))\n",
    "joined = ' '.join(list_of_words)\n",
    "print(\"Joined list of words into a string is \",joined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b1013cbc-4aba-48ed-b2d1-12c0727f2f45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string separated by spaces : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String separated by spaces is  My name is Akshat Saxena .\n",
      "String separated by underscores is  My_name_is_Akshat_Saxena_.\n"
     ]
    }
   ],
   "source": [
    "'''Q16 Convert a string where words are separated by spaces to one where words\n",
    "are separated by underscores.'''\n",
    "\n",
    "string = input(\"Enter a string separated by spaces :\")\n",
    "print(\"String separated by spaces is \",string)\n",
    "underscore = string.replace(\" \",\"_\")\n",
    "print(\"String separated by underscores is \",underscore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a2a807eb-7d52-4120-8f3a-202ea59cbc2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I study in PW SKILLS\n",
      "Enter a word or phrase : study\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string does not starts with  study\n"
     ]
    }
   ],
   "source": [
    "'''Q17 Check if a string starts with a specific word or phrase.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "word = input(\"Enter a word or phrase :\")\n",
    "check = string.startswith(word)\n",
    "if check == True:\n",
    "    print(\"The string starts with \", word)\n",
    "else:\n",
    "    print(\"The string does not starts with \", word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "76f7339d-7677-45e9-a163-f76ddca1b8f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I study in PW SKILLS\n",
      "Enter a word or phrase : PW SKILLS\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string ends with  PW SKILLS\n"
     ]
    }
   ],
   "source": [
    "'''Q18 Check if a string ends with a specific word or phrase.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "word = input(\"Enter a word or phrase :\")\n",
    "check = string.endswith(word)\n",
    "if check == True:\n",
    "    print(\"The string ends with \", word)\n",
    "else:\n",
    "    print(\"The string does not ends with \", word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "90fa7708-d3dd-4eca-97a7-85861eb22951",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I study in PW SKILLS\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title cased string is I Study In Pw Skills\n"
     ]
    }
   ],
   "source": [
    "'''Q19 Convert a string to title case (e.g., \"hello world\" to \"Hello World\").'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "t = string.title()\n",
    "print(\"Title cased string is\",t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a245f0cb-677d-44be-8082-a2ad00d43894",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The longest word in the string provided is Akshat\n"
     ]
    }
   ],
   "source": [
    "'''Q20 Find the longest word in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "L =[]\n",
    "k = string.split()\n",
    "for i in range(len(k)):\n",
    "    L.append(len(k[i]))\n",
    "    max_num = max(L)\n",
    "    index_word = L.index(max_num)\n",
    "print(\"The longest word in the string provided is\", k[index_word])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e20bd620-50d3-4020-a52f-26a434ccf25c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Hello I am your friend\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shortest word in the string provided is I\n"
     ]
    }
   ],
   "source": [
    "'''Q21 Find the shortest word in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "L =[]\n",
    "k = string.split()\n",
    "for i in range(len(k)):\n",
    "    L.append(len(k[i]))\n",
    "    min_num = min(L)\n",
    "    index_word = L.index(min_num)\n",
    "print(\"The shortest word in the string provided is\", k[index_word])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ce58f151-4fc8-4589-8228-c940efae5d55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after reversing the order of words is yM eman si tahskA anexaS . \n"
     ]
    }
   ],
   "source": [
    "'''Q22 Reverse the order of words in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "reverse_string = \"\"\n",
    "k = string.split()\n",
    "for i in k :\n",
    "    reverse_string += i[::-1]\n",
    "    reverse_string += \" \"\n",
    "print(\"String after reversing the order of words is\", reverse_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bf75b3c0-969e-430c-9ab1-7821a1e9dfc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String is not alphanumeric\n"
     ]
    }
   ],
   "source": [
    "'''Q23 Check if a string is alphanumeric.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "check = string.isalnum()\n",
    "if check:\n",
    "    print(\"String is alphanumeric\")\n",
    "else:\n",
    "    print(\"String is not alphanumeric\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "70cbe11c-4806-4852-9022-7fa2947cd3d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I am 18 years old . I study in class 12th .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted digits from string are  1812\n"
     ]
    }
   ],
   "source": [
    "'''Q24 Extract all digits from a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "digit = \" \"\n",
    "for i in string :\n",
    "    if i.isdigit() :\n",
    "        digit += i\n",
    "print(\"Extracted digits from string are\", digit) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f99aaa13-1470-4828-9fc0-def99721f14b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I am 18 years old . I study in class 12th .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracted alphabets from string are  IamyearsoldIstudyinclassth\n"
     ]
    }
   ],
   "source": [
    "'''Q25 Extract all alphabets from a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "alphabets = \" \"\n",
    "for i in string :\n",
    "    if i.isalpha() :\n",
    "        alphabets += i\n",
    "print(\"Extracted alphabets from string are\", alphabets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "eafcfc3a-7738-4202-9ac2-901d54216fed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of uppercase letters in the string are 3\n"
     ]
    }
   ],
   "source": [
    "'''Q26 Count the number of uppercase letters in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "count = 0\n",
    "for i in string :\n",
    "    if i.isupper() :\n",
    "        count += 1\n",
    "print(\"The number of uppercase letters in the string are\", count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5e9b1500-157e-44c3-9198-13ad6441bf5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of lowercase letters in the string are 17\n"
     ]
    }
   ],
   "source": [
    "'''Q27 Count the number of lowercase letters in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "count = 0\n",
    "for i in string :\n",
    "    if i.islower() :\n",
    "        count += 1\n",
    "print(\"The number of lowercase letters in the string are\", count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cc93799e-603b-4bd8-847d-4c806f07a649",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swapped case string is mY NAME IS aKSHAT sAXENA .\n"
     ]
    }
   ],
   "source": [
    "'''Q28 Swap the case of each character in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "new_string = \"\"\n",
    "for i in string :\n",
    "    new_string += i.swapcase()\n",
    "print(\"Swapped case string is\", new_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e3581dc6-aeb2-4def-8a1a-59550c78e244",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n",
      "Enter a word to be removed : ym\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter valid word to be removed\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a word to be removed : Ak\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter valid word to be removed\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a word to be removed : Akshat\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after removing specific word is My name is Saxena . \n"
     ]
    }
   ],
   "source": [
    "'''Q29 Remove a specific word from a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "new_string = \"\"\n",
    "a = True\n",
    "while a :\n",
    "    word = input(\"Enter a word to be removed :\")\n",
    "    if word in string.split() :\n",
    "        a = False\n",
    "    else :\n",
    "        print(\"Enter valid word to be removed\")\n",
    "s = string.split()\n",
    "for i in s :\n",
    "    if i != word :\n",
    "        new_string += i\n",
    "        new_string += \" \"\n",
    "print(\"String after removing specific word is\", new_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "15c26847-2b9e-4193-ac1b-c5fb2c24532f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "email_1 is  valid email\n",
      "email_2 is  invalid email\n"
     ]
    }
   ],
   "source": [
    "'''Q30 Check if a string is a valid email address.'''\n",
    "\n",
    "import re\n",
    "\n",
    "def check_valid_email(email) :\n",
    "    regular_pattern = r'\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,7}\\b'\n",
    "    if re.match(regular_pattern , email) :\n",
    "        return \"valid email\"\n",
    "    else :\n",
    "        return \"invalid email\"\n",
    "\n",
    "email_1 = \"hello@email.com\"\n",
    "email_2 = \"invalid*email\"\n",
    "output_1 = check_valid_email(email_1)\n",
    "output_2 = check_valid_email(email_2)\n",
    "print(\"email_1 is \", output_1)\n",
    "print(\"email_2 is \", output_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "529a52e0-bd8a-4a0f-8526-5a478615ecd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a email address : akshat@email.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Username is  akshat\n"
     ]
    }
   ],
   "source": [
    "'''Q31 Extract the username from an email address string.'''\n",
    "\n",
    "\n",
    "def extract_username(e):\n",
    "    u = e.split(\"@\")[0]\n",
    "    return u\n",
    "\n",
    "email = input(\"Enter a email address :\")\n",
    "username = extract_username(email)\n",
    "print(\"Username is \", username)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a66d792b-401a-4038-8f03-1aa23547822c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a email address : akshat@email.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Domain name is  email.com\n"
     ]
    }
   ],
   "source": [
    "'''Q32 Extract the domain name from an email address string.'''\n",
    "\n",
    "def extract_domain_name(e):\n",
    "    d = e.split(\"@\")[1]\n",
    "    return d\n",
    "\n",
    "email = input(\"Enter a email address :\")\n",
    "domain_name = extract_domain_name(email)\n",
    "print(\"Domain name is \", domain_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "39143762-37ab-4de8-a9d7-38e57fb00e6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string :   akshat hello    how  are you    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String after replacing multiple spaces is  akshat hello how are you\n"
     ]
    }
   ],
   "source": [
    "'''Q33 Replace multiple spaces in a string with a single space.'''\n",
    "\n",
    "def replace_multiple_spaces(s) :\n",
    "    new_string = \" \".join(s.split())\n",
    "    return new_string\n",
    "    \n",
    "string = input(\"Enter a string :\") # \"  akshat hello    how  are you    \"\n",
    "output = replace_multiple_spaces(string)\n",
    "print(\"String after replacing multiple spaces is \",output)          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ec89401c-7b81-4623-b81b-e26d6e65178c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "url_1 is  True\n",
      "url_2 is  False\n"
     ]
    }
   ],
   "source": [
    "'''Q34 Check if a string is a valid URL.'''\n",
    "\n",
    "from urllib.parse import urlparse\n",
    "def check_valid_url(url):\n",
    "    try :\n",
    "        result = urlparse(url)\n",
    "        return all([result.scheme, result.netloc])\n",
    "    except ValueError :\n",
    "        return False\n",
    "\n",
    "url_1 = \"https://www.youtube.com/\"\n",
    "url_2 = \"invalid*url\"\n",
    "output_1 = check_valid_url(url_1)\n",
    "output_2 = check_valid_url(url_2)\n",
    "print(\"url_1 is \", output_1)\n",
    "print(\"url_2 is \", output_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f5d324a1-6089-4731-81f1-8afccbe6d6fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st url : http://www.hello.com\n",
      "Enter 2nd url : ftp://ftp.game.com\n",
      "Enter 3rd url : https://youtube.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Protocol 1 is  http\n",
      "Protocol 2 is  ftp\n",
      "Protocol 3 is  https\n"
     ]
    }
   ],
   "source": [
    "'''Q35 Extract the protocol (http or https) from a URL string.'''\n",
    "\n",
    "def extract_protocol(url) :\n",
    "    index = url.find(\"://\")\n",
    "    if index != -1 :\n",
    "        return url[:index]\n",
    "    else :\n",
    "        return \"No protocol\"\n",
    "            \n",
    "url_1 = input(\"Enter 1st url :\")\n",
    "url_2 = input(\"Enter 2nd url :\")\n",
    "url_3 = input(\"Enter 3rd url :\")\n",
    "\n",
    "protocol_1 = extract_protocol(url_1)\n",
    "protocol_2 = extract_protocol(url_2)\n",
    "protocol_3 = extract_protocol(url_3)\n",
    "\n",
    "print(\"Protocol 1 is \",protocol_1)\n",
    "print(\"Protocol 2 is \",protocol_2)\n",
    "print(\"Protocol 3 is \",protocol_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8497f0b4-b22e-4f93-a78c-773e48472cb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : helloworld\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency of  h : 1\n",
      "Frequency of  e : 1\n",
      "Frequency of  l : 3\n",
      "Frequency of  o : 2\n",
      "Frequency of  w : 1\n",
      "Frequency of  r : 1\n",
      "Frequency of  d : 1\n"
     ]
    }
   ],
   "source": [
    "'''Q36 Find the frequency of each character in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "new_string = \"\"\n",
    "dictionary = {}\n",
    "for i in string :\n",
    "    if i not in new_string :\n",
    "        dictionary[i] = 1\n",
    "        new_string += i\n",
    "    else :\n",
    "        dictionary.update({i : dictionary[i] + 1})\n",
    "for i , k in dictionary.items() :\n",
    "    print(\"Frequency of \", i ,\":\" , k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "77551fd1-a0fe-434b-8054-9787f160a64d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Hello, Rahul! What's up?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string : Hello, Rahul! What's up?\n",
      "Cleaned string : Hello Rahul Whats up\n"
     ]
    }
   ],
   "source": [
    "'''Q37 Remove all punctuation from a string.'''\n",
    "\n",
    "import string\n",
    "def remove_puntuations(input_string) :\n",
    "    translator = str.maketrans(\"\",\"\",string.punctuation)\n",
    "    clean_string = input_string.translate(translator)\n",
    "    return clean_string\n",
    "    \n",
    "input_string = input(\"Enter a string :\")\n",
    "cleaned_string = remove_puntuations(input_string)\n",
    "print(\"Original string :\",input_string)\n",
    "print(\"Cleaned string :\",cleaned_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "13ff7764-9255-4cc8-90f5-cf0826ea7b59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : 12345\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String contains only digits\n"
     ]
    }
   ],
   "source": [
    "'''Q38 Check if a string contains only digits.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "if string.isdigit() :\n",
    "    print(\"String contains only digits\")\n",
    "else :\n",
    "    print(\"String does not contains only digits\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5d313272-7f86-49e1-ae5f-78f5ecb0a9ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String does not contains only alphabets\n"
     ]
    }
   ],
   "source": [
    "'''Q39 Check if a string contains only alphabets.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "if string.isalpha() :\n",
    "    print(\"String contains only alphabets\")\n",
    "else :\n",
    "    print(\"String does not contains only alphabets\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c02d93b9-72b5-4bd0-b299-a1f268f35dfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted string to a list of characters : ['M', 'y', ' ', 'n', 'a', 'm', 'e', ' ', 'i', 's', ' ', 'A', 'k', 's', 'h', 'a', 't', ' ', 'S', 'a', 'x', 'e', 'n', 'a', ' ', '.']\n"
     ]
    }
   ],
   "source": [
    "'''Q40 Convert a string to a list of characters.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "convert = list(string)\n",
    "print(\"Converted string to a list of characters :\",convert)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "555b1507-ed4e-459f-acf8-d774f80ae481",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st string : bored\n",
      "Enter 2nd string : robed\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both strings are amagrams\n"
     ]
    }
   ],
   "source": [
    "''' Q41 Check if two strings are anagrams.'''\n",
    "\n",
    "string_1 = input(\"Enter 1st string :\") #worth\n",
    "string_2 = input(\"Enter 2nd string :\") #throw\n",
    "new_string1 = \"\"\n",
    "new_string2 = \"\"\n",
    "dictionary_1 = {}\n",
    "dictionary_2 = {}\n",
    "\n",
    "#Checking 1st string\n",
    "for i in string_1 :\n",
    "    if i not in new_string1 :\n",
    "        dictionary_1[i] = 1\n",
    "        new_string1 += i\n",
    "    else :\n",
    "        dictionary_1.update({i : dictionary_1[i] + 1})\n",
    "        \n",
    "#Checking 2nd string\n",
    "for i in string_2 :\n",
    "    if i not in new_string2 :\n",
    "        dictionary_2[i] = 1\n",
    "        new_string2 += i\n",
    "    else :\n",
    "        dictionary_2.update({i : dictionary_2[i] + 1})\n",
    "        \n",
    "#Comparing both dictionaries\n",
    "if dictionary_1 == dictionary_2 :\n",
    "    print(\"Both strings are amagrams\")\n",
    "else :\n",
    "    print(\"Bothe strings are not amagrams\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e9668f1b-a941-40bf-8ae2-0126a501eab8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string to encode : Akshat Saxena\n",
      "Enter shift value for encoding : 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoded text : wmujcvvoczgpc\n"
     ]
    }
   ],
   "source": [
    "'''Q42 Encode a string using a Caesar cipher.'''\n",
    "\n",
    "#defining function Caesar_cipher\n",
    "def Caesar_cipher(text , shift) :\n",
    "    encoded_text = \"\"\n",
    "    for char in text :\n",
    "        if char.isalpha() :\n",
    "            encoded_char = chr((ord(char) + shift - ord('a')) % 26 + ord('a'))\n",
    "        else :\n",
    "            encode_char = char\n",
    "        \n",
    "        encoded_text += encoded_char\n",
    "    \n",
    "    return encoded_text\n",
    "    \n",
    "#Defining the input text and shift value for encoding\n",
    "string = input(\"Enter a string to encode :\")\n",
    "shift = int(input(\"Enter shift value for encoding :\"))\n",
    "\n",
    "#Calling function Caesar_cipher\n",
    "encoded_text = Caesar_cipher(string , shift)\n",
    "            \n",
    "#Printing the encoded text\n",
    "print(\"Encoded text :\", encoded_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ef2ad960-bb13-4c9b-91dc-af6da45a45b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string to decode : hello how are you\n",
      "Enter shift value for decoding : 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoded text : fcjjm fmu ypc wms\n"
     ]
    }
   ],
   "source": [
    "'''Q43 Decode a Caesar cipher encoded string.'''\n",
    "\n",
    "#Defining function Caesar_cipher_decode\n",
    "def Caesar_cipher_decode(text , shift) :\n",
    "    decoded_text = \"\"\n",
    "    for char in text :\n",
    "        if char.isalpha() :\n",
    "            decoded_char = chr((ord(char) - shift - ord('a')) % 26 + ord('a'))\n",
    "        else :\n",
    "            decoded_char = char\n",
    "        \n",
    "        decoded_text += decoded_char\n",
    "        \n",
    "    return decoded_text\n",
    "\n",
    "\n",
    "#defining input text and shift value for decoding\n",
    "string = input(\"Enter a string to decode :\")\n",
    "shift = int(input(\"Enter shift value for decoding :\"))\n",
    "\n",
    "#Calling function Caesar_cipher_decode\n",
    "decoded_text = Caesar_cipher_decode(string , shift)\n",
    "\n",
    "#Printing the decoded text\n",
    "print(\"Decoded text :\", decoded_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8bd184b8-d142-49a6-baa1-1aa8bf6771f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Hello world Let's play world Go world\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most frequent word is  world  with  3 times repetition\n"
     ]
    }
   ],
   "source": [
    "'''Q44 Find the most frequent word in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "arrange_words = string.split()\n",
    "frequency = {}\n",
    "for i in arrange_words :\n",
    "    if i in frequency :\n",
    "        frequency[i] += 1\n",
    "    else :\n",
    "        frequency[i] = 1\n",
    "\n",
    "frequent = max(frequency.values())\n",
    "for i in frequency :\n",
    "    if frequency[i] == frequent :\n",
    "        print(\"Most frequent word is \", i ,\" with \", frequent ,\"times repetition\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "923944c8-7471-4395-89a1-c642d33642ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : I felt happy because I saw the others were happy and because I knew I should feel happy, but I wasn't really happy.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All unique words in string are :\n",
      "felt\n",
      "the\n",
      "feel\n",
      "others\n",
      "were\n",
      "really\n",
      "saw\n",
      "because\n",
      "happy,\n",
      "wasn't\n",
      "and\n",
      "but\n",
      "happy.\n",
      "I\n",
      "knew\n",
      "happy\n",
      "should\n"
     ]
    }
   ],
   "source": [
    "'''Q45 Find all unique words in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "arrange_words = string.split()\n",
    "unique_words = set()\n",
    "for i in arrange_words :\n",
    "    unique_words.add(i)\n",
    "    \n",
    "print(\"All unique words in string are :\")\n",
    "for i in unique_words :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "38e344d5-36f1-4fa8-818a-d45e4de47d0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st string : Mat\n",
      "Enter 2nd string : Game\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of syllables in the Mat  are  1\n",
      "The number of syllables in the  Game are   2\n"
     ]
    }
   ],
   "source": [
    "'''Q46 Count the number of syllables in a string.'''\n",
    "\n",
    "def syllables(string) :\n",
    "    arrange_words = string.split()\n",
    "    count = 0\n",
    "    for word in arrange_words :\n",
    "        for char in word :\n",
    "            if char in [\"a\",\"e\",\"i\",\"o\",\"u\",\"A\",\"E\",\"I\",\"O\",\"U\"] :\n",
    "                count += 1\n",
    "    return count\n",
    "string1 = input(\"Enter 1st string :\")\n",
    "string2 = input(\"Enter 2nd string :\")\n",
    "\n",
    "syllable_1 = syllables(string1)\n",
    "syllable_2 = syllables(string2)\n",
    "\n",
    "\n",
    "print(\"The number of syllables in the\", string1, \" are \", syllable_1)\n",
    "print(\"The number of syllables in the \", string2, \"are  \", syllable_2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ccff22f8-2f06-42ce-afef-2b0764b1c44b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st string : Hello! How are you?\n",
      "Enter 2nd string : Let's go! It's showtime .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Hello! How are you?' contains special characters: True\n",
      "'Let's go! It's showtime .' contains special characters: True\n"
     ]
    }
   ],
   "source": [
    "'''Q47 Check if a string contains any special characters.'''\n",
    "\n",
    "import re\n",
    "\n",
    "def check_special_characters(string) :\n",
    "    pattern = re.compile(r'[!@#$%^&*()_+{}\\[\\]:;<>,.?~\\\\/]')\n",
    "    match = pattern.search(string)\n",
    "    return bool(match)\n",
    "\n",
    "string_1 = input(\"Enter 1st string :\")\n",
    "string_2 = input(\"Enter 2nd string :\")\n",
    "\n",
    "result_1 = check_special_characters(string_1)\n",
    "result_2 = check_special_characters(string_2)\n",
    "\n",
    "print(f\"'{string_1}' contains special characters:\", result_1)\n",
    "print(f\"'{string_2}' contains special characters:\", result_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "dbe4674b-a5fa-4c9e-829d-63b57fb62109",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Please bring your books with you to every class.\n",
      "Enter nth word to be removed : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string : Please bring your books with you to every class.\n",
      "Cleaned string : Please bring books with you to every class.\n",
      "Removed word : your\n"
     ]
    }
   ],
   "source": [
    "'''Q48 Remove the nth word from a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "nth_value = int(input(\"Enter nth word to be removed :\"))\n",
    "arrange_words = string.split()\n",
    "if nth_value >=1 and nth_value <= len(arrange_words) :\n",
    "    removed_word = arrange_words.pop(nth_value-1)\n",
    "    cleaned_string = \" \".join(arrange_words)\n",
    "print(\"Original string :\", string)\n",
    "print(\"Cleaned string :\", cleaned_string)\n",
    "print(\"Removed word :\", removed_word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c2455fff-7162-40ed-98dd-f7f1fb34b222",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : Please bring books with you to every class.\n",
      "Enter nth value to insert word : 3\n",
      "Enter word to be inserted : your\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string : Please bring books with you to every class.\n",
      "Cleaned string : Please bring your books with you to every class.\n"
     ]
    }
   ],
   "source": [
    "'''Q49 Insert a word at the nth position in a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "nth_value = int(input(\"Enter nth value to insert word :\"))\n",
    "word = input(\"Enter word to be inserted :\")\n",
    "arrange_words = string.split()\n",
    "if nth_value >=1 and nth_value <= len(arrange_words) :\n",
    "    arrange_words.insert(nth_value - 1 , word)\n",
    "    cleaned_string = \" \".join(arrange_words)\n",
    "print(\"Original string :\", string)\n",
    "print(\"Cleaned string :\", cleaned_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "94354e0b-a2ad-419b-a4f7-8b2e9a2603aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Roll No.', ' Name', ' Marks']\n",
      "['01', ' Rahul', ' 79']\n",
      "['02', ' Sonu', ' 89']\n"
     ]
    }
   ],
   "source": [
    "'''Q50 Convert a CSV string to a list of lists.'''\n",
    "\n",
    "def csv_string_list(string) :\n",
    "    new_list = []\n",
    "    lines = string.split(\"\\n\")\n",
    "    for line in lines:\n",
    "        fields = line.split(\",\")\n",
    "        new_list.append(fields)\n",
    "\n",
    "    return new_list\n",
    "\n",
    "string = \"Roll No., Name, Marks\\n01, Rahul, 79\\n02, Sonu, 89\"\n",
    "list_of_lists = csv_string_list(string)\n",
    "\n",
    "for row in list_of_lists :\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb159973-8761-45ee-8cbf-9d90de0c3167",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "db11c703-2c52-4394-95db-872ddf75addd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List based practice problem "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "361eb64a-da79-44c5-902f-c8b3be570a80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "'''Q1 Create a list with integers from 1 to 10.'''\n",
    "\n",
    "lst = []\n",
    "for i in range(1,11) :\n",
    "    lst.append(i)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ef9a5606-c1b3-4110-aaf7-79cd3d52dd4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [2,4,6,8,10,12]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of list provided : 6\n"
     ]
    }
   ],
   "source": [
    "'''Q2 Find the length of a list without using the `len()` function.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "count = 0\n",
    "for i in lst :\n",
    "    count += 1\n",
    "print(\"Length of list provided :\", count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3faba0c3-028c-4e1e-9fad-f88a7ce810a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,3,5,7,9,11]\n",
      "Enter a element to be appended : 13\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after updation : [1, 3, 5, 7, 9, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "'''Q3 Append an element to the end of a list. '''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "element = int(input(\"Enter a element to be appended :\"))\n",
    "lst.append(element)\n",
    "print(\"List after updation :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "30d86c23-8003-4bfa-a1dd-e7d58055b93b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,5,6,7,8,9,10]\n",
      "Enter a element to be inserted : 4\n",
      "Enter index to insert element : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after updation : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "'''Q4 Insert an element at a specific index in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "element = int(input(\"Enter a element to be inserted :\"))\n",
    "index = int(input(\"Enter index to insert element :\"))\n",
    "lst.insert(index , element)\n",
    "print(\"List after updation :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e5687729-e804-4e42-accb-2d47075cb489",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [2,4,5,6,8,10,12]\n",
      "Enter element to be removed : 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after updation : [2, 4, 6, 8, 10, 12]\n"
     ]
    }
   ],
   "source": [
    "'''Q5 Remove an element from a list by its value.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "element = eval(input(\"Enter element to be removed :\"))\n",
    "lst.remove(element)\n",
    "print(\"List after updation :\",lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1d56473d-e083-4b87-80ba-761aecb89f4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,3,5,7,8,9,11]\n",
      "Enter index of element to be removed : 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after updation : [1, 3, 5, 7, 9, 11]\n"
     ]
    }
   ],
   "source": [
    "'''Q6 Remove an element from a list by its index.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "index = int(input(\"Enter index of element to be removed :\"))\n",
    "lst.pop(index)\n",
    "print(\"List after updation :\",lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "61ec04eb-77f8-4cf8-9c01-4ee7bb9a7273",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n",
      "Enter element to check it's existence in list : 7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 exists in list\n"
     ]
    }
   ],
   "source": [
    "'''Q7 Check if an element exists in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "element = eval(input(\"Enter element to check it's existence in list :\"))\n",
    "if element in lst :\n",
    "    print(element ,\"exists in list\")\n",
    "else :\n",
    "    print(element ,\"does not exist in list\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ea39cb36-32d1-4f6c-961b-b3bdf0e2deab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"pw\",\"skills\",\"wallah\",\"game\",\"akshat\",\"saxena\",\"skills\",\"game\",\"hi\"]\n",
      "Enter element to find it's index : \"game\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index of game : 3\n"
     ]
    }
   ],
   "source": [
    "'''Q8 Find the index of the first occurrence of an element in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "element = eval(input(\"Enter element to find it's index :\"))\n",
    "index = lst.index(element)\n",
    "print(f\"index of {element} : {index}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5c99d999-3f2f-4ed8-bc7f-17f7d25ccf35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"pw\",\"skills\",\"wallah\",\"game\",\"akshat\",\"saxena\",\"skills\",\"game\",\"hi\"]\n",
      "Enter element to count it's number of occurence : \"game\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of occurence of game : 2\n"
     ]
    }
   ],
   "source": [
    "'''Q9 Count the occurrences of an element in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "element = eval(input(\"Enter element to count it's number of occurence :\"))\n",
    "count = lst.count(element)\n",
    "print(f\"Number of occurence of {element} : {count}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2d288267-448c-4e2a-946b-8fadeb3ce336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"pw\",\"skills\",\"wallah\",\"game\",\"akshat\",\"saxena\",\"skills\",\"game\",\"hi\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed list ['hi', 'game', 'skills', 'saxena', 'akshat', 'game', 'wallah', 'skills', 'pw']\n"
     ]
    }
   ],
   "source": [
    "''' Q10 Reverse the order of elements in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "lst.reverse()\n",
    "print(f\"Reversed list {lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "68d1d9ee-3dcf-431d-b611-ce0870798a1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [4,3,10,6,8,7,5,1,2,9]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List in ascending order : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "'''Q11 Sort a list in ascending order.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "lst.sort()\n",
    "print(f\"List in ascending order : {lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "17b5b773-2f33-4fb6-8a8e-d5cdd6c6f1cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [4,3,10,6,8,7,5,1,2,9]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List in ascending order : [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "'''Q12 Sort a list in descending order.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "lst.sort(reverse=True)\n",
    "print(f\"List in ascending order : {lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5424d6e8-6eaa-45e3-9508-aa1ce9dba10f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of even numbers from 1 to 20 : [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n"
     ]
    }
   ],
   "source": [
    "'''Q13 Create a list of even numbers from 1 to 20.'''\n",
    "\n",
    "lst = []\n",
    "for i in range(1,21) :\n",
    "    if i%2 == 0 :\n",
    "        lst.append(i)\n",
    "print(\"List of even numbers from 1 to 20 :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8d4cb0cf-2bb1-40d7-a8df-714f42f31167",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of odd numbers from 1 to 20 : [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "'''Q14 Create a list of odd numbers from 1 to 20.'''\n",
    "\n",
    "lst = []\n",
    "for i in range(1,21) :\n",
    "    if i%2 != 0 :\n",
    "        lst.append(i)\n",
    "print(\"List of odd numbers from 1 to 20 :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6dbc0c25-e18d-4851-a75c-b97f59b66c1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all elements of list : 55\n"
     ]
    }
   ],
   "source": [
    "'''Q15 Find the sum of all elements in a list.'''\n",
    "\n",
    "from functools import reduce \n",
    "\n",
    "sum = 0\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "sum_element = reduce(lambda a,b : a + b , lst)\n",
    "print(\"Sum of all elements of list :\", sum_element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "033e730f-105c-4ca4-91b7-fcf98172e151",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value in  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] : 10\n"
     ]
    }
   ],
   "source": [
    "'''Q16 Find the maximum value in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "max_value = max(lst)\n",
    "print(\"Maximum value in \", lst ,\":\", max_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "00214459-1c68-4d72-b3fa-7062f628ca46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value in  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] : 1\n"
     ]
    }
   ],
   "source": [
    "'''Q17 Find the minimum value in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "min_value = min(lst)\n",
    "print(\"Minimum value in \", lst ,\":\", min_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ce533123-e3fd-4273-8dfa-fe9621a4eb16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list from 1 to 10 : [1,2,3,4,5,6,7,8,9,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of squares of numbers from 1 to 10 : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "'''Q18 Create a list of squares of numbers from 1 to 10.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list from 1 to 10 :\"))\n",
    "squares_list = list(map(lambda i : i**2 , lst))\n",
    "print(\"List of squares of numbers from 1 to 10 :\", squares_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d28fde8e-1b12-48c6-89f1-204a96a65218",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of random numbers : [40, 706, 801, 52, 341, 633, 161, 158, 35, 88]\n"
     ]
    }
   ],
   "source": [
    "'''Q19 Create a list of random numbers.'''\n",
    "\n",
    "import random\n",
    "\n",
    "lst =[]\n",
    "for i in range(10) :\n",
    "    lst += [random.randint(1,1001)]\n",
    "print(\"List of random numbers :\",lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3691e3af-782d-4792-a6c3-469b43f50733",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list with duplicate elements : [2,3,4,5,5,5,2,6,7,2,1,4,5,6,8]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with duplicate elements removed : [1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "'''Q20 Remove duplicates from a list.'''\n",
    "\n",
    "s = set()\n",
    "lst = eval(input(\"Enter a list with duplicate elements :\"))\n",
    "for i in lst :\n",
    "    s.add(i)\n",
    "print(\"List with duplicate elements removed :\", list(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3a3c08e3-f94d-44e4-90fb-8c6a953451c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st list : [1,2,4,6,4,8,9,30,26]\n",
      "Enter 2nd list : [26,33,56,6,4,7]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements between two lists :\n",
      "4\n",
      "6\n",
      "26\n"
     ]
    }
   ],
   "source": [
    "'''Q21 Find the common elements between two lists.'''\n",
    "\n",
    "lst_1 = eval(input(\"Enter 1st list :\"))\n",
    "lst_2 = eval(input(\"Enter 2nd list :\"))\n",
    "new_lst = []\n",
    "print(\"Common elements between two lists :\")\n",
    "for i in lst_1 :\n",
    "    for j in lst_2 :\n",
    "        if i == j :\n",
    "            if i in new_lst :\n",
    "                continue\n",
    "            else :\n",
    "                new_lst.append(i)\n",
    "if len(new_lst) == 0 :\n",
    "    print(\"No element is common\")\n",
    "for i in new_lst :\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "34629646-2951-4aee-aa6f-ac9328fd86b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st list : [\"Tokyo\",\"Berlin\",\"Paris\",\"Rio\"]\n",
      "Enter 2nd list : [\"Berlin\",\"India\",\"Rio\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference between both list : ['Tokyo', 'Paris']\n"
     ]
    }
   ],
   "source": [
    "'''Q22 Find the difference between two lists.'''\n",
    "\n",
    "lst_1 = eval(input(\"Enter 1st list :\"))\n",
    "lst_2 = eval(input(\"Enter 2nd list :\"))\n",
    "difference = list(set(lst_1).difference(lst_2))\n",
    "print(\"Difference between both list :\", difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9af98879-4dec-42cc-906e-384138b1cb86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st list : [\"Tokyo\",\"Berlin\",\"Paris\",\"Rio\"]\n",
      "Enter 2nd list : [\"Berlin\",\"India\",\"Rio\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New list after merging to lists : ['Tokyo', 'Berlin', 'Paris', 'Rio', 'Berlin', 'India', 'Rio']\n"
     ]
    }
   ],
   "source": [
    "'''Q23 Merge two lists.'''\n",
    "\n",
    "lst_1 = eval(input(\"Enter 1st list :\"))\n",
    "lst_2 = eval(input(\"Enter 2nd list :\"))\n",
    "merge_lst = lst_1 + lst_2\n",
    "print(\"New list after merging to lists :\", merge_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c1105a3a-e6cd-4b1a-bd1b-18a7b189d3a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"Tokyo\",\"Berlin\",\"Paris\",\"Rio\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after multiplying all elements by 2 : ['TokyoTokyo', 'BerlinBerlin', 'ParisParis', 'RioRio']\n"
     ]
    }
   ],
   "source": [
    "'''Q24 Multiply all elements in a list by 2.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "new_list = list(map(lambda i : i*2 , lst))\n",
    "print(\"List after multiplying all elements by 2 :\", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1231b100-eee8-4bc2-8463-0ca80005d1d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list which contains numbers : [1,2,5,8,10,45,36,79,50,35,4]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All even numbers in list : [2, 8, 10, 36, 50, 4]\n"
     ]
    }
   ],
   "source": [
    "'''Q25 Filter out all even numbers from a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list which contains numbers :\"))\n",
    "even_lst = list(filter(lambda i : i%2 == 0 , lst))\n",
    "print(\"All even numbers in list :\", even_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0a5ba40d-1f8c-4263-9431-437f8f77f9c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list of strings : [\"10\",\"30\",\"2\",\"5\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of integers : [10, 30, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "'''Q26 Convert a list of strings to a list of integers.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list of strings :\"))\n",
    "integer_lst = list(map(lambda i : int(i) , lst))\n",
    "print(\"List of integers :\", integer_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c5c031e6-a3b0-459b-bcda-2bb5c9f48ed7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list of integers : [10, 30, 2, 5]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of strings : ['10', '30', '2', '5']\n"
     ]
    }
   ],
   "source": [
    "'''Q27 Convert a list of integers to a list of strings.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list of integers :\"))\n",
    "string_lst = list(map(lambda i : str(i) , lst))\n",
    "print(\"List of strings :\", string_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "93b6b22c-4fe3-4173-9d5d-092858c9f980",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a nested list : [[2,3,4],6,[7,9,10],[8,12,14]]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened nested list : [2, 3, 4, 6, 7, 9, 10, 8, 12, 14]\n"
     ]
    }
   ],
   "source": [
    "'''Q28 Flatten a nested list.'''\n",
    "\n",
    "nested_lst = eval(input(\"Enter a nested list :\"))\n",
    "flatten_lst = []\n",
    "for lst in nested_lst :\n",
    "    if type(lst) != type([]) :\n",
    "        flatten_lst.append(lst)\n",
    "        continue\n",
    "    for element in lst :\n",
    "        flatten_lst.append(element)\n",
    "print(\"Flattened nested list :\", flatten_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "69f37c1f-e2ce-4637-8e2c-a5d05ebda5d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of fibnacci numbers you want : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first  10 Fibnacci numbers : [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "'''Q29 Create a list of the first 10 Fibonacci numbers.'''\n",
    "\n",
    "def fib_num(n) :\n",
    "    lst = [0,1]\n",
    "    for i in range(2,n) :\n",
    "        next_fib_num = lst[i-1] + lst[i-2]\n",
    "        lst.append(next_fib_num)\n",
    "    return lst\n",
    "\n",
    "n = int(input(\"Enter number of fibnacci numbers you want :\"))\n",
    "lst = fib_num(n)\n",
    "print(\"List of the first \",n ,\"Fibnacci numbers :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "88b1e42a-701c-4342-aa81-9e65cd9d9d87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,4,7,8]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List is sorted in ascending order\n"
     ]
    }
   ],
   "source": [
    "'''Q30 Check if a list is sorted.'''\n",
    "\n",
    "def check_lst_sorted(lst) :\n",
    "    for i in range(1,len(lst)) :\n",
    "        if lst[i] < lst[i-1] :\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "if check_lst_sorted(lst) :\n",
    "    print(\"List is sorted in ascending order\")\n",
    "else :\n",
    "    print(\"List is not sorted in ascending order\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "8b527433-bdd3-4e52-9a7e-b6ebb63f8d48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [3,4,5,6,7,8,9,10,1,2,11]\n",
      "Enter number of positions to rotate list to the left : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List rotated to left by 3 positions : [6, 7, 8, 9, 10, 1, 2, 11, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "'''Q31 Rotate a list to the left by `n` positions.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "n = int(input(\"Enter number of positions to rotate list to the left :\"))\n",
    "rotated_lst = lst[n:] + lst[0:n]\n",
    "print(f\"List rotated to left by {n} positions : {rotated_lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3f8c81e4-18b7-4616-89ea-c59e2c0d7294",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [3,4,5,6,7,8,9,10,1,2,11]\n",
      "Enter number of positions to rotate list to the right : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List rotated to right by 3 positions : [11, 2, 1, 10, 9, 8, 7, 6, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "'''Q32 Rotate a list to the right by `n` positions.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "n = int(input(\"Enter number of positions to rotate list to the right :\"))\n",
    "rotated_lst = lst[:n-1:-1] + lst[0:n]\n",
    "print(f\"List rotated to right by {n} positions : {rotated_lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b365f6cd-c660-4872-94e9-9761233f6868",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime numbers upto 50 : \n",
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "'''Q33 Create a list of prime numbers up to 50.'''\n",
    "\n",
    "#defining function prime_num()\n",
    "def prime_num() :\n",
    "    #crating empty list for storing prime numbers\n",
    "    lst = []     \n",
    "    #giving range 1 to 40 as formula to calculate prime numbers is valid till 40\n",
    "    for i in range(1,41) :\n",
    "        #checking for 1 and negative numbers\n",
    "        if i<=1 :\n",
    "            continue\n",
    "        #checking for numbers 2 and 3\n",
    "        elif i<=3 :\n",
    "            #adding prime numbers to list\n",
    "            lst.append(i)\n",
    "            continue\n",
    "        #checking for left numbers\n",
    "        elif i in (4,51) :\n",
    "            #given this range as formula is applicable on this only\n",
    "            for j in range(1,10) :\n",
    "                #formula 1\n",
    "                p_1 = (6*j) - 1\n",
    "                #formula 2\n",
    "                p_2 = (6*j) + 1\n",
    "                #ignoring exceptions in formula\n",
    "                if p_1 not in (25,35,49,53,55) :\n",
    "                    #adding prime numbers to list \n",
    "                    lst.append(p_1)\n",
    "                #ignoring exceptions in formula\n",
    "                if p_2 not in (25,35,49,53,55) :\n",
    "                    #adding elements to list\n",
    "                    lst.append(p_2)\n",
    "    #returning list of prime numbers upto 50\n",
    "    return lst\n",
    "\n",
    "#initializing n = 50\n",
    "n = 50\n",
    "#calling funcion pime_num()\n",
    "prime_num_lst = prime_num()\n",
    "#printing list of prime numbers upto 50\n",
    "print(f\"List of prime numbers upto {n} : \")\n",
    "print(prime_num_lst)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9ba46e06-e007-4962-8dae-1a3962d36360",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n",
      "Enter size into which you want to split list : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after splitting into chunks of 3 : [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]\n"
     ]
    }
   ],
   "source": [
    "'''Q34 Split a list into chunks of size `n`.'''\n",
    "\n",
    "def chunk_list(lst, n):\n",
    "    for i in range(0, len(lst), n):\n",
    "        yield lst[i:i + n]\n",
    "        \n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "n = int(input(\"Enter size into which you want to split list :\"))\n",
    "chunked_list = list(chunk_list(lst, n))\n",
    "\n",
    "print(f\"List after splitting into chunks of {n} : {chunked_list}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a8d7d5ca-b578-4c9d-9a0b-65e366073493",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [23,45,6,7,89,45,34,23,87,65,45,1,2,3,45,67]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second largest number in list : 87\n"
     ]
    }
   ],
   "source": [
    "'''Q35 Find the second largest number in a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "max_num_1 = max(lst)\n",
    "if max_num_1 in lst :\n",
    "    lst.remove(max_num_1)\n",
    "max_num_2 = max(lst)\n",
    "print(\"Second largest number in list :\", max_num_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "daf6c308-8bd1-4add-a2e9-396148d3f3f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Every element in list with its squares : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "'''Q36 Replace every element in a list with its square.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "square_lst = list(map(lambda i : i**2 , lst))\n",
    "print(\"Every element in list with its squares :\", square_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9f810644-9a24-4f88-987c-cd5719188e05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"Tokyo\",\"Berlin\",\"Rio\",\"Paris\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List converted to dictionary : {'Tokyo': 0, 'Berlin': 1, 'Rio': 2, 'Paris': 3}\n"
     ]
    }
   ],
   "source": [
    "'''Q37 Convert a list to a dictionary where list elements become keys and their\n",
    "indices become values.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "dictionary = dict()\n",
    "for i in range(len(lst)) :\n",
    "    dictionary[lst[i]] = i\n",
    "print(\"List converted to dictionary :\", dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "044dc3c3-573e-46b7-8e53-782c1c046f02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"Tokyo\",\"Berlin\",\"Rio\",\"Paris\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with shuffled elements : ['Paris', 'Tokyo', 'Berlin', 'Rio']\n"
     ]
    }
   ],
   "source": [
    "'''Q38 Shuffle the elements of a list randomly.'''\n",
    "\n",
    "import random \n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "random.shuffle(lst)\n",
    "print(\"List with shuffled elements :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fec35927-f1c6-4419-8e56-89caa99538d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of factorial numbers you want in a list (n - 1) : 9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of first -1 factorial numbers : [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "'''Q39 Create a list of the first 10 factorial numbers.'''\n",
    "\n",
    "def fact_lst(n) :\n",
    "    if n == 0 :\n",
    "        return 1\n",
    "    else :\n",
    "        return n*fact_lst(n-1)\n",
    "\n",
    "n = int(input(\"Enter number of factorial numbers you want in a list (n - 1) :\"))\n",
    "lst = []\n",
    "while n >= 0 :\n",
    "    element = fact_lst(n)\n",
    "    lst.append(element)\n",
    "    n -= 1\n",
    "lst.sort()\n",
    "print(f\"List of first {n} factorial numbers : {lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "027d70c2-373f-4200-99dc-da0ecfede655",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st list : [\"Tokyo\",\"Rio\",\"India\",\"Berlin\"]\n",
      "Enter 2nd list : [\"India\",\"Rio\",\"Paris\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Two lists have atleast one element in common \n"
     ]
    }
   ],
   "source": [
    "'''Q40 Check if two lists have at least one element in common.'''\n",
    "\n",
    "lst_1 = eval(input(\"Enter 1st list :\"))\n",
    "lst_2 = eval(input(\"Enter 2nd list :\"))\n",
    "new_lst = []\n",
    "for i in lst_1 :\n",
    "    for j in lst_2 :\n",
    "        if i == j :\n",
    "            if i in new_lst :\n",
    "                continue\n",
    "            else :\n",
    "                new_lst.append(i)\n",
    "if len(new_lst) == 0 :\n",
    "    print(\"No element is common\")\n",
    "else :\n",
    "    print(\"Two lists have atleast one element in common \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "03898207-7b22-4bb3-9b36-097afba0d505",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [\"Tokyo\",\"Rio\",\"India\",\"Berlin\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing all the elements : []\n"
     ]
    }
   ],
   "source": [
    "'''Q41 Remove all elements from a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "length = len(lst)\n",
    "for i in range(length) :\n",
    "    lst.pop()\n",
    "print(\"List after removing all the elements :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a6b7f722-08dd-4cdf-87b4-3063562f18a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [-2,56,-45,-3,3,4,-10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after updation : [0, 56, 0, 0, 3, 4, 0]\n"
     ]
    }
   ],
   "source": [
    "'''Q42 Replace negative numbers in a list with 0.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "for i in range(len(lst)) :\n",
    "    if lst[i] < 0 :\n",
    "        lst[i] = 0\n",
    "print(\"List after updation :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6168f27e-067c-4606-aec6-ed2f6a4ac057",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of string into a list of words : ['My', 'name', 'is', 'Akshat', 'Saxena', '.']\n"
     ]
    }
   ],
   "source": [
    "'''Q43 Convert a string into a list of words.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "lst = string.split()\n",
    "print(\"Conversion of string into a list of words :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5f8a0de6-3348-4de4-9c8b-4e0b3d2104f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list of words : ['My', 'name', 'is', 'Akshat', 'Saxena', '.']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of list of words into string : My name is Akshat Saxena .\n"
     ]
    }
   ],
   "source": [
    "'''Q44 Convert a list of words into a string.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list of words :\"))\n",
    "string = \" \".join(lst)\n",
    "print(\"Conversion of list of words into string :\",string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "399b7911-3e9e-4fc9-88ab-b196c8220685",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of powers of 2 list you want : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of first 10 powers of 2 : [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]\n"
     ]
    }
   ],
   "source": [
    "'''Q45 Create a list of the first `n` powers of 2.'''\n",
    "\n",
    "n = int(input(\"Enter number of powers of 2 list you want :\"))\n",
    "lst = []\n",
    "for i in range(n) :\n",
    "    lst.append(2**i)\n",
    "print(f\"List of first {n} powers of 2 : {lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9f5e8242-a372-44eb-8f27-5c45259482cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list of strings : [\"Tokyo\",\"Rio\",\"India\",\"Berlin\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest string in list of strings : Berlin\n"
     ]
    }
   ],
   "source": [
    "'''Q46 Find the longest string in a list of strings.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list of strings :\"))\n",
    "longest_string = max(list(map(lambda i : len(i) , lst)))\n",
    "for i in lst :\n",
    "    if len(i) == longest_string :\n",
    "        print(\"Longest string in list of strings :\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b2213ba1-a7d0-41af-86ce-9d05281a9dbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list of strings : [\"Tokyo\",\"Rio\",\"India\",\"Berlin\"]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest string in list of strings : Rio\n"
     ]
    }
   ],
   "source": [
    "'''Q47 Find the shortest string in a list of strings.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list of strings :\"))\n",
    "shortest_string = min(list(map(lambda i : len(i) , lst)))\n",
    "for i in lst :\n",
    "    if len(i) == shortest_string :\n",
    "        print(\"Shortest string in list of strings :\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "131703a9-e4d8-4847-aae4-a65bf3e283c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of first n triangular numbers you want : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 10 triangular numbers : [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]\n"
     ]
    }
   ],
   "source": [
    "'''Q48 Create a list of the first `n` triangular numbers.'''\n",
    "\n",
    "def triangular_numbers(n) :\n",
    "    return [i * (i+1) // 2 for i in range(1,n+1)]\n",
    "\n",
    "n = int(input(\"Enter number of first n triangular numbers you want :\"))\n",
    "lst = triangular_numbers(n)\n",
    "print(f\"List of the first {n} triangular numbers : {lst}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "38ab7090-1b26-434f-9339-695eed2db375",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n",
      "Enter another list : [2,6,9]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List ccontains another list as subsequence\n"
     ]
    }
   ],
   "source": [
    "'''Q49 Check if a list contains another list as a subsequence.'''\n",
    "\n",
    "def check_subsequence(lst , subsequence) :\n",
    "    index = 0\n",
    "    for i in lst :\n",
    "        if i == subsequence[index] :\n",
    "            index += 1\n",
    "            if index == len(subsequence) :\n",
    "                return True\n",
    "    return False\n",
    "            \n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))              \n",
    "subsequence = eval(input(\"Enter another list :\")) \n",
    "\n",
    "result = check_subsequence(lst,subsequence)\n",
    "if result :\n",
    "    print(\"List ccontains another list as subsequence\")\n",
    "else :\n",
    "    print(\"List does not contain another list as subsequence\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4a8c9580-0e00-48f5-bcef-4db21e30238e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,5,4,6,7,8,9,10]\n",
      "Enter element 1 to swap : 4\n",
      "Enter element 2 to swap : 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after updation : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "'''Q50 Swap two elements in a list by their indices.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "ele_1 = int(input(\"Enter element 1 to swap :\"))\n",
    "ele_2 = int(input(\"Enter element 2 to swap :\"))\n",
    "if ele_1 in lst and ele_2 in lst :\n",
    "    index_1 = lst.index(ele_1)\n",
    "    index_2 = lst.index(ele_2)\n",
    "lst[index_1] = ele_2\n",
    "lst[index_2] = ele_1\n",
    "print(\"List after updation :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba120b3-0d85-4823-a727-447f660dad46",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dc2dc64b-380b-40c4-b0d9-93f2af10299c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuple Based Practice Problem :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fc2374ea-5173-4001-aa6f-a0914d3bbcf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple containing integers from 1 to 5 : (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "'''Q1 Create a tuple with integers from 1 to 5.'''\n",
    "\n",
    "lst = []\n",
    "for i in range(1,6) :\n",
    "    lst.append(i)\n",
    "tup = tuple(lst)\n",
    "print(\"Tuple containing integers from 1 to 5 :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7cbefeeb-3ff9-4a6d-aead-efa957b4644e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5,6,7,8,9,10)\n",
      "Enter element number which you want to access : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element : 3\n"
     ]
    }
   ],
   "source": [
    "'''Q2 Access the third element of a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "index = int(input(\"Enter element number which you want to access :\"))\n",
    "element = tup[index-1]\n",
    "print(f\"Element : {element}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "85d0cd78-2e5c-4235-bd42-66faf082b60c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5,6,7,8,9,10)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of tuple : 10\n"
     ]
    }
   ],
   "source": [
    "'''Q3 Find the length of a tuple without using the `len()` function.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "count = 0\n",
    "for i in list(tup) :\n",
    "    count += 1\n",
    "print(\"Length of tuple :\", count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3b070bcc-4225-4ac9-9342-ec1943c7a5db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (\"Berlin\",\"Tokyo\",\"Paris\",\"Berlin\",\"Rio\",\"Berlin\")\n",
      "Enter element which you want to count occurrences : \"Berlin\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Occurrences of Berlin : 3\n"
     ]
    }
   ],
   "source": [
    "'''Q4 Count the occurrences of an element in a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "element = eval(input(\"Enter element which you want to count occurrences :\"))\n",
    "count = tup.count(element)\n",
    "print(f\"Occurrences of {element} : {count}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1d812c59-4c19-4cb1-9d3a-220c5a3cfe63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (\"Berlin\",\"Tokyo\",\"Paris\",\"Berlin\",\"Rio\",\"Berlin\")\n",
      "Enter element which you want to find first occurrence : \"Paris\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index of first occurrence of Paris : 2\n"
     ]
    }
   ],
   "source": [
    "'''Q5 Find the index of the first occurrence of an element in a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "element = eval(input(\"Enter element which you want to find first occurrence :\"))\n",
    "index = tup.index(element)\n",
    "print(f\"Index of first occurrence of {element} : {index}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3bbaeb1c-be96-4e44-9950-a322f33eddb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (\"Berlin\",\"Tokyo\",\"Paris\",\"Berlin\",\"Rio\",\"Berlin\")\n",
      "Enter element to check : \"Rio\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rio exists in tuple\n"
     ]
    }
   ],
   "source": [
    "'''Q6 Check if an element exists in a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "element = eval(input(\"Enter element to check :\"))\n",
    "if element in tup :\n",
    "    print(f\"{element} exists in tuple\")\n",
    "else :\n",
    "    print(f\"{element} does not exist in tuple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "7ee63b99-c90e-4a45-9d97-35ecdec4f278",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : ('Berlin', 'Tokyo', 'Paris', 'Berlin', 'Rio', 'Berlin')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of tuple to list  ['Berlin', 'Tokyo', 'Paris', 'Berlin', 'Rio', 'Berlin']\n"
     ]
    }
   ],
   "source": [
    "'''Q7 Convert a tuple to a list.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "lst_tup = list(tup)\n",
    "print(\"Conversion of tuple to list \", lst_tup) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "94a91604-5fc5-4c5c-88d2-a5019296ce4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : ['Berlin', 'Tokyo', 'Paris', 'Berlin', 'Rio', 'Berlin']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of list to tuple : ('Berlin', 'Tokyo', 'Paris', 'Berlin', 'Rio', 'Berlin')\n"
     ]
    }
   ],
   "source": [
    "'''Q8 Convert a list to a tuple.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "tup_lst = tuple(lst)\n",
    "print(\"Conversion of list to tuple :\", tup_lst) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1709bd25-af27-4439-bfa4-3d708f7d8f3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (\"Berlin\",\"Tokyo\",\"Paris\",\"Rio\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements of tuple into variables :\n",
      "Variable_1 : Berlin\n",
      "Variable_1 : Tokyo\n",
      "Variable_1 : Paris\n",
      "Variable_1 : Rio\n"
     ]
    }
   ],
   "source": [
    "'''Q9 Unpack the elements of a tuple into variables.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "a,b,c,d = tup\n",
    "print(\"Elements of tuple into variables :\")\n",
    "print(\"Variable_1 :\", a)\n",
    "print(\"Variable_1 :\", b)\n",
    "print(\"Variable_1 :\", c)\n",
    "print(\"Variable_1 :\", d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1ece703c-f0a5-4ac7-9e95-c6b353ee0e2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of even numbers : (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "'''Q10 Create a tuple of even numbers from 1 to 10.'''\n",
    "\n",
    "lst = []\n",
    "for i in range(1,11) :\n",
    "    if i%2 == 0 :\n",
    "        lst.append(i)\n",
    "print(\"Tuple of even numbers :\", tuple(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6e41dd67-c8d0-4096-b29d-d16c9504a157",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of odd numbers : (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "'''Q11 Create a tuple of odd numbers from 1 to 10.'''\n",
    "\n",
    "lst = []\n",
    "for i in range(1,11) :\n",
    "    if i%2 != 0 :\n",
    "        lst.append(i)\n",
    "print(\"Tuple of odd numbers :\", tuple(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a8d2f196-1c34-4f44-b56d-9d0a37cfdefc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st tuple : (1,2,3)\n",
      "Enter 2nd tuple : (4,5)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concatenation of two tuples : (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "'''Q12 Concatenate two tuples.'''\n",
    "\n",
    "tup_1 = eval(input(\"Enter 1st tuple :\"))\n",
    "tup_2 = eval(input(\"Enter 2nd tuple :\"))\n",
    "tup_3 = tup_1 + tup_2\n",
    "print(\"Concatenation of two tuples :\", tup_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "60c2a021-539d-447a-9f50-e09055a46b4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple repeated 3 times : (1, 2, 3, 1, 2, 3, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "'''Q13 Repeat a tuple three times.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "repeat_tup = tup * 3\n",
    "print(\"Tuple repeated 3 times :\", repeat_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "45f54d43-f92d-402d-82d2-f8e3d9986bde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (5,6,7)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple is not empty \n"
     ]
    }
   ],
   "source": [
    "'''Q14 Check if a tuple is empty.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "if tup == () :\n",
    "    print(\"Tuple is empty\")\n",
    "else  :\n",
    "    print(\"Tuple is not empty \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1df21c8f-837d-4673-bb9c-e9fdad50dca3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Create a nested tuple : ((1,3,5),(\"Berlin\",\"Rio\"),6,(True,))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested tuple : ((1, 3, 5), ('Berlin', 'Rio'), 6, (True,))\n"
     ]
    }
   ],
   "source": [
    "'''Q15 Create a nested tuple.'''\n",
    "\n",
    "tup = eval(input(\"Create a nested tuple :\"))\n",
    "print(\"Nested tuple :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "00ace0d0-06b7-4884-bbaf-a9ff4ce22b14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a nested tuple : ((1,3,5),(\"Berlin\",\"Rio\"),6,(True,))\n",
      "Enter element number which you want to access : 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element : (1, 3, 5)\n"
     ]
    }
   ],
   "source": [
    "'''Q16 Access the first element of a nested tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a nested tuple :\"))\n",
    "index = int(input(\"Enter element number which you want to access :\"))\n",
    "element = tup[index-1]\n",
    "print(f\"Element : {element}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2a1e113b-8b29-4567-95d0-c1f3c32bf1b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Create a tuple with single element : (2,)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with single element : (2,)\n"
     ]
    }
   ],
   "source": [
    "'''Q17 Create a tuple with a single element.'''\n",
    "\n",
    "tup = eval(input(\"Create a tuple with single element :\"))\n",
    "print(\"Tuple with single element :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4a2e2072-59c8-47ac-9084-fd5bbc453946",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st tuple : (2,4,5)\n",
      "Enter 2nd tuple : (3,5,7)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple 1 == Tuple 2 : False\n",
      "Tuple 1 != Tuple 2 : True\n",
      "Tuple 1 > tTple 2 : False\n",
      "Tuple 1 < tTple 2 : True\n",
      "Tuple 1 >= Tuple 2 : False\n",
      "Tuple 1 <= Tuple 2 : True\n"
     ]
    }
   ],
   "source": [
    "'''Q18 Compare two tuples.'''\n",
    "\n",
    "tup_1 = eval(input(\"Enter 1st tuple :\"))\n",
    "tup_2 = eval(input(\"Enter 2nd tuple :\"))\n",
    "print(\"Tuple 1 == Tuple 2 :\", tup_1 == tup_2)  \n",
    "print(\"Tuple 1 != Tuple 2 :\", tup_1 != tup_2)  \n",
    "print(\"Tuple 1 > tTple 2 :\", tup_1 > tup_2)\n",
    "print(\"Tuple 1 < tTple 2 :\", tup_1 < tup_2)  \n",
    "print(\"Tuple 1 >= Tuple 2 :\", tup_1 >= tup_2)    \n",
    "print(\"Tuple 1 <= Tuple 2 :\", tup_1 <= tup_2)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "67d41e2f-be22-4937-85d2-15e33b091327",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3)\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'tup' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[40], line 5\u001b[0m\n\u001b[1;32m      3\u001b[0m tup \u001b[38;5;241m=\u001b[39m \u001b[38;5;28meval\u001b[39m(\u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnter a tuple :\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m(tup)\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTuple deleted :\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[43mtup\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'tup' is not defined"
     ]
    }
   ],
   "source": [
    "'''Q19 Delete a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "del(tup)\n",
    "print(\"Tuple deleted :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dcab3b09-5dbd-40c5-a63c-e56875059357",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : ('Berlin', 'Tokyo', 'Paris', 'Berlin', 'Rio', 'Berlin')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliced tuple : ('Paris', 'Berlin')\n"
     ]
    }
   ],
   "source": [
    "'''Q20 Slice a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "slice_tup = tup[2:4]\n",
    "print(\"Sliced tuple :\", slice_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b22e7d89-7c97-4e5b-b35b-e0905a12dff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (2,45,6,735,6785,78,900)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value in tuple : 6785\n"
     ]
    }
   ],
   "source": [
    "'''Q21 Find the maximum value in a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "max_num = max(tup)\n",
    "print(\"Maximum value in tuple :\", max_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a1beadcd-e5f6-479c-b6d7-f0cb9520c3af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (2,45,6,735,6785,78,900)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value in tuple : 2\n"
     ]
    }
   ],
   "source": [
    "'''Q22 Find the minimum value in a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "min_num = min(tup)\n",
    "print(\"Minimum value in tuple :\", min_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "10111276-78ef-46c0-8d09-d9733ffdef09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of string to tuple of characters : ('M', 'y', ' ', 'n', 'a', 'm', 'e', ' ', 'i', 's', ' ', 'A', 'k', 's', 'h', 'a', 't', ' ', 'S', 'a', 'x', 'e', 'n', 'a', ' ', '.')\n"
     ]
    }
   ],
   "source": [
    "'''Q23 Convert a string to a tuple of characters.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "tup_str = tuple(string)\n",
    "print(\"Conversion of string to tuple of characters :\", tup_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "45bb8a83-39ae-4f1f-ad19-d0e6f54cb2a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : ('M', 'y', ' ', 'n', 'a', 'm', 'e', ' ', 'i', 's', ' ', 'A', 'k', 's', 'h', 'a', 't', ' ', 'S', 'a', 'x', 'e', 'n', 'a', ' ', '.')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of tuple to a string of characters : My name is Akshat Saxena .\n"
     ]
    }
   ],
   "source": [
    "'''Q24 Convert a tuple of characters to a string.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "str_tup = \"\".join(tup)\n",
    "print(\"Conversion of tuple to a string of characters :\", str_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "7637f5a6-75bc-4da5-87c1-f4e580f99c69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Create a tuple of multiple data types : (1,\"Berlin\",True,False,\"Hi\",45)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of multiple data types : (1, 'Berlin', True, False, 'Hi', 45)\n"
     ]
    }
   ],
   "source": [
    "'''Q25 Create a tuple from multiple data types.'''\n",
    "\n",
    "tup = eval(input(\"Create a tuple of multiple data types :\"))\n",
    "print(\"Tuple of multiple data types :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "8aefc3b8-2db7-42c8-bccd-15d12b58cf00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st tuple : (1,2,3)\n",
      "Enter 2nd tuple : (1,2,3)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuples are identical\n"
     ]
    }
   ],
   "source": [
    "'''Q26 Check if two tuples are identical.'''\n",
    "\n",
    "tup_1 = eval(input(\"Enter 1st tuple :\"))\n",
    "tup_2 = eval(input(\"Enter 2nd tuple :\"))\n",
    "if tup_1 == tup_2 :\n",
    "    print(\"Tuples are identical\")\n",
    "else :\n",
    "    print(\"Tuples are not identical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "1986fe73-4c92-49f9-b340-132c6503a76b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (2,45,6,735,6785,78,900)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted tuple : (2, 6, 45, 78, 735, 900, 6785)\n"
     ]
    }
   ],
   "source": [
    "'''Q27 Sort the elements of a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "sorted_tup = tuple(sorted(tup))\n",
    "print(\"Sorted tuple :\", sorted_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "077400cf-f872-48d3-a7ba-13842b7b1ee3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple of integers : (1,2,3,4,5,6)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of strings : ('1', '2', '3', '4', '5', '6')\n"
     ]
    }
   ],
   "source": [
    "'''Q28 Convert a tuple of integers to a tuple of strings.'''\n",
    "\n",
    "int_tup = eval(input(\"Enter a tuple of integers :\"))\n",
    "str_lst = []\n",
    "for i in list(int_tup) :\n",
    "    str_lst += str(i)\n",
    "str_tup = tuple(str_lst)\n",
    "print(\"Tuple of strings :\", str_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "24e23fa2-97e8-4aaf-a2d5-bcd54be1b977",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple of strings : ('1', '2', '3', '4', '5', '6')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of integers : (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "'''Q29 Convert a tuple of strings to a tuple of integers.'''\n",
    "\n",
    "str_tup = eval(input(\"Enter a tuple of strings :\"))\n",
    "int_lst = []\n",
    "for i in list(str_tup) :\n",
    "    int_lst += [int(i)]\n",
    "int_tup = tuple(int_lst)\n",
    "print(\"Tuple of integers :\", int_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7c6e3b5b-b208-4dd8-85bc-fd6d4456096d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st tuple : (1,2,3)\n",
      "Enter 2nd tuple : (4,5,6)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merge of both tuples : (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "'''Q30 Merge two tuples.'''\n",
    "\n",
    "tup_1 = eval(input(\"Enter 1st tuple :\"))\n",
    "tup_2 = eval(input(\"Enter 2nd tuple :\"))\n",
    "merge = tup_1 + tup_2\n",
    "print(\"Merge of both tuples :\", merge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f849515a-4ba8-476d-b74f-0ae7168b6a3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a nested tuple : ((1,2,3),6,(\"Berlin\",\"Paris\"),True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened nested list : (1, 2, 3, 6, 'Berlin', 'Paris', True)\n"
     ]
    }
   ],
   "source": [
    "'''Q31 Flatten a nested tuple.'''\n",
    "\n",
    "nested_tup = eval(input(\"Enter a nested tuple :\"))\n",
    "flatten_lst = []\n",
    "for tup in nested_tup :\n",
    "    if type(tup) != type(()) :\n",
    "        flatten_lst.append(tup)\n",
    "        continue\n",
    "    for element in tup :\n",
    "        flatten_lst.append(element)\n",
    "print(\"Flattened nested list :\", tuple(flatten_lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5b0c76f3-1db8-4500-9390-72777460f951",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of first prime numbers you want(max 100) : 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first 5 prime numbers: (2, 3, 5, 7, 11)\n"
     ]
    }
   ],
   "source": [
    "'''Q32 Create a tuple of the first 5 prime numbers.'''\n",
    "\n",
    "def check_prime(num):\n",
    "    if num <= 1:\n",
    "        return False\n",
    "    for i in range(2, int(num ** 0.5) + 1) :\n",
    "        if num % i == 0 :\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "n = int(input(\"Enter number of first prime numbers you want(max 100) :\"))\n",
    "prime_num_lst = [num for num in range(2, 100) if check_prime(num)][:n]\n",
    "\n",
    "prime_num_tup = tuple(prime_num_lst)\n",
    "\n",
    "print(\"Tuple of the first 5 prime numbers:\", prime_num_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b5e669bb-97a5-46f7-a69b-7d03fb134285",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (\"r\",\"a\",\"d\",\"a\",\"r\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple is palindrome\n"
     ]
    }
   ],
   "source": [
    "'''Q33 Check if a tuple is a palindrome.'''    \n",
    "\n",
    "def check_palindrome(lst) :\n",
    "    if lst == lst[::-1] :\n",
    "        return True\n",
    "    else :\n",
    "        return False\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "result = check_palindrome(list(tup))\n",
    "if result :\n",
    "    print(\"Tuple is palindrome\")\n",
    "else :\n",
    "    print(\"Tuple is not palindrome\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a8dd4dce-c3d2-4f97-86a1-c072f69a8d4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of squares : (1, 4, 9, 16, 25)\n"
     ]
    }
   ],
   "source": [
    "'''Q34 Create a tuple of squares of numbers from 1 to 5.'''\n",
    "\n",
    "lst_square = list(map(lambda i : i**2 , [1,2,3,4,5]))\n",
    "print(\"Tuple of squares :\", tuple(lst_square))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fc758141-87c2-4620-8d46-15de5ec5a11e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5,6,7,8,9,10)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All even numbers from tuple : (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "'''Q35 Filter out all even numbers from a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "even_lst = []\n",
    "for i in list(tup) :\n",
    "    if i % 2 == 0 :\n",
    "        even_lst += [i]\n",
    "print(\"All even numbers from tuple :\", tuple(even_lst))\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1b7aa21b-6e4e-4932-aa7a-38d83015d885",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (2,4,6,8,10)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Each element multiplied by 2 : (4, 8, 12, 16, 20)\n"
     ]
    }
   ],
   "source": [
    "'''Q36 Multiply all elements in a tuple by 2.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "mult_tup = tuple(map(lambda i : i*2 , tup))\n",
    "print(\"Each element multiplied by 2 :\", mult_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "147df07f-122e-4a15-8980-48ddb6dcb919",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of elements you want in tuple : 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of random numbers : (95, 92, 16, 63, 2, 54)\n"
     ]
    }
   ],
   "source": [
    "'''Q37 Create a tuple of random numbers.'''\n",
    "\n",
    "import random \n",
    "\n",
    "lst = []\n",
    "n = int(input(\"Enter number of elements you want in tuple :\"))\n",
    "for i in range(n) :\n",
    "    lst.append(random.randint(0,100))\n",
    "print(\"Tuple of random numbers :\", tuple(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a5b7723c-ccf8-4712-8d12-cecee8e4d7da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple is sorted\n"
     ]
    }
   ],
   "source": [
    "'''Q38 Check if a tuple is sorted.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "if list(tup) == sorted(tup) :\n",
    "    print(\"Tuple is sorted\")\n",
    "else :\n",
    "    print(\"Tuple is not sorted\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cf403932-e106-4e1a-8e1f-3b19107961f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5,6,7,8,9,10)\n",
      "Enter number of positions to rotate tuple to the left : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List rotated to left by 3 positions : (4, 5, 6, 7, 8, 9, 10, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "'''Q39 Rotate a tuple to the left by `n` positions.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "n = int(input(\"Enter number of positions to rotate tuple to the left :\"))\n",
    "lst = list(tup)\n",
    "rotated_lst = lst[n:] + lst[0:n]\n",
    "print(f\"List rotated to left by {n} positions : {tuple(rotated_lst)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7bf97609-c773-44ac-adf9-dd069e371864",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tup : (1,2,3,4,5,6,7,8,9,10)\n",
      "Enter number of positions to rotate tuple to the right : 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List rotated to right by 3 positions : (10, 9, 8, 7, 6, 5, 4, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "'''Q40 Rotate a tuple to the right by `n` positions.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tup :\"))\n",
    "n = int(input(\"Enter number of positions to rotate tuple to the right :\"))\n",
    "lst = list(tup)\n",
    "rotated_lst = lst[:n-1:-1] + lst[0:n]\n",
    "print(f\"List rotated to right by {n} positions : {tuple(rotated_lst)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f10ea1a2-92a9-4dd8-ae35-68ea793c8eb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of fibnacci numbers you want : 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first  5 Fibnacci numbers : (0, 1, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "'''Q41 Create a tuple of the first 5 Fibonacci numbers.'''\n",
    "\n",
    "def fib_num(n) :\n",
    "    lst = [0,1]\n",
    "    for i in range(2,n) :\n",
    "        next_fib_num = lst[i-1] + lst[i-2]\n",
    "        lst.append(next_fib_num)\n",
    "    return lst\n",
    "\n",
    "n = int(input(\"Enter number of fibnacci numbers you want :\"))\n",
    "lst = fib_num(n)\n",
    "print(\"Tuple of the first \",n ,\"Fibnacci numbers :\", tuple(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2ed4e3f6-001b-4707-9da9-d1c6b371204f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple : (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "'''Q42 Create a tuple from user input.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "print(\"Tuple :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "09565f77-2307-4d46-a3c5-820864640a0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,6,5,7,8,9,10)\n",
      "Enter element 1 which you want to swap : 5\n",
      "Enter element 2 which you want to swap : 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple after updation : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n"
     ]
    }
   ],
   "source": [
    "'''Q43 Swap two elements in a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "ele_1 = int(input(\"Enter element 1 which you want to swap :\"))\n",
    "ele_2 = int(input(\"Enter element 2 which you want to swap :\"))\n",
    "index_1 = tup.index(ele_1)\n",
    "index_2 = tup.index(ele_2)\n",
    "lst = list(tup)\n",
    "lst[index_1] = ele_2\n",
    "lst[index_2] = ele_1\n",
    "print(\"Tuple after updation :\", tuple(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e8356143-5586-4284-b2cf-a3011b5df7f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed tuple : (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "'''Q44 Reverse the elements of a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "lst = list(tup)\n",
    "reverse_tup = tuple(lst[::-1])\n",
    "print(\"Reversed tuple :\", reverse_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "11ef7653-c1f0-417d-85fb-561043acdb90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of n powers of 2 you want : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of first 10 powers of 2 : (1, 2, 4, 8, 16, 32, 64, 128, 256, 512)\n"
     ]
    }
   ],
   "source": [
    "'''Q45 Create a tuple of the first `n` powers of 2.'''\n",
    "\n",
    "n = int(input(\"Enter number of n powers of 2 you want :\"))\n",
    "lst = []\n",
    "for i in range(n) :\n",
    "    lst.append(2 ** i)\n",
    "print(f\"Tuple of first {n} powers of 2 : {tuple(lst)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "607eaa89-3eff-442a-9405-388463aac008",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple of strings : (\"Berlin\",\"Tokyo\",\"Paris\",\"Rio\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest string in tuple of strings : Berlin\n"
     ]
    }
   ],
   "source": [
    "'''Q46 Find the longest string in a tuple of strings.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple of strings :\"))\n",
    "longest_string = max(list(map(lambda i : len(i) , list(tup))))\n",
    "for i in list(tup) :\n",
    "    if len(i) == longest_string :\n",
    "        print(\"Longest string in tuple of strings :\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "34c4a9be-96bb-48d2-ae32-4e3d439b0878",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple of strings : (\"Berlin\",\"Tokyo\",\"Paris\",\"Rio\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest string in tuple of strings : Rio\n"
     ]
    }
   ],
   "source": [
    "'''Q47 Find the shortest string in a tuple of strings.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple of strings :\"))\n",
    "shortest_string = min(list(map(lambda i : len(i) , list(tup))))\n",
    "for i in list(tup) :\n",
    "    if len(i) == shortest_string :\n",
    "        print(\"Shortest string in tuple of strings :\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e03d0f16-b4e2-4e92-aaa3-d0e35a3809c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of first n triangular numbers you want : 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of the first 6 triangular numbers : (1, 3, 6, 10, 15, 21)\n"
     ]
    }
   ],
   "source": [
    "'''Q48 Create a tuple of the first `n` triangular numbers.'''\n",
    "\n",
    "def triangular_numbers(n) :\n",
    "    return [i * (i+1) // 2 for i in range(1,n+1)]\n",
    "\n",
    "n = int(input(\"Enter number of first n triangular numbers you want :\"))\n",
    "lst = triangular_numbers(n)\n",
    "print(f\"List of the first {n} triangular numbers : {tuple(lst)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c7b76500-2ea9-49e1-863a-325e362a416f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5,6,7,8,9,10)\n",
      "Enter another tuple : (1,6,9)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple ccontains another tuple as subsequence\n"
     ]
    }
   ],
   "source": [
    "'''Q49 Check if a tuple contains another tuple as a subsequence.'''\n",
    "\n",
    "def check_subsequence(tup , subsequence) :\n",
    "    index = 0\n",
    "    for i in tup :\n",
    "        if i == subsequence[index] :\n",
    "            index += 1\n",
    "            if index == len(subsequence) :\n",
    "                return True\n",
    "    return False\n",
    "            \n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))              \n",
    "subsequence = eval(input(\"Enter another tuple :\")) \n",
    "\n",
    "result = check_subsequence(tup,subsequence)\n",
    "if result :\n",
    "    print(\"Tuple ccontains another tuple as subsequence\")\n",
    "else :\n",
    "    print(\"Tuple does not contain another tuple as subsequence\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6eed2baf-344b-4f30-bc66-65558528c406",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter length of tuple you want : 7\n",
      "Do you want to start tuple with 0 or 1 : 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of alternating 1s and 0s of length 7 : (0, 1, 0, 1, 0, 1, 0)\n"
     ]
    }
   ],
   "source": [
    "'''Q50 Create a tuple of alternating 1s and 0s of length `n`.'''\n",
    "\n",
    "n = int(input(\"Enter length of tuple you want :\"))\n",
    "start = int(input(\"Do you want to start tuple with 0 or 1 :\"))\n",
    "lst = []\n",
    "if start == 1 :\n",
    "    for i in range(n) :\n",
    "        lst.append(start)\n",
    "        if len(lst) == n :\n",
    "            break\n",
    "        else :\n",
    "            lst.append(0)\n",
    "if start == 0 :\n",
    "    for i in range(n) :\n",
    "        lst.append(start)\n",
    "        if len(lst) == n :\n",
    "            break\n",
    "        else :\n",
    "            lst.append(1)\n",
    "else :\n",
    "    print(\"You entered an invalid number\")\n",
    "\n",
    "print(f\"Tuple of alternating 1s and 0s of length {n} : {tuple(lst)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9010e273-af2c-4ce2-a93c-9e6e4fc28b52",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0640ec51-75ce-4d10-833c-e3d74d7f4ca4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set Based Practice Problem :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6adcc3e3-57da-4e55-8cda-714897cdbe91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set with integers from 1 to 5 : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "'''Q1 Create a set with integers from 1 to 5.'''\n",
    "\n",
    "my_set = set()\n",
    "for i in range(1,6) :\n",
    "    my_set.add(i)\n",
    "print(\"Set with integers from 1 to 5 :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04e10129-31a2-46d8-bf86-ea2589e348a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {\"Berlin\",\"Tokyo\",\"Paris\"}\n",
      "Enter a element to add in set : \"Rio\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after adding element : {'Berlin', 'Rio', 'Tokyo', 'Paris'}\n"
     ]
    }
   ],
   "source": [
    "'''Q2 Add an element to a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "element = eval(input(\"Enter a element to add in set :\"))\n",
    "my_set.add(element)\n",
    "print(\"Set after adding element :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "457e5956-ee84-48b0-a13f-d9976141e6d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {'Berlin', 'Rio', 'Tokyo', 'Paris'}\n",
      "Enter a element to remove from set : \"Rio\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after removing element : {'Berlin', 'Tokyo', 'Paris'}\n"
     ]
    }
   ],
   "source": [
    "'''Q3 Remove an element from a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "element = eval(input(\"Enter a element to remove from set :\"))\n",
    "my_set.remove(element)\n",
    "print(\"Set after removing element :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cbff3a0b-b301-4ff8-bdb9-64611d3a056d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {'Berlin', 'Rio', 'Tokyo', 'Paris'}\n",
      "Enter an element to check it's existence : \"Tokyo\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokyo exists in set\n"
     ]
    }
   ],
   "source": [
    "'''Q4 Check if an element exists in a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "element = eval(input(\"Enter an element to check it's existence :\"))\n",
    "if element in my_set :\n",
    "    print(f\"{element} exists in set\")\n",
    "else :\n",
    "    print(f\"{element} does not exist in set\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "da4f2dc1-bd7e-4097-990a-962ed860e44e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {'Berlin', 'Rio', 'Tokyo', 'Paris'}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of set : 4\n"
     ]
    }
   ],
   "source": [
    "'''Q5 Find the length of a set without using the `len()` function.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "count = 0\n",
    "for i in my_set :\n",
    "    count += 1\n",
    "print(\"Length of set :\", count)     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c07a8aa0-2ce2-4082-b735-eb554fce6de0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {'Berlin', 'Rio', 'Tokyo', 'Paris'}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after clearing all elements : set()\n"
     ]
    }
   ],
   "source": [
    "'''Q6 Clear all elements from a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "my_set.clear()\n",
    "print(\"Set after clearing all elements :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bda3af92-54d7-4b98-b73b-f33aa5cc8e6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of even numbers from 1 to 10 : {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q7 Create a set of even numbers from 1 to 10.'''\n",
    "\n",
    "my_set = set()\n",
    "for i in range(1,11) :\n",
    "    if i%2 == 0 :\n",
    "        my_set.add(i)\n",
    "print(\"Set of even numbers from 1 to 10 :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d12aa1e3-9a57-40cc-aba0-136e130ffe06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of odd numbers from 1 to 10 : {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "'''Q8 Create a set of odd numbers from 1 to 10.'''\n",
    "\n",
    "my_set = set()\n",
    "for i in range(1,11) :\n",
    "    if i%2 != 0 :\n",
    "        my_set.add(i)\n",
    "print(\"Set of odd numbers from 1 to 10 :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a143e94b-48b8-4961-b768-574586a9ade3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {2,4,6,3,5}\n",
      "Enter 2nd set : {1,2,4,5,7,6}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of two sets : {1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "'''Q9 Find the union of two sets.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "union = my_set_1.union(my_set_2)\n",
    "print(\"Union of two sets :\", union)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4d790462-70f7-4661-a8b3-5ebcadf199ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {2,4,6,3,5}\n",
      "Enter 2nd set : {1,2,4,5,7,6}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of two sets : {2, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "'''Q10 Find the intersection of two sets.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "intersection = my_set_1.intersection(my_set_2)\n",
    "print(\"Union of two sets :\", intersection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "279b905b-b57b-47e0-890a-0837b7d64fef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {2,4,6,3,5}\n",
      "Enter 2nd set : {1,2,4,5,7,6}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of two sets : {3}\n"
     ]
    }
   ],
   "source": [
    "'''Q11 Find the difference between two sets.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "difference = my_set_1.difference(my_set_2)\n",
    "print(\"Union of two sets :\", difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f6781add-9d97-4766-aa84-271bc520a699",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter another set : {3,4,5}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 4, 5} is a subset of {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q12 Check if a set is a subset of another set.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter a set :\"))\n",
    "my_set_2 = eval(input(\"Enter another set :\"))\n",
    "if my_set_1.issubset(my_set_2) :\n",
    "    print(f\"{my_set_1} is a subset of {my_set_2}\")\n",
    "elif my_set_2.issubset(my_set_1) :\n",
    "    print(f\"{my_set_2} is a subset of {my_set_1}\")\n",
    "else :\n",
    "    print(\"No set is a subset of another\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5292095f-8883-4e59-ba35-034672e35856",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter another set : {3,4,5}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} is superset of {3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "'''Q13 Check if a set is a superset of another set.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter a set :\"))\n",
    "my_set_2 = eval(input(\"Enter another set :\"))\n",
    "if my_set_1.issuperset(my_set_2) :\n",
    "    print(f\"{my_set_1} is superset of {my_set_2}\")\n",
    "elif my_set_2.issuperset(my_set_1) :\n",
    "    print(f\"{my_set_2} is superset of {my_set_1}\")\n",
    "else :\n",
    "    print(\"No set is superset of another\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c887db8c-d36e-4cb0-a25d-fb7e4fb85b45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,4,5,6,7,8,9,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of list to set : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q14 Create a set from a list.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "my_set = set(lst)\n",
    "print(\"Conversion of list to set :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5bafdf4e-6181-4cdb-865e-9b5d93adf2ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of set to list : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "'''Q15 Convert a set to a list.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "lst = list(my_set)\n",
    "print(\"Conversion of set to list :\", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c63c9fc3-1b9c-445e-8f9a-fddc3c6aec05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after removing random element : {1, 2, 3, 4, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q16 Remove a random element from a set.'''\n",
    "\n",
    "import random\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "element = random.choice(list(my_set))\n",
    "my_set.remove(element)\n",
    "print(\"Set after removing random element :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "18b7869f-47d4-4169-9d5e-06e5a0768e45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Popped element : 1\n",
      "Set after popping out an element : {2, 3, 4, 5, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q17 Pop an element from a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "element_popped = my_set.pop()\n",
    "print(\"Popped element :\", element_popped)\n",
    "print(\"Set after popping out an element :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f09dd533-2d8b-49d5-bb8b-97b41fa1fe25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter 2nd set : {11,12,13}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both sets have no common elements\n"
     ]
    }
   ],
   "source": [
    "'''Q18 Check if two sets have no elements in common.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "result = my_set_1.intersection(my_set_2)\n",
    "            \n",
    "if result :\n",
    "    print(\"Both sets have some common elements\")\n",
    "else :\n",
    "    print(\"Both sets have no common elements\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "37dedd24-a9e0-4655-a4e1-2b12f8b46ef1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter 2nd set : {3,5,7}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symmetric difference : {1, 2, 4, 6, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q19 Find the symmetric difference between two sets.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "sym_diff = my_set_1.symmetric_difference(my_set_2)\n",
    "print(\"Symmetric difference :\", sym_diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "fa9e39f8-23b3-4df7-90fa-b6a13a867956",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter 2nd set : {11,13,15,12}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after updation {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15}\n"
     ]
    }
   ],
   "source": [
    "'''Q20 Update a set with elements from another set.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "my_set_1.update(my_set_2)\n",
    "print(f\"Set after updation {my_set_1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "078e41fc-55ac-4f00-b959-d130a234354c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of first prime numbers you want(max 100) : 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of the first 5 prime numbers: {2, 3, 5, 7, 11}\n"
     ]
    }
   ],
   "source": [
    "'''Q21 Create a set of the first 5 prime numbers.'''\n",
    "\n",
    "def check_prime(num):\n",
    "    if num <= 1:\n",
    "        return False\n",
    "    for i in range(2, int(num ** 0.5) + 1) :\n",
    "        if num % i == 0 :\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "n = int(input(\"Enter number of first prime numbers you want(max 100) :\"))\n",
    "prime_num_lst = [num for num in range(2, 100) if check_prime(num)][:n]\n",
    "\n",
    "print(\"Tuple of the first 5 prime numbers:\", set(prime_num_lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7c3196a1-82ef-4da2-b43b-ad7717e62ef8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3}\n",
      "Enter 2nd set : {1,2,3}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both sets are identical\n"
     ]
    }
   ],
   "source": [
    "'''Q22 Check if two sets are identical.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "if my_set_1 == my_set_2 :\n",
    "    print(\"Both sets are identical\")\n",
    "else :\n",
    "    print(\"Both sets are not identical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f31a7543-c7bf-4332-8633-4f506c655e3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [2,4,6,8,10]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frozen Set : frozenset({2, 4, 6, 8, 10})\n"
     ]
    }
   ],
   "source": [
    "'''Q23 Create a frozen set.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "frozen_set = frozenset(lst)\n",
    "print(\"Frozen Set :\", frozen_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "98322190-0e51-480d-9971-1444c89f1dbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3}\n",
      "Enter 2nd set : {4,5,6}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sets are disjoint\n"
     ]
    }
   ],
   "source": [
    "'''Q24 Check if a set is disjoint with another set.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "if my_set_1.isdisjoint(my_set_2) :\n",
    "    print(\"Given sets are disjoint\")\n",
    "else :\n",
    "    print(\"Given sets are not disjoint\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "752493e8-1e37-4b7a-ae90-bbb7ce5b1667",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of squares of numbers from 1 to 5 : {1, 4, 9, 16, 25}\n"
     ]
    }
   ],
   "source": [
    "'''Q25 Create a set of squares of numbers from 1 to 5.'''\n",
    "\n",
    "my_set = set(map(lambda i : i**2 , (j for j in range(1,6))))\n",
    "print(\"Set of squares of numbers from 1 to 5 :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b7f8b8d1-4556-43e6-ad66-805c6062d826",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of even numbers : {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q26 Filter out all even numbers from a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "even_set = set()\n",
    "for i in my_set :\n",
    "    if i%2 == 0 :\n",
    "        even_set.add(i) \n",
    "\n",
    "print(\"Set of even numbers :\", even_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a02adebd-1c4e-4d0e-9ada-c29a99c46c10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after updation : {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}\n"
     ]
    }
   ],
   "source": [
    "'''Q27 Multiply all elements in a set by 2.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "mult_set = set(map(lambda i : i*2 , my_set))\n",
    "print(\"Set after updation :\", mult_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8a3ef2c4-5881-4fb8-8ec5-56e8faa424dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter length of set which you want : 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of random numbers : {32, 28, 89, 92, 25}\n"
     ]
    }
   ],
   "source": [
    "'''Q28 Create a set of random numbers.'''\n",
    "\n",
    "import random \n",
    "\n",
    "my_set = set()\n",
    "n = int(input(\"Enter length of set which you want :\"))\n",
    "for i in range(n) :\n",
    "    my_set.add(random.randint(1,100))\n",
    "\n",
    "print(\"Set of random numbers :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "5ce699c9-ade0-460c-a9b2-a2e209e78708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set is empty\n"
     ]
    }
   ],
   "source": [
    "'''Q29 Check if a set is empty.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "if len(my_set) == 0 :\n",
    "    print(\"Set is empty\")\n",
    "else :\n",
    "    print(\"Set is not empty\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "488ba30d-3a32-4af8-a3ec-5538b7ad8803",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set {2,4,6,8,10}\n",
      "Enter 2nd set {1,2,3,4,5}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested set: {frozenset({2, 4, 6, 8, 10}), frozenset({1, 2, 3, 4, 5})}\n"
     ]
    }
   ],
   "source": [
    "'''Q30 Create a nested set (hint: use frozenset).'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set\"))\n",
    "\n",
    "frozen_set_1 = frozenset(my_set_1)\n",
    "frozen_set_2 = frozenset(my_set_2)\n",
    "nested_set = {frozen_set_1, frozen_set_2}\n",
    "\n",
    "print(\"Nested set:\", nested_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5533e4e3-83d5-4518-9699-559b4c1453ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter element which you want to discard : 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after removing an element : {1, 2, 3, 4, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q31 Remove an element from a set using the discard method.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "element = int(input(\"Enter element which you want to discard :\"))\n",
    "my_set.discard(element)\n",
    "print(\"Set after removing an element :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "114ff4d4-84e5-4075-ba56-5499b5279fd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3,4,6}\n",
      "Enter 2nd set : {2,3,4,5,1}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1: {1, 2, 3, 4, 6}\n",
      "Set 2: {1, 2, 3, 4, 5}\n",
      "Is set 1 a subset of set 2? False\n",
      "Is set 2 a subset of set 1? False\n",
      "Intersection: {1, 2, 3, 4}\n",
      "Union: {1, 2, 3, 4, 5, 6}\n",
      "Elements in set 1 but not in set 2: {6}\n",
      "Elements in set 2 but not in set 1: {5}\n"
     ]
    }
   ],
   "source": [
    "'''Q32 Compare two sets.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "\n",
    "check_subset = my_set_1.issubset(my_set_2)\n",
    "check_superset = my_set_1.issuperset(my_set_2)\n",
    "check_intersection = my_set_1.intersection(my_set_2)\n",
    "union = my_set_1.union(my_set_2)\n",
    "difference_1 = my_set_1.difference(my_set_2)\n",
    "difference_2 = my_set_2.difference(my_set_1)\n",
    "\n",
    "print(\"Set 1:\", my_set_1)\n",
    "print(\"Set 2:\", my_set_2)\n",
    "print(\"Is set 1 a subset of set 2?\", check_subset)\n",
    "print(\"Is set 2 a subset of set 1?\", check_superset)\n",
    "print(\"Intersection:\", check_intersection)\n",
    "print(\"Union:\", union)\n",
    "print(\"Elements in set 1 but not in set 2:\", difference_1)\n",
    "print(\"Elements in set 2 but not in set 1:\", difference_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3ace1588-8fdc-4e85-918f-e01b30391f42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string : My name is Akshat Saxena .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of string to set : {'t', '.', 's', 'k', 'M', 'a', 'n', 'i', 'y', 'h', 'S', ' ', 'm', 'A', 'e', 'x'}\n"
     ]
    }
   ],
   "source": [
    "'''Q33 Create a set from a string.'''\n",
    "\n",
    "string = input(\"Enter a string :\")\n",
    "print(\"Conversion of string to set :\", set(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7c13c12a-258c-446a-96fe-27dda0582d03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set of strings : {\"1\",\"2\",\"3\",\"4\"}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of set of strings to set of integers : {1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "'''Q34 Convert a set of strings to a set of integers.'''\n",
    "\n",
    "str_set = eval(input(\"Enter a set of strings :\"))\n",
    "set_int = set(map(lambda i : int(i) , list(str_set)))\n",
    "print(\"Conversion of set of strings to set of integers :\", set_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "003549f7-c14c-4a06-a972-4faf7ae1e1c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set of integers : {1, 2, 3, 4}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conversion of set of integers to set of strings : {'4', '1', '2', '3'}\n"
     ]
    }
   ],
   "source": [
    "'''Q35 Convert a set of integers to a set of strings.'''\n",
    "\n",
    "int_set = eval(input(\"Enter a set of integers :\"))\n",
    "set_str = set(map(lambda i : str(i) , list(int_set)))\n",
    "print(\"Conversion of set of integers to set of strings :\", set_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "067647db-e2cf-4256-95b0-024950806d26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a tuple : (1,2,3,4,5)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set from a tuple : {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "'''Q36 Create a set from a tuple.'''\n",
    "\n",
    "tup = eval(input(\"Enter a tuple :\"))\n",
    "my_set = set(tup)\n",
    "print(\"Set from a tuple :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7ca098fe-a41c-4096-a943-48c8377213b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple from a set : (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "'''Q37 Convert a set to a tuple.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "tup = tuple(my_set)\n",
    "print(\"Tuple from a set :\", tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "54f52d43-3e8a-4ed2-8d09-e2ace2ab4b49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,3,4,5,6,7,89,23}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value in set : 89\n"
     ]
    }
   ],
   "source": [
    "'''Q38 Find the maximum value in a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "lst = list(my_set)\n",
    "max_num = max(lst)\n",
    "print(\"Maximum value in set :\", max_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "19dc5027-3fd3-406c-98f0-2baffbc241da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,3,4,5,6,7,89,23}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value in set : 1\n"
     ]
    }
   ],
   "source": [
    "'''Q39 Find the minimum value in a set.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "lst = list(my_set)\n",
    "min_num = min(lst)\n",
    "print(\"Minimum value in set :\", min_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "16a261e8-b35b-48c3-82a4-fabd9eb2d91d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,3,4,5,6,7,89,23}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set : {1, 3, 4, 5, 6, 7, 23, 89}\n"
     ]
    }
   ],
   "source": [
    "'''Q40 Create a set from user input.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "print(\"Set :\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a563795a-0a60-40f1-852a-0d663433221e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3}\n",
      "Enter 2nd set : {4,5}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inbtersection of two sets is a empty set\n"
     ]
    }
   ],
   "source": [
    "'''Q41 Check if the intersection of two sets is empty.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "if my_set_1.intersection(my_set_2) :\n",
    "    print(\"Inbtersection of two sets is not a empty set\")\n",
    "else :\n",
    "    print(\"Inbtersection of two sets is a empty set\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fe1bd4ce-ce74-4f12-a23b-d779104f0edc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of Fibonacci numbers you want in set (n +1) : 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of first 6 Fibonacci numbers : {0, 1, 2, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "'''Q42 Create a set of the first 5 Fibonacci numbers.'''\n",
    "\n",
    "n = int(input(\"Enter number of Fibonacci numbers you want in set (n +1) :\"))\n",
    "x , y = 0 , 1  # initializing first two fibonacci numbers\n",
    "fib_set = set()\n",
    "for i in range(n) :\n",
    "    fib_set.add(x)\n",
    "    x , y = y , x+y\n",
    "\n",
    "print(f\"Set of first {n} Fibonacci numbers : {fib_set}\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c35df517-06e9-47ee-80a5-6364578b2727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list : [1,2,3,3,3,6,7,8,5,55,5,5,6,6,8,8]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after removing duplicate values : [1, 2, 3, 5, 6, 7, 8, 55]\n"
     ]
    }
   ],
   "source": [
    "'''Q43 Remove duplicates from a list using sets.'''\n",
    "\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "dup_set = set(lst)\n",
    "remove_duplicated_lst = list(dup_set)\n",
    "print(\"List after removing duplicate values :\", remove_duplicated_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "283ae658-8f8f-4b51-9fe4-f82535b1c0ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {4,5,6,4,6}\n",
      "Enter 2nd set : {4,5,6}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both sets have the same elements\n"
     ]
    }
   ],
   "source": [
    "'''Q44 Check if two sets have the same elements, regardless of their count.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "\n",
    "sorted_lst_1 = sorted(list(my_set_1))\n",
    "sorted_lst_2 = sorted(list(my_set_2))\n",
    "\n",
    "\n",
    "if sorted_lst_1 == sorted_lst_2 :\n",
    "    print(\"Both sets have the same elements\")\n",
    "else:\n",
    "    print(\"Both sets do not have the same elements\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "15e9a232-aa43-43b5-8651-b97ee5a19042",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of powers of n you want : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of first 10 powers of 2 : {32, 1, 2, 64, 4, 128, 256, 512, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "'''Q45 Create a set of the first `n` powers of 2.'''\n",
    "\n",
    "n = int(input(\"Enter number of powers of n you want :\"))\n",
    "my_set = set()\n",
    "for i in range(n) :\n",
    "    my_set.add(2**i)\n",
    "print(f\"Set of first {n} powers of 2 : {my_set}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3971f03a-5b46-4c53-9906-519485d71218",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8,9,10}\n",
      "Enter a list : [3,5,7,9,11]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements between set and list :\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "'''Q46 Find the common elements between a set and a list.'''\n",
    "\n",
    "my_set = eval(input(\"Enter a set :\"))\n",
    "lst = eval(input(\"Enter a list :\"))\n",
    "print(\"Common elements between set and list :\")\n",
    "for i in my_set :\n",
    "    for j in lst :\n",
    "        if i == j :\n",
    "            print(i)            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a7d69d8e-10d2-4a85-bcbf-ebce8c517273",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number of first n triangular numbers you want : 6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of the first 6 triangular numbers : {1, 3, 6, 10, 15, 21}\n"
     ]
    }
   ],
   "source": [
    "'''Q47 Create a set of the first `n` triangular numbers.'''\n",
    "\n",
    "def triangular_numbers(n) :\n",
    "    return [i * (i+1) // 2 for i in range(1,n+1)]\n",
    "\n",
    "n = int(input(\"Enter number of first n triangular numbers you want :\"))\n",
    "lst = triangular_numbers(n)\n",
    "print(f\"Set of the first {n} triangular numbers : {set(lst)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "31addc9c-be1a-4cef-bbc8-c1f558b94c3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a set : {1,2,3,4,5,6,7,8}\n",
      "Enter another set : {2,3,4}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 4} is a subset of {1, 2, 3, 4, 5, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "'''Q48 Check if a set contains another set as a subset.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter a set :\"))\n",
    "my_set_2 = eval(input(\"Enter another set :\"))\n",
    "if my_set_1.issubset(my_set_2) :\n",
    "    print(f\"{my_set_1} is a subset of {my_set_2}\")\n",
    "elif my_set_2.issubset(my_set_1) :\n",
    "    print(f\"{my_set_2} is a subset of {my_set_1}\")\n",
    "else :\n",
    "    print(\"No set is a subset of another\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5ef1e2e9-fca6-4972-88aa-3ad27e3ab777",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter length of set you want : 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of alternating 1s and 0s of length 10 : {0, 1}\n"
     ]
    }
   ],
   "source": [
    "'''Q49 Create a set of alternating 1s and 0s of length `n`.'''\n",
    "\n",
    "n = int(input(\"Enter length of set you want :\"))\n",
    "my_set = set()\n",
    "for i in range(n) :\n",
    "        my_set.add(1)\n",
    "        if len(my_set) == n :\n",
    "            break\n",
    "        else :\n",
    "            my_set.add(0)\n",
    "\n",
    "print(f\"Set of alternating 1s and 0s of length {n} : {my_set}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f262cb72-82d4-4a6c-82ab-3772ea67e949",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter 1st set : {1,2,3}\n",
      "Enter 2nd set : {4,5,6}\n",
      "Enter 3rd set : {7,8,9,10}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged sets : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "'''Q50 Merge multiple sets into one.'''\n",
    "\n",
    "my_set_1 = eval(input(\"Enter 1st set :\"))\n",
    "my_set_2 = eval(input(\"Enter 2nd set :\"))\n",
    "my_set_3 = eval(input(\"Enter 3rd set :\"))\n",
    "\n",
    "merge = my_set_1.union(my_set_2 , my_set_3)\n",
    "print(\"Merged sets :\", merge)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}