FULL200QSW2S2assignmentsols.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dab25e2-6100-438b-a457-17267becce3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# STRING BASED QS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "eb794ed8-299e-49e0-87dc-87e1fa0cb392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  I LOVE DS\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed string: SD EVOL I\n"
     ]
    }
   ],
   "source": [
    "#STRING Q1: Write a program to reverse a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Reverse the string using string slicing\n",
    "reversed_string = input_string[::-1]\n",
    "\n",
    "# Print the reversed string\n",
    "print(\"Reversed string:\", reversed_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "16544781-dd70-40b2-b3bb-756c74b988e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  I LOVE DS\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The entered string is not a palindrome.\n"
     ]
    }
   ],
   "source": [
    "# Q2: Check if a string is a palindrome.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Remove spaces and convert to lowercase for case-insensitive comparison\n",
    "cleaned_string = input_string.replace(\" \", \"\").lower()\n",
    "\n",
    "# Reverse the string using string slicing\n",
    "reversed_string = cleaned_string[::-1]\n",
    "\n",
    "# Check if the original and reversed strings are the same\n",
    "if cleaned_string == reversed_string:\n",
    "    print(\"The entered string is a palindrome.\")\n",
    "else:\n",
    "    print(\"The entered string is not a palindrome.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b3b9486d-5427-4db4-9534-885811c83ea0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love ds\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uppercase string: I LOVE DS\n"
     ]
    }
   ],
   "source": [
    "# Q3: Convert a string to uppercase.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Convert the string to uppercase\n",
    "uppercase_string = input_string.upper()\n",
    "\n",
    "# Print the uppercase string\n",
    "print(\"Uppercase string:\", uppercase_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e78467c0-1ced-416a-930f-cc7438619236",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  I LOVE DS\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowercase string: i love ds\n"
     ]
    }
   ],
   "source": [
    "# Q4: Convert a string to lowercase.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Convert the string to lowercase\n",
    "lowercase_string = input_string.lower()\n",
    "\n",
    "# Print the lowercase string\n",
    "print(\"Lowercase string:\", lowercase_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "610effa9-599c-4a22-b89b-28f10a4ef871",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  I love apple\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of vowels: 5\n"
     ]
    }
   ],
   "source": [
    "# Q5: Count the number of vowels in a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Initialize a variable to store the vowel count\n",
    "vowel_count = 0\n",
    "\n",
    "# Define the set of vowels\n",
    "vowels = \"aeiouAEIOU\"\n",
    "\n",
    "# Iterate through each character in the string\n",
    "for char in input_string:\n",
    "    if char in vowels:\n",
    "        vowel_count += 1\n",
    "\n",
    "# Print the vowel count\n",
    "print(\"Number of vowels:\", vowel_count)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b5504382-0474-4b00-9279-2d6b1d690bcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love apple\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of consonants: 5\n"
     ]
    }
   ],
   "source": [
    "# Q6: Count the number of consonants in a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Initialize a variable to store the consonant count\n",
    "consonant_count = 0\n",
    "\n",
    "# Define the set of vowels\n",
    "vowels = \"aeiouAEIOU\"\n",
    "\n",
    "# Iterate through each character in the string\n",
    "for char in input_string:\n",
    "    if char.isalpha() and char not in vowels:\n",
    "        consonant_count += 1\n",
    "\n",
    "# Print the consonant count\n",
    "print(\"Number of consonants:\", consonant_count)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "12b50cc3-6b1b-446c-9f73-ffb282c775f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love ds\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String without whitespaces: iloveds\n"
     ]
    }
   ],
   "source": [
    "# Q7: Remove all whitespaces from a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Remove whitespaces from the string\n",
    "no_whitespace_string = input_string.replace(\" \", \"\")\n",
    "\n",
    "# Print the string without whitespaces\n",
    "print(\"String without whitespaces:\", no_whitespace_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "86de5e88-2f47-4d17-8ee1-8c4295fb6867",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love ds\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the string: 9\n"
     ]
    }
   ],
   "source": [
    "# Q8: Find the length of a string without using the len() function.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Initialize a variable to store the string length\n",
    "string_length = 0\n",
    "\n",
    "# Iterate through each character in the string\n",
    "for char in input_string:\n",
    "    string_length += 1\n",
    "\n",
    "# Print the string length\n",
    "print(\"Length of the string:\", string_length)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "187ee4f6-0830-4d05-8165-fcafc1b0afe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love apple\n",
      "Enter the specific word to check:  a\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The specific word is present in the string.\n"
     ]
    }
   ],
   "source": [
    "# Q9: Check if a string contains a specific word.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "specific_word = input(\"Enter the specific word to check: \")\n",
    "\n",
    "# Check if the specific word is present in the string\n",
    "if specific_word in input_string:\n",
    "    print(\"The specific word is present in the string.\")\n",
    "else:\n",
    "    print(\"The specific word is not present in the string.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5944bf44-52ba-4f18-bb06-3c951240fe46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love applw\n",
      "Enter the word to replace:  applw\n",
      "Enter the new word:  orange\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified string: i love orange\n"
     ]
    }
   ],
   "source": [
    "# Q10: Replace a word in a string with another word.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "old_word = input(\"Enter the word to replace: \")\n",
    "new_word = input(\"Enter the new word: \")\n",
    "\n",
    "# Replace the old word with the new word in the string\n",
    "modified_string = input_string.replace(old_word, new_word)\n",
    "\n",
    "# Print the modified string\n",
    "print(\"Modified string:\", modified_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "13911dd8-883d-48f2-86b9-6bffebfee7fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love love \n",
      "Enter the word to count:  love\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Occurrences of the word: 2\n"
     ]
    }
   ],
   "source": [
    "# Q11: Count the occurrences of a word in a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "target_word = input(\"Enter the word to count: \")\n",
    "\n",
    "# Split the string into words\n",
    "words = input_string.split()\n",
    "\n",
    "# Initialize a variable to store the word count\n",
    "word_count = 0\n",
    "\n",
    "# Iterate through each word in the list of words\n",
    "for word in words:\n",
    "    if word == target_word:\n",
    "        word_count += 1\n",
    "\n",
    "# Print the word count\n",
    "print(\"Occurrences of the word:\", word_count)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e69987a4-8e53-42c4-8d79-51af997bf180",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  apple is healthy\n",
      "Enter the word to find:  is\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first occurrence of the word is at index: 6\n"
     ]
    }
   ],
   "source": [
    "# Q12: Find the first occurrence of a word in a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "target_word = input(\"Enter the word to find: \")\n",
    "\n",
    "# Find the index of the first occurrence of the target word\n",
    "index = input_string.find(target_word)\n",
    "\n",
    "# Print the index of the first occurrence\n",
    "if index != -1:\n",
    "    print(\"The first occurrence of the word is at index:\", index)\n",
    "else:\n",
    "    print(\"The word was not found in the string.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c7259a4a-595c-4443-a5ff-b0e68bbc10a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  apple is good \n",
      "Enter the word to find:  good\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The last occurrence of the word is at index: 9\n"
     ]
    }
   ],
   "source": [
    "# Q13: Find the last occurrence of a word in a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "target_word = input(\"Enter the word to find: \")\n",
    "\n",
    "# Find the index of the last occurrence of the target word\n",
    "index = input_string.rfind(target_word)\n",
    "\n",
    "# Print the index of the last occurrence\n",
    "if index != -1:\n",
    "    print(\"The last occurrence of the word is at index:\", index)\n",
    "else:\n",
    "    print(\"The word was not found in the string.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8025f870-c2af-4a21-8d1b-a694a601c305",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  apple is good \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of words: ['apple', 'is', 'good']\n"
     ]
    }
   ],
   "source": [
    "# Q14: Split a string into a list of words.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Split the string into a list of words\n",
    "word_list = input_string.split()\n",
    "\n",
    "# Print the list of words\n",
    "print(\"List of words:\", word_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "67885bb3-4176-4a09-8030-c948531d9883",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a list of words (separated by spaces):  apple orange mango banana\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joined string: apple orange mango banana\n"
     ]
    }
   ],
   "source": [
    "# Q15: Join a list of words into a string.\n",
    "\n",
    "# Get input from the user: list of words\n",
    "word_list = input(\"Enter a list of words (separated by spaces): \").split()\n",
    "\n",
    "# Join the list of words into a string using spaces as separators\n",
    "joined_string = \" \".join(word_list)\n",
    "\n",
    "# Print the joined string\n",
    "print(\"Joined string:\", joined_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7c5ecb95-dba1-4b7a-a392-25536fed4b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string with words separated by spaces:  for each apple red \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted string: for_each_apple_red_\n"
     ]
    }
   ],
   "source": [
    "# Q16: Convert a string where words are separated by spaces to one where words are separated by underscores.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string with words separated by spaces: \")\n",
    "\n",
    "# Replace spaces with underscores\n",
    "converted_string = input_string.replace(\" \", \"_\")\n",
    "\n",
    "# Print the converted string\n",
    "print(\"Converted string:\", converted_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "65d88f4a-4aa6-4515-b751-1ac1acc4b88f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love apple\n",
      "Enter the specific word or phrase to check:  p\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string does not start with the specified word or phrase.\n"
     ]
    }
   ],
   "source": [
    "# Q17: Check if a string starts with a specific word or phrase.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "specific_word = input(\"Enter the specific word or phrase to check: \")\n",
    "\n",
    "# Check if the string starts with the specific word or phrase\n",
    "if input_string.startswith(specific_word):\n",
    "    print(\"The string starts with the specified word or phrase.\")\n",
    "else:\n",
    "    print(\"The string does not start with the specified word or phrase.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fdefebbf-7ecf-48f5-84d3-11ed7165e2b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love you\n",
      "Enter the specific word or phrase to check:  u\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string ends with the specified word or phrase.\n"
     ]
    }
   ],
   "source": [
    "# Q18: Check if a string ends with a specific word or phrase.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "specific_word = input(\"Enter the specific word or phrase to check: \")\n",
    "\n",
    "# Check if the string ends with the specific word or phrase\n",
    "if input_string.endswith(specific_word):\n",
    "    print(\"The string ends with the specified word or phrase.\")\n",
    "else:\n",
    "    print(\"The string does not end with the specified word or phrase.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b6dc2bd2-82c3-442b-a5a1-d0408e448767",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love u\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title case string: I Love U\n"
     ]
    }
   ],
   "source": [
    "# Q19: Convert a string to title case.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Convert the string to title case\n",
    "title_case_string = input_string.title()\n",
    "\n",
    "# Print the title case string\n",
    "print(\"Title case string:\", title_case_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0e223926-98b3-4129-a48c-fcd0a56314f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pizza\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest word: pizza\n"
     ]
    }
   ],
   "source": [
    "# Q20: Find the longest word in a string.\n",
    "\n",
    "# Get input from the user\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "# Split the string into a list of words\n",
    "words = input_string.split()\n",
    "\n",
    "# Initialize variables to store the longest word and its length\n",
    "longest_word = \"\"\n",
    "max_length = 0\n",
    "\n",
    "# Iterate through each word in the list of words\n",
    "for word in words:\n",
    "    if len(word) > max_length:\n",
    "        longest_word = word\n",
    "        max_length = len(word)\n",
    "\n",
    "# Print the longest word\n",
    "print(\"Longest word:\", longest_word)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f3ce4a14-3d3d-4857-91d3-654ecaf343d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love you\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest word: i\n"
     ]
    }
   ],
   "source": [
    "# Q21: Find the shortest word in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "words = input_string.split()\n",
    "\n",
    "# Initialize variables to store the shortest word and its length\n",
    "shortest_word = words[0]\n",
    "min_length = len(words[0])\n",
    "\n",
    "# Iterate through each word in the list of words\n",
    "for word in words:\n",
    "    if len(word) < min_length:\n",
    "        shortest_word = word\n",
    "        min_length = len(word)\n",
    "\n",
    "print(\"Shortest word:\", shortest_word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "87d2c81b-91d6-491f-88de-557559014d05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love paris\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed order of words: paris love i\n"
     ]
    }
   ],
   "source": [
    "# Q22: Reverse the order of words in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "words = input_string.split()\n",
    "\n",
    "# Reverse the order of words using list slicing\n",
    "reversed_words = words[::-1]\n",
    "\n",
    "# Join the reversed words into a string\n",
    "reversed_string = \" \".join(reversed_words)\n",
    "\n",
    "print(\"Reversed order of words:\", reversed_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "66712410-2418-4db3-837b-4fa346d93261",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i want 3 pizza\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string is not alphanumeric.\n"
     ]
    }
   ],
   "source": [
    "# Q23: Check if a string is alphanumeric.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "if input_string.isalnum():\n",
    "    print(\"The string is alphanumeric.\")\n",
    "else:\n",
    "    print(\"The string is not alphanumeric.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "41027340-dcfa-4a70-af40-9a7a71a764a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i want 3 pizza\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digits extracted: 3\n"
     ]
    }
   ],
   "source": [
    "# Q24: Extract all digits from a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "digits = [char for char in input_string if char.isdigit()]\n",
    "\n",
    "print(\"Digits extracted:\", \"\".join(digits))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3b144a37-5b2a-4d1f-a279-ef98ef8489bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pizza\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alphabets extracted: ilovepizza\n"
     ]
    }
   ],
   "source": [
    "# Q25: Extract all alphabets from a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "alphabets = [char for char in input_string if char.isalpha()]\n",
    "\n",
    "print(\"Alphabets extracted:\", \"\".join(alphabets))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "25eeffce-d216-4550-8a66-94be53fd6b28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love APPLE \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of uppercase letters: 5\n"
     ]
    }
   ],
   "source": [
    "# Q26: Count the number of uppercase letters in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "uppercase_count = sum(1 for char in input_string if char.isupper())\n",
    "\n",
    "print(\"Number of uppercase letters:\", uppercase_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eef6e28c-2278-47cd-b5b5-5be66baf0e3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pizza\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of lowercase letters: 10\n"
     ]
    }
   ],
   "source": [
    "# Q27: Count the number of lowercase letters in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "lowercase_count = sum(1 for char in input_string if char.islower())\n",
    "\n",
    "print(\"Number of lowercase letters:\", lowercase_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "702af4ce-2c1a-4013-aa6b-66a4170bc39b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pw\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String with swapped case: I LOVE PW\n"
     ]
    }
   ],
   "source": [
    "# Q28: Swap the case of each character in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "swapped_case_string = input_string.swapcase()\n",
    "\n",
    "print(\"String with swapped case:\", swapped_case_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "696442a6-5028-4576-a4f1-66742af19042",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pw \n",
      "Enter the word to remove:  love \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified string: i pw \n"
     ]
    }
   ],
   "source": [
    "# Q29: Remove a specific word from a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "specific_word = input(\"Enter the word to remove: \")\n",
    "\n",
    "modified_string = input_string.replace(specific_word, \"\")\n",
    "\n",
    "print(\"Modified string:\", modified_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "17429832-8136-4506-846a-80ddd0b2159b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an email address:  faiza@yahoo.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid email address.\n"
     ]
    }
   ],
   "source": [
    "# Q30: Check if a string is a valid email address.\n",
    "\n",
    "import re\n",
    "\n",
    "email = input(\"Enter an email address: \")\n",
    "pattern = r\"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$\"\n",
    "\n",
    "if re.match(pattern, email):\n",
    "    print(\"Valid email address.\")\n",
    "else:\n",
    "    print(\"Invalid email address.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7b29f044-92ee-4060-b01d-7e836395c8af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an email address:  faiz@yahoo.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Username: faiz\n"
     ]
    }
   ],
   "source": [
    "# Q31: Extract the username from an email address string.\n",
    "\n",
    "email = input(\"Enter an email address: \")\n",
    "username = email.split('@')[0]\n",
    "\n",
    "print(\"Username:\", username)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bf64b6fe-990f-4730-8e93-aaad2170daaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an email address:  faiz@yahoo.com\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Domain: yahoo.com\n"
     ]
    }
   ],
   "source": [
    "# Q32: Extract the domain name from an email address string.\n",
    "\n",
    "email = input(\"Enter an email address: \")\n",
    "domain = email.split('@')[1]\n",
    "\n",
    "print(\"Domain:\", domain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9b63dca1-3a6f-40fe-9336-2afb679d61fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pw\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String with single spaces: i love pw\n"
     ]
    }
   ],
   "source": [
    "# Q33: Replace multiple spaces in a string with a single space.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "modified_string = ' '.join(input_string.split())\n",
    "\n",
    "print(\"String with single spaces:\", modified_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dbe3f261-b2c1-4675-b6cc-b707f2306b91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a URL:  https://github.com/FURIOUSCHAMP007/Full-Stack-Data-Science-Pro/tree/main\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid URL.\n"
     ]
    }
   ],
   "source": [
    "# Q34: Check if a string is a valid URL.\n",
    "\n",
    "import re\n",
    "\n",
    "url = input(\"Enter a URL: \")\n",
    "pattern = r\"^(http|https)://[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$\"\n",
    "\n",
    "if re.match(pattern, url):\n",
    "    print(\"Valid URL.\")\n",
    "else:\n",
    "    print(\"Invalid URL.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7239236f-a9ea-4e7f-9b74-67aa8e773554",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a URL:  https://github.com/FURIOUSCHAMP007/Full-Stack-Data-Science-Pro/tree/main\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Protocol: https\n"
     ]
    }
   ],
   "source": [
    "# Q35: Extract the protocol (http or https) from a URL string.\n",
    "\n",
    "url = input(\"Enter a URL: \")\n",
    "protocol = url.split(':')[0]\n",
    "\n",
    "print(\"Protocol:\", protocol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6c58357e-7167-46ac-9f1e-39c4232444cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love apple \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character frequency: {'i': 1, ' ': 3, 'l': 2, 'o': 1, 'v': 1, 'e': 2, 'a': 1, 'p': 2}\n"
     ]
    }
   ],
   "source": [
    "# Q36: Find the frequency of each character in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "character_frequency = {}\n",
    "\n",
    "for char in input_string:\n",
    "    character_frequency[char] = character_frequency.get(char, 0) + 1\n",
    "\n",
    "print(\"Character frequency:\", character_frequency)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7236fa6f-1798-4d77-84ff-5ea653765cb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love , apple .\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String without punctuation: i love  apple \n"
     ]
    }
   ],
   "source": [
    "# Q37: Remove all punctuation from a string.\n",
    "\n",
    "import string\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "no_punctuation_string = input_string.translate(str.maketrans('', '', string.punctuation))\n",
    "\n",
    "print(\"String without punctuation:\", no_punctuation_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "958bd251-5065-4768-9b0a-e8104427b32c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  love 3 times than \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string does not contain only digits.\n"
     ]
    }
   ],
   "source": [
    "# Q38: Check if a string contains only digits.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "if input_string.isdigit():\n",
    "    print(\"The string contains only digits.\")\n",
    "else:\n",
    "    print(\"The string does not contain only digits.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9703140f-460d-4cc0-94b1-6781affbd005",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love ytou\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string does not contain only alphabets.\n"
     ]
    }
   ],
   "source": [
    "# Q39: Check if a string contains only alphabets.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "\n",
    "if input_string.isalpha():\n",
    "    print(\"The string contains only alphabets.\")\n",
    "else:\n",
    "    print(\"The string does not contain only alphabets.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e5b2e0bc-8f38-433f-85da-67e105baa6d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pw\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of characters: ['i', ' ', 'l', 'o', 'v', 'e', ' ', 'p', 'w']\n"
     ]
    }
   ],
   "source": [
    "# Q40: Convert a string to a list of characters.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "character_list = list(input_string)\n",
    "\n",
    "print(\"List of characters:\", character_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8be7c7a2-0f71-4d9f-b7a0-6d2a2c012ebc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first string:  i love you\n",
      "Enter the second string:  i love you\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The strings are anagrams.\n"
     ]
    }
   ],
   "source": [
    "# Q41: Check if two strings are anagrams.\n",
    "\n",
    "def are_anagrams(str1, str2):\n",
    "    return sorted(str1) == sorted(str2)\n",
    "\n",
    "string1 = input(\"Enter the first string: \")\n",
    "string2 = input(\"Enter the second string: \")\n",
    "\n",
    "if are_anagrams(string1, string2):\n",
    "    print(\"The strings are anagrams.\")\n",
    "else:\n",
    "    print(\"The strings are not anagrams.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c783950d-3ab5-4ae3-a901-5cca5be748a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love pw \n",
      "Enter the shift value:  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoded string: p svcl wd \n"
     ]
    }
   ],
   "source": [
    "# Q42: Encode a string using a Caesar cipher.\n",
    "\n",
    "def caesar_cipher_encrypt(text, shift):\n",
    "    encrypted_text = \"\"\n",
    "\n",
    "    for char in text:\n",
    "        if char.isalpha():\n",
    "            shift_amount = ord('a') if char.islower() else ord('A')\n",
    "            encrypted_char = chr((ord(char) - shift_amount + shift) % 26 + shift_amount)\n",
    "            encrypted_text += encrypted_char\n",
    "        else:\n",
    "            encrypted_text += char\n",
    "\n",
    "    return encrypted_text\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "shift_value = int(input(\"Enter the shift value: \"))\n",
    "\n",
    "encoded_string = caesar_cipher_encrypt(input_string, shift_value)\n",
    "print(\"Encoded string:\", encoded_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "915c5e53-8c53-47d4-b7cb-dc227351963f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter an encoded string:  p svcl wd\n",
      "Enter the shift value:  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoded string: i love pw\n"
     ]
    }
   ],
   "source": [
    "# Q43: Decode a Caesar cipher encoded string.\n",
    "\n",
    "def caesar_cipher_decrypt(encrypted_text, shift):\n",
    "    return caesar_cipher_encrypt(encrypted_text, -shift)\n",
    "\n",
    "encoded_string = input(\"Enter an encoded string: \")\n",
    "shift_value = int(input(\"Enter the shift value: \"))\n",
    "\n",
    "decoded_string = caesar_cipher_decrypt(encoded_string, shift_value)\n",
    "print(\"Decoded string:\", decoded_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f57b56d3-df15-4d31-ae09-735a66829300",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love apple\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most frequent word: i\n"
     ]
    }
   ],
   "source": [
    "# Q44: Find the most frequent word in a string.\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "words = input_string.split()\n",
    "word_count = Counter(words)\n",
    "most_common_word = word_count.most_common(1)[0][0]\n",
    "\n",
    "print(\"Most frequent word:\", most_common_word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "87d1765c-cc7a-4949-847b-dbed0d771e3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:   i love banana orange mango\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique words: {'i', 'love', 'banana', 'mango', 'orange'}\n"
     ]
    }
   ],
   "source": [
    "# Q45: Find all unique words in a string.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "words = input_string.split()\n",
    "unique_words = set(words)\n",
    "\n",
    "print(\"Unique words:\", unique_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9e0fd00b-9da2-42ca-9031-2d8716b6b343",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  maths sci phy chem sst \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of syllables: 3\n"
     ]
    }
   ],
   "source": [
    "# Q46: Count the number of syllables in a string.\n",
    "\n",
    "def count_syllables(word):\n",
    "    vowels = \"AEIOUaeiou\"\n",
    "    count = 0\n",
    "    for char in word:\n",
    "        if char in vowels:\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "words = input_string.split()\n",
    "total_syllables = sum(count_syllables(word) for word in words)\n",
    "\n",
    "print(\"Number of syllables:\", total_syllables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8b1e71bf-b345-4677-be6f-c1b9171afe75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love @ pw \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string contains special characters.\n"
     ]
    }
   ],
   "source": [
    "# Q47: Check if a string contains any special characters.\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "special_characters = \"!@#$%^&*()_-+={}[]|\\:;<>,.?/~\"\n",
    "\n",
    "if any(char in special_characters for char in input_string):\n",
    "    print(\"The string contains special characters.\")\n",
    "else:\n",
    "    print(\"The string does not contain special characters.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "bca5900d-b9c5-4f44-95a1-1befc85f81d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  lovely\n",
      "Enter the position of the word to remove:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified string: lovely\n"
     ]
    }
   ],
   "source": [
    "# Q48: Remove the nth word from a string.\n",
    "\n",
    "def remove_nth_word(input_string, n):\n",
    "    words = input_string.split()\n",
    "    if 1 <= n <= len(words):\n",
    "        words.pop(n - 1)\n",
    "        return \" \".join(words)\n",
    "    else:\n",
    "        return input_string\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "n = int(input(\"Enter the position of the word to remove: \"))\n",
    "\n",
    "modified_string = remove_nth_word(input_string, n)\n",
    "print(\"Modified string:\", modified_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "29e2b313-fc11-4a2e-b0c6-24bdc2804cf9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  i love maths \n",
      "Enter the word to insert:  hate \n",
      "Enter the position to insert the word:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified string: i love maths hate \n"
     ]
    }
   ],
   "source": [
    "# Q49: Insert a word at the nth position in a string.\n",
    "\n",
    "def insert_word(input_string, word, n):\n",
    "    words = input_string.split()\n",
    "    if 0 <= n <= len(words):\n",
    "        words.insert(n, word)\n",
    "        return \" \".join(words)\n",
    "    else:\n",
    "        return input_string\n",
    "\n",
    "input_string = input(\"Enter a string: \")\n",
    "word_to_insert = input(\"Enter the word to insert: \")\n",
    "position = int(input(\"Enter the position to insert the word: \"))\n",
    "\n",
    "modified_string = insert_word(input_string, word_to_insert, position)\n",
    "print(\"Modified string:\", modified_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "61aae63a-2565-4307-b8eb-e7605171b1ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a CSV string:  hello.csv\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CSV list: [['hello.csv']]\n"
     ]
    }
   ],
   "source": [
    "# Q50: Convert a CSV string to a list of lists.\n",
    "\n",
    "csv_string = input(\"Enter a CSV string: \")\n",
    "lines = csv_string.split('\\n')\n",
    "csv_list = [line.split(',') for line in lines]\n",
    "\n",
    "print(\"CSV list:\", csv_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b006b7d3-9753-4f32-b66b-579f854fdccc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#LIST BASED QS "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5bc0f2aa-56be-47ff-b90b-819f3732570c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# LIST-Q1: Create a list with integers from 1 to 10.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "print(\"Integer list:\", integer_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "45a7002e-9a5a-4714-8da2-eb06fd753f6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the list: 10\n"
     ]
    }
   ],
   "source": [
    "# Q2: Find the length of a list without using the len() function.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Initialize a variable to store the length of the list\n",
    "list_length = 0\n",
    "\n",
    "# Iterate through each element in the list\n",
    "for _ in integer_list:\n",
    "    list_length += 1\n",
    "\n",
    "print(\"Length of the list:\", list_length)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9cc971e8-ac5f-429c-9a7f-e890c06ebda8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Q3: Append an element to the end of a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Append an element to the end of the list\n",
    "new_element = 6\n",
    "integer_list.append(new_element)\n",
    "\n",
    "print(\"Updated list:\", integer_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "81f005e2-428a-4276-8e52-e0cb33ba4350",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Q4: Insert an element at a specific index in a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 5, 6]\n",
    "\n",
    "# Insert an element at a specific index\n",
    "element_to_insert = 4\n",
    "index_to_insert = 3  # Index where the element will be inserted\n",
    "integer_list.insert(index_to_insert, element_to_insert)\n",
    "\n",
    "print(\"Updated list:\", integer_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f3c8df12-5b14-4796-8f4e-49ab2a54d099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list: [1, 2, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q5: Remove an element from a list by its value.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Remove an element by its value\n",
    "element_to_remove = 3\n",
    "integer_list.remove(element_to_remove)\n",
    "\n",
    "print(\"Updated list:\", integer_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "984587f3-86bb-4b3e-ae34-5f1c7c82956f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated list: [1, 2, 4, 5]\n",
      "Removed element: 3\n"
     ]
    }
   ],
   "source": [
    "# Q6: Remove an element from a list by its index.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Remove an element by its index\n",
    "index_to_remove = 2  # Index of the element to be removed\n",
    "removed_element = integer_list.pop(index_to_remove)\n",
    "\n",
    "print(\"Updated list:\", integer_list)\n",
    "print(\"Removed element:\", removed_element)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ec30e439-a5b1-4755-b1ed-395811287045",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 exists in the list.\n"
     ]
    }
   ],
   "source": [
    "# Q7: Check if an element exists in a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Check if an element exists in the list\n",
    "element_to_check = 3\n",
    "if element_to_check in integer_list:\n",
    "    print(f\"{element_to_check} exists in the list.\")\n",
    "else:\n",
    "    print(f\"{element_to_check} does not exist in the list.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "43ee390e-7a7b-4b37-bc73-87840a4a9ccc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The index of the first occurrence of 3 is: 2\n"
     ]
    }
   ],
   "source": [
    "# Q8: Find the index of the first occurrence of an element in a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5, 3, 6]\n",
    "\n",
    "# Find the index of the first occurrence of an element\n",
    "element_to_find = 3\n",
    "index = integer_list.index(element_to_find)\n",
    "\n",
    "print(f\"The index of the first occurrence of {element_to_find} is:\", index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "645df6dd-3d98-48b6-8834-bfe8e51858b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The element 3 appears 2 times in the list.\n"
     ]
    }
   ],
   "source": [
    "# Q9: Count the occurrences of an element in a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5, 3, 6]\n",
    "\n",
    "# Count the occurrences of an element\n",
    "element_to_count = 3\n",
    "count = integer_list.count(element_to_count)\n",
    "\n",
    "print(f\"The element {element_to_count} appears {count} times in the list.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f023cbdf-0711-44a9-b0f2-dc523c8f4b3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed list: [5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# Q10: Reverse the order of elements in a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Reverse the order of elements\n",
    "integer_list.reverse()\n",
    "\n",
    "print(\"Reversed list:\", integer_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "78d02cf8-f251-404f-a624-da4f69f9b1a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list in ascending order: [1, 2, 3, 5, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "# Q11: Sort a list in ascending order.\n",
    "\n",
    "integer_list = [5, 2, 8, 1, 7, 3]\n",
    "integer_list.sort()\n",
    "\n",
    "print(\"Sorted list in ascending order:\", integer_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a687e007-c43e-41f8-b518-2273aa1b03b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list in descending order: [8, 7, 5, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# Q12: Sort a list in descending order.\n",
    "\n",
    "integer_list = [5, 2, 8, 1, 7, 3]\n",
    "integer_list.sort(reverse=True)\n",
    "\n",
    "print(\"Sorted list in descending order:\", integer_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9d1e4f69-6548-4506-ad9d-ceefde13e720",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of even numbers: [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",
    "even_numbers = [num for num in range(2, 21, 2)]\n",
    "\n",
    "print(\"List of even numbers:\", even_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fa11d94d-7f5f-4c75-a4ad-f54f7a9d2b8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of odd numbers: [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",
    "odd_numbers = [num for num in range(1, 21, 2)]\n",
    "\n",
    "print(\"List of odd numbers:\", odd_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "91047e04-401d-49e1-aa75-6cc5b1e99113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of elements: 15\n"
     ]
    }
   ],
   "source": [
    "# Q15: Find the sum of all elements in a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "sum_of_elements = sum(integer_list)\n",
    "\n",
    "print(\"Sum of elements:\", sum_of_elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "89dd4d76-ecc9-4466-935b-5650e8064ab3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value: 8\n"
     ]
    }
   ],
   "source": [
    "# Q16: Find the maximum value in a list.\n",
    "\n",
    "integer_list = [5, 2, 8, 1, 7, 3]\n",
    "max_value = max(integer_list)\n",
    "\n",
    "print(\"Maximum value:\", max_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bde01699-c0a3-420a-b7c4-53aee353ba66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value: 1\n"
     ]
    }
   ],
   "source": [
    "# Q17: Find the minimum value in a list.\n",
    "\n",
    "integer_list = [5, 2, 8, 1, 7, 3]\n",
    "min_value = min(integer_list)\n",
    "\n",
    "print(\"Minimum value:\", min_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d8f017dc-e2c1-4501-90d3-0e9f75c6792c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of squares: [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",
    "squares = [num ** 2 for num in range(1, 11)]\n",
    "\n",
    "print(\"List of squares:\", squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9d57818d-61ca-4ecf-bb22-b16295009bd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of random numbers: [78, 49, 48, 21, 75, 8, 31, 16, 67, 24]\n"
     ]
    }
   ],
   "source": [
    "# Q19: Create a list of random numbers.\n",
    "\n",
    "import random\n",
    "\n",
    "random_numbers = [random.randint(1, 100) for _ in range(10)]\n",
    "\n",
    "print(\"List of random numbers:\", random_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8d4e6a37-38d7-4cfd-8c3b-458bfec6f0e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with duplicates removed: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Q20: Remove duplicates from a list.\n",
    "\n",
    "duplicate_list = [1, 2, 2, 3, 4, 4, 5, 5, 6]\n",
    "unique_list = list(set(duplicate_list))\n",
    "\n",
    "print(\"List with duplicates removed:\", unique_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4519ab7f-eb44-44ba-96fa-d2add8f2ea09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements: [3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q21: Find the common elements between two lists.\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [3, 4, 5, 6, 7]\n",
    "\n",
    "common_elements = [element for element in list1 if element in list2]\n",
    "\n",
    "print(\"Common elements:\", common_elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5b1912e8-d38a-4922-a0d7-b2a994f11756",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference between lists: [1, 2]\n"
     ]
    }
   ],
   "source": [
    "# Q22: Find the difference between two lists.\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [3, 4, 5, 6, 7]\n",
    "\n",
    "difference = [element for element in list1 if element not in list2]\n",
    "\n",
    "print(\"Difference between lists:\", difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "68aa658c-618c-4198-a6ec-606519d14541",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged list: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Q23: Merge two lists.\n",
    "\n",
    "list1 = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "\n",
    "merged_list = list1 + list2\n",
    "\n",
    "print(\"Merged list:\", merged_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "03be6d65-f7c1-4a64-b68b-969735537e72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with elements multiplied by 2: [2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Q24: Multiply all elements in a list by 2.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "doubled_list = [element * 2 for element in integer_list]\n",
    "\n",
    "print(\"List with elements multiplied by 2:\", doubled_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c35e1468-380a-4c96-adf6-acf859e4bd38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with odd numbers: [1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# Q25: Filter out all even numbers from a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "odd_numbers = [element for element in integer_list if element % 2 != 0]\n",
    "\n",
    "print(\"List with odd numbers:\", odd_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3dea9432-68cd-4f56-a3e8-eadeb7c82200",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of integers: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q26: Convert a list of strings to a list of integers.\n",
    "\n",
    "string_list = [\"1\", \"2\", \"3\", \"4\", \"5\"]\n",
    "integer_list = [int(element) for element in string_list]\n",
    "\n",
    "print(\"List of integers:\", integer_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3ca17ce9-0ec9-44cd-b2e6-570a08c6bfa4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of strings: ['1', '2', '3', '4', '5']\n"
     ]
    }
   ],
   "source": [
    "# Q27: Convert a list of integers to a list of strings.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "string_list = [str(element) for element in integer_list]\n",
    "\n",
    "print(\"List of strings:\", string_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c3793a06-27ea-4a18-a7a3-6c52d3997ffa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened list: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Q28: Flatten a nested list.\n",
    "\n",
    "nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "flattened_list = [element for sublist in nested_list for element in sublist]\n",
    "\n",
    "print(\"Flattened list:\", flattened_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3ba9a885-c045-4a79-a9f6-4deacdfbefaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of Fibonacci 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 fibonacci(n):\n",
    "    fib_list = [0, 1]\n",
    "    for i in range(2, n):\n",
    "        fib_list.append(fib_list[i-1] + fib_list[i-2])\n",
    "    return fib_list\n",
    "\n",
    "fibonacci_numbers = fibonacci(10)\n",
    "\n",
    "print(\"List of Fibonacci numbers:\", fibonacci_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4abb97a2-3f41-4c35-aabe-24373b0ca4ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the list sorted? True\n"
     ]
    }
   ],
   "source": [
    "# Q30: Check if a list is sorted.\n",
    "\n",
    "def is_sorted(lst):\n",
    "    return all(lst[i] <= lst[i+1] for i in range(len(lst)-1))\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "sorted_check = is_sorted(integer_list)\n",
    "\n",
    "print(\"Is the list sorted?\", sorted_check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5054984b-2d8e-47d2-9ca1-29c2a25cc3ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated list to the left: [3, 4, 5, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# Q31: Rotate a list to the left by `n` positions.\n",
    "\n",
    "def rotate_left(lst, n):\n",
    "    n = n % len(lst)  # Handle cases where n is greater than the list length\n",
    "    return lst[n:] + lst[:n]\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "rotated_list = rotate_left(integer_list, 2)\n",
    "\n",
    "print(\"Rotated list to the left:\", rotated_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "26022b14-5db0-4f49-a4b9-ec1a679101b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated list to the right: [4, 5, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Q32: Rotate a list to the right by `n` positions.\n",
    "\n",
    "def rotate_right(lst, n):\n",
    "    n = n % len(lst)  # Handle cases where n is greater than the list length\n",
    "    return lst[-n:] + lst[:-n]\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "rotated_list = rotate_right(integer_list, 2)\n",
    "\n",
    "print(\"Rotated list to the right:\", rotated_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "25e126db-bf30-4e56-9b4e-a438f93d4771",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of prime numbers: [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",
    "def is_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",
    "prime_numbers = [num for num in range(2, 51) if is_prime(num)]\n",
    "\n",
    "print(\"List of prime numbers:\", prime_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "828e07b1-d0c7-4438-b0cb-e2f8f87e4589",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List split into chunks: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]\n"
     ]
    }
   ],
   "source": [
    "# Q34: Split a list into chunks of size `n`.\n",
    "\n",
    "def split_into_chunks(lst, n):\n",
    "    return [lst[i:i + n] for i in range(0, len(lst), n)]\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "chunk_size = 3\n",
    "chunks = split_into_chunks(integer_list, chunk_size)\n",
    "\n",
    "print(\"List split into chunks:\", chunks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f7cbbd8a-a183-4c42-8dda-8fdb40685025",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second largest number: 12\n"
     ]
    }
   ],
   "source": [
    "# Q35: Find the second largest number in a list.\n",
    "\n",
    "integer_list = [10, 5, 8, 15, 3, 12]\n",
    "sorted_list = sorted(integer_list)\n",
    "second_largest = sorted_list[-2]\n",
    "\n",
    "print(\"Second largest number:\", second_largest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "190dd962-8e33-424b-acd6-5b99caf2df67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with elements squared: [1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# Q36: Replace every element in a list with its square.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "squared_list = [element ** 2 for element in integer_list]\n",
    "\n",
    "print(\"List with elements squared:\", squared_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fed8827d-d44b-4a26-b2e4-0ba9ca91859b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dictionary: {'apple': 0, 'banana': 1, 'cherry': 2, 'date': 3}\n"
     ]
    }
   ],
   "source": [
    "# Q37: Convert a list to a dictionary where list elements become keys and their indices become values.\n",
    "\n",
    "word_list = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
    "word_dict = {word: index for index, word in enumerate(word_list)}\n",
    "\n",
    "print(\"Dictionary:\", word_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3fc93d9d-5576-4079-a94b-2b7db9e6f00a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shuffled list: [1, 2, 4, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q38: Shuffle the elements of a list randomly.\n",
    "\n",
    "import random\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "shuffled_list = random.sample(integer_list, len(integer_list))\n",
    "\n",
    "print(\"Shuffled list:\", shuffled_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e9ecf17e-08e2-4b90-8996-d5cdb355f07e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of factorial numbers: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]\n"
     ]
    }
   ],
   "source": [
    "# Q39: Create a list of the first 10 factorial numbers.\n",
    "\n",
    "def factorial(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n - 1)\n",
    "\n",
    "factorial_numbers = [factorial(i) for i in range(1, 11)]\n",
    "\n",
    "print(\"List of factorial numbers:\", factorial_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "4d392ed0-a848-48ce-8ce2-a8b8ec2368ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The two lists do not have any common elements.\n"
     ]
    }
   ],
   "source": [
    "# Q40: Check if two lists have at least one element in common.\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [6, 7, 8, 9, 10]\n",
    "common_elements = any(element in list2 for element in list1)\n",
    "\n",
    "if common_elements:\n",
    "    print(\"The two lists have at least one element in common.\")\n",
    "else:\n",
    "    print(\"The two lists do not have any common elements.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "cd1db137-8f61-4d02-a6c8-f4399f5f7f81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empty list: []\n"
     ]
    }
   ],
   "source": [
    "# Q41: Remove all elements from a list.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "integer_list.clear()\n",
    "\n",
    "print(\"Empty list:\", integer_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "2636e865-6cdd-44bf-a63e-fdf36ce66b17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with negative numbers replaced: [0, 2, 0, 4, 0]\n"
     ]
    }
   ],
   "source": [
    "# Q42: Replace negative numbers in a list with 0.\n",
    "\n",
    "numbers = [-1, 2, -3, 4, -5]\n",
    "positive_numbers = [num if num >= 0 else 0 for num in numbers]\n",
    "\n",
    "print(\"List with negative numbers replaced:\", positive_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "4aba55fe-6c0a-47a0-959d-db1d9c9816bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of words: ['Hello,', 'this', 'is', 'a', 'sentence.']\n"
     ]
    }
   ],
   "source": [
    "# Q43: Convert a string into a list of words.\n",
    "\n",
    "sentence = \"Hello, this is a sentence.\"\n",
    "word_list = sentence.split()\n",
    "\n",
    "print(\"List of words:\", word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0abd7dd1-241c-48df-80fa-937bc7458e41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted sentence: Hello this is a list of words\n"
     ]
    }
   ],
   "source": [
    "# Q44: Convert a list of words into a string.\n",
    "\n",
    "word_list = [\"Hello\", \"this\", \"is\", \"a\", \"list\", \"of\", \"words\"]\n",
    "sentence = \" \".join(word_list)\n",
    "\n",
    "print(\"Converted sentence:\", sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "756fd23a-ad52-4340-8594-1326cfef9cb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of powers of 2: [1, 2, 4, 8, 16]\n"
     ]
    }
   ],
   "source": [
    "# Q45: Create a list of the first `n` powers of 2.\n",
    "\n",
    "n = 5\n",
    "powers_of_2 = [2 ** i for i in range(n)]\n",
    "\n",
    "print(\"List of powers of 2:\", powers_of_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "8898493a-481f-460c-985e-49be83575d0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest string: banana\n"
     ]
    }
   ],
   "source": [
    "# Q46: Find the longest string in a list of strings.\n",
    "\n",
    "string_list = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
    "longest_string = max(string_list, key=len)\n",
    "\n",
    "print(\"Longest string:\", longest_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "07772854-6b11-4d35-871b-8c5821b76737",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest string: date\n"
     ]
    }
   ],
   "source": [
    "# Q47: Find the shortest string in a list of strings.\n",
    "\n",
    "string_list = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
    "shortest_string = min(string_list, key=len)\n",
    "\n",
    "print(\"Shortest string:\", shortest_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "4a75847f-1455-4d23-a084-5d7913c4b529",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of triangular numbers: [1, 3, 6, 10, 15]\n"
     ]
    }
   ],
   "source": [
    "# Q48: Create a list of the first `n` triangular numbers.\n",
    "\n",
    "def triangular_number(n):\n",
    "    return n * (n + 1) // 2\n",
    "\n",
    "n = 5\n",
    "triangular_numbers = [triangular_number(i) for i in range(1, n+1)]\n",
    "\n",
    "print(\"List of triangular numbers:\", triangular_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "0531d5ed-960e-4cb9-9bdc-b4ffbc0547b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The subsequence is present in the main list.\n"
     ]
    }
   ],
   "source": [
    "# Q49: Check if a list contains another list as a subsequence.\n",
    "\n",
    "def is_subsequence(sub, main):\n",
    "    i = 0\n",
    "    for element in main:\n",
    "        if element == sub[i]:\n",
    "            i += 1\n",
    "            if i == len(sub):\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "main_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "sub_list = [3, 5, 7]\n",
    "\n",
    "if is_subsequence(sub_list, main_list):\n",
    "    print(\"The subsequence is present in the main list.\")\n",
    "else:\n",
    "    print(\"The subsequence is not present in the main list.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "3e4418d7-cbbf-41bf-8be8-6e2e7362b40a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List after swapping: [1, 4, 3, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q50: Swap two elements in a list by their indices.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "index1, index2 = 1, 3  # Indices of the elements to be swapped\n",
    "integer_list[index1], integer_list[index2] = integer_list[index2], integer_list[index1]\n",
    "\n",
    "print(\"List after swapping:\", integer_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ff391c18-5692-4cde-8fb0-e805e21ed9e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TUPLE QS "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3f6eea79-c93b-47ca-a1f6-d43b2e46b2c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# TUPLE Q1: Create a tuple with integers from 1 to 5.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "\n",
    "print(\"Tuple:\", integer_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "e32773a7-4fdc-4bf7-b9dd-711ee40d51c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Third element: 3\n"
     ]
    }
   ],
   "source": [
    "# Q2: Access the third element of a tuple.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "third_element = integer_tuple[2]\n",
    "\n",
    "print(\"Third element:\", third_element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f967a76b-b47b-41cb-b2e0-057006b3f4db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of tuple: 5\n"
     ]
    }
   ],
   "source": [
    "# Q3: Find the length of a tuple without using the `len()` function.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "length = sum(1 for _ in integer_tuple)\n",
    "\n",
    "print(\"Length of tuple:\", length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "653e92ed-5af0-433f-816e-5138196f2bd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Occurrences of element: 3\n"
     ]
    }
   ],
   "source": [
    "# Q4: Count the occurrences of an element in a tuple.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 2, 5, 2)\n",
    "element_to_count = 2\n",
    "count = sum(1 for element in integer_tuple if element == element_to_count)\n",
    "\n",
    "print(\"Occurrences of element:\", count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "baa243c6-754b-4bd4-aa38-c02cff4d332e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index of first occurrence: 1\n"
     ]
    }
   ],
   "source": [
    "# Q5: Find the index of the first occurrence of an element in a tuple.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 2, 5, 2)\n",
    "element_to_find = 2\n",
    "index = next((i for i, element in enumerate(integer_tuple) if element == element_to_find), -1)\n",
    "\n",
    "print(\"Index of first occurrence:\", index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a20d526c-6dfa-4586-b118-08c7df5b22ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element exists in the tuple.\n"
     ]
    }
   ],
   "source": [
    "# Q6: Check if an element exists in a tuple.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "element_to_check = 3\n",
    "exists = element_to_check in integer_tuple\n",
    "\n",
    "if exists:\n",
    "    print(\"Element exists in the tuple.\")\n",
    "else:\n",
    "    print(\"Element does not exist in the tuple.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "77e9b55c-aee0-4521-a5e6-c688894798ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted list: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q7: Convert a tuple to a list.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "integer_list = list(integer_tuple)\n",
    "\n",
    "print(\"Converted list:\", integer_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "e89e6095-1c61-45d4-a86f-8bd58d13fb7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted tuple: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# Q8: Convert a list to a tuple.\n",
    "\n",
    "integer_list = [1, 2, 3, 4, 5]\n",
    "integer_tuple = tuple(integer_list)\n",
    "\n",
    "print(\"Converted tuple:\", integer_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "208e3ff6-0c92-41a9-99fb-0574f64f093b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Name: John\n",
      "Last Name: Doe\n",
      "Age: 30\n"
     ]
    }
   ],
   "source": [
    "# Q9: Unpack the elements of a tuple into variables.\n",
    "\n",
    "name_tuple = (\"John\", \"Doe\", 30)\n",
    "first_name, last_name, age = name_tuple\n",
    "\n",
    "print(\"First Name:\", first_name)\n",
    "print(\"Last Name:\", last_name)\n",
    "print(\"Age:\", age)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "1e7ce2c3-9b77-49a7-935b-e6495345124f",
   "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",
    "even_tuple = tuple(num for num in range(2, 11, 2))\n",
    "\n",
    "print(\"Tuple of even numbers:\", even_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "475f2a80-f247-4c83-bb26-b4a1dd81af2e",
   "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",
    "odd_tuple = tuple(num for num in range(1, 11) if num % 2 != 0)\n",
    "\n",
    "print(\"Tuple of odd numbers:\", odd_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "5a8c4a30-613b-4a0e-b069-00758796a633",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concatenated tuple: (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "# Q12: Concatenate two tuples.\n",
    "\n",
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (4, 5, 6)\n",
    "concatenated_tuple = tuple1 + tuple2\n",
    "\n",
    "print(\"Concatenated tuple:\", concatenated_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "5bcee8c6-bc3c-4b4b-91e3-45ad6a7c0854",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Repeated tuple: (1, 2, 3, 1, 2, 3, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Q13: Repeat a tuple three times.\n",
    "\n",
    "original_tuple = (1, 2, 3)\n",
    "repeated_tuple = original_tuple * 3\n",
    "\n",
    "print(\"Repeated tuple:\", repeated_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "53d888f8-6f0b-4efa-a688-eebde1f28184",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple is empty.\n"
     ]
    }
   ],
   "source": [
    "# Q14: Check if a tuple is empty.\n",
    "\n",
    "empty_tuple = ()\n",
    "is_empty = len(empty_tuple) == 0\n",
    "\n",
    "if is_empty:\n",
    "    print(\"The tuple is empty.\")\n",
    "else:\n",
    "    print(\"The tuple is not empty.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "9b1a0442-8037-4182-9168-8f38fb785c66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested tuple: ((1, 2), (3, 4), (5, 6))\n"
     ]
    }
   ],
   "source": [
    "# Q15: Create a nested tuple.\n",
    "\n",
    "nested_tuple = ((1, 2), (3, 4), (5, 6))\n",
    "\n",
    "print(\"Nested tuple:\", nested_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "26235f8a-584b-48de-beb0-b6be1456425c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First element of nested tuple: (1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Q16: Access the first element of a nested tuple.\n",
    "\n",
    "nested_tuple = ((1, 2), (3, 4), (5, 6))\n",
    "first_element = nested_tuple[0]\n",
    "\n",
    "print(\"First element of nested tuple:\", first_element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "e05731d1-f6cf-44f4-9df8-ec23e550054f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single element tuple: (42,)\n"
     ]
    }
   ],
   "source": [
    "# Q17: Create a tuple with a single element.\n",
    "\n",
    "single_element_tuple = (42,)\n",
    "\n",
    "print(\"Single element tuple:\", single_element_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "b8b2ac69-88ee-4c25-8b23-7c20aa76931c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuples are equal.\n"
     ]
    }
   ],
   "source": [
    "# Q18: Compare two tuples.\n",
    "\n",
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 3)\n",
    "are_equal = tuple1 == tuple2\n",
    "\n",
    "if are_equal:\n",
    "    print(\"The tuples are equal.\")\n",
    "else:\n",
    "    print(\"The tuples are not equal.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8c8823d7-9003-463c-9548-87ea95cc5699",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple has been deleted.\n"
     ]
    }
   ],
   "source": [
    "# Q19: Delete a tuple.\n",
    "\n",
    "to_be_deleted = (1, 2, 3)\n",
    "del to_be_deleted\n",
    "\n",
    "try:\n",
    "    print(to_be_deleted)  # This will raise a NameError\n",
    "except NameError:\n",
    "    print(\"The tuple has been deleted.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8dfa79b1-aeb9-45c8-abeb-f36efe36b4f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliced tuple: (2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "# Q20: Slice a tuple.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "sliced_tuple = integer_tuple[1:4]\n",
    "\n",
    "print(\"Sliced tuple:\", sliced_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "de1104c4-f1de-4343-a56f-58e7c675469f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value: 67\n"
     ]
    }
   ],
   "source": [
    "# Q21: Find the maximum value in a tuple.\n",
    "\n",
    "number_tuple = (12, 45, 23, 67, 34)\n",
    "maximum_value = max(number_tuple)\n",
    "\n",
    "print(\"Maximum value:\", maximum_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "45963bee-d591-43b4-969e-cf7d26279511",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value: 12\n"
     ]
    }
   ],
   "source": [
    "# Q22: Find the minimum value in a tuple.\n",
    "\n",
    "number_tuple = (12, 45, 23, 67, 34)\n",
    "minimum_value = min(number_tuple)\n",
    "\n",
    "print(\"Minimum value:\", minimum_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "78fa607b-2d3a-4b5d-8922-4309941a3288",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of characters: ('h', 'e', 'l', 'l', 'o')\n"
     ]
    }
   ],
   "source": [
    "# Q23: Convert a string to a tuple of characters.\n",
    "\n",
    "string = \"hello\"\n",
    "char_tuple = tuple(string)\n",
    "\n",
    "print(\"Tuple of characters:\", char_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "6c0d66a7-c2c1-4a51-ad94-e3a8d5256259",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted string: hello\n"
     ]
    }
   ],
   "source": [
    "# Q24: Convert a tuple of characters to a string.\n",
    "\n",
    "char_tuple = ('h', 'e', 'l', 'l', 'o')\n",
    "string = ''.join(char_tuple)\n",
    "\n",
    "print(\"Converted string:\", string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "a0a92d2e-09e0-4149-8c31-d3365a4d6947",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mixed tuple: (1, 'hello', 3.14, True)\n"
     ]
    }
   ],
   "source": [
    "# Q25: Create a tuple from multiple data types.\n",
    "\n",
    "mixed_tuple = (1, \"hello\", 3.14, True)\n",
    "\n",
    "print(\"Mixed tuple:\", mixed_tuple)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f37e399c-730d-4e3f-b9ad-2278b7c6ccb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuples are not identical.\n"
     ]
    }
   ],
   "source": [
    "# Q26: Check if two tuples are identical.\n",
    "\n",
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (1, 2, 3)\n",
    "are_identical = tuple1 is tuple2\n",
    "\n",
    "if are_identical:\n",
    "    print(\"The tuples are identical.\")\n",
    "else:\n",
    "    print(\"The tuples are not identical.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5770c3d8-a0ab-41d3-a3b1-9685d1ff4fea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted tuple: (12, 23, 34, 45, 67)\n"
     ]
    }
   ],
   "source": [
    "# Q27: Sort the elements of a tuple.\n",
    "\n",
    "number_tuple = (12, 45, 23, 67, 34)\n",
    "sorted_tuple = tuple(sorted(number_tuple))\n",
    "\n",
    "print(\"Sorted tuple:\", sorted_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aa443f83-c8bf-467e-bb89-97c7335cb00b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of strings: ('1', '2', '3', '4', '5')\n"
     ]
    }
   ],
   "source": [
    "# Q28: Convert a tuple of integers to a tuple of strings.\n",
    "\n",
    "integer_tuple = (1, 2, 3, 4, 5)\n",
    "string_tuple = tuple(str(num) for num in integer_tuple)\n",
    "\n",
    "print(\"Tuple of strings:\", string_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1f8916c9-34b2-4a5c-8433-470ece2e968f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of integers: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# Q29: Convert a tuple of strings to a tuple of integers.\n",
    "\n",
    "string_tuple = ('1', '2', '3', '4', '5')\n",
    "integer_tuple = tuple(int(s) for s in string_tuple)\n",
    "\n",
    "print(\"Tuple of integers:\", integer_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b8184af2-b04d-4c80-aff6-75170c4dfb70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged tuple: (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "# Q30: Merge two tuples.\n",
    "\n",
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (4, 5, 6)\n",
    "merged_tuple = tuple1 + tuple2\n",
    "\n",
    "print(\"Merged tuple:\", merged_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b9f156c5-ff40-47c9-8744-52db1b9f4594",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened tuple: (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "# Q31: Flatten a nested tuple.\n",
    "\n",
    "nested_tuple = ((1, 2), (3, 4), (5, 6))\n",
    "flattened_tuple = tuple(element for sub_tuple in nested_tuple for element in sub_tuple)\n",
    "\n",
    "print(\"Flattened tuple:\", flattened_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9c9b150a-5e91-4c80-a7e7-d9dbf0175ed3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of prime numbers: (2, 3, 5, 7, 11)\n"
     ]
    }
   ],
   "source": [
    "# Q32: Create a tuple of the first 5 prime numbers.\n",
    "\n",
    "def is_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 = 5\n",
    "prime_tuple = tuple(num for num in range(2, 100) if is_prime(num))[:n]\n",
    "\n",
    "print(\"Tuple of prime numbers:\", prime_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "997e1307-4df2-4c40-8677-1636bde48eb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple is a palindrome.\n"
     ]
    }
   ],
   "source": [
    "# Q33: Check if a tuple is a palindrome.\n",
    "\n",
    "def is_palindrome(data):\n",
    "    return data == data[::-1]\n",
    "\n",
    "palindrome_tuple = (1, 2, 3, 2, 1)\n",
    "is_palindrome_result = is_palindrome(palindrome_tuple)\n",
    "\n",
    "if is_palindrome_result:\n",
    "    print(\"The tuple is a palindrome.\")\n",
    "else:\n",
    "    print(\"The tuple is not a palindrome.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e9ba56cc-d8b0-4d85-b814-d4ff5fdc499d",
   "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",
    "squares_tuple = tuple(num ** 2 for num in range(1, 6))\n",
    "\n",
    "print(\"Tuple of squares:\", squares_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2dbe32a9-ff89-4ec1-8b03-07dabbb4e6f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of odd numbers: (1, 3, 5, 7, 9)\n"
     ]
    }
   ],
   "source": [
    "# Q35: Filter out all even numbers from a tuple.\n",
    "\n",
    "number_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
    "odd_tuple = tuple(num for num in number_tuple if num % 2 != 0)\n",
    "\n",
    "print(\"Tuple of odd numbers:\", odd_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c4ddb99b-3364-4728-b6e3-0bda38c38c10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple with elements doubled: (2, 4, 6, 8, 10)\n"
     ]
    }
   ],
   "source": [
    "# Q36: Multiply all elements in a tuple by 2.\n",
    "\n",
    "number_tuple = (1, 2, 3, 4, 5)\n",
    "doubled_tuple = tuple(num * 2 for num in number_tuple)\n",
    "\n",
    "print(\"Tuple with elements doubled:\", doubled_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fc1793cd-745c-40b0-8859-8421fb376355",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of random numbers: (98, 44, 43, 12, 50)\n"
     ]
    }
   ],
   "source": [
    "# Q37: Create a tuple of random numbers.\n",
    "\n",
    "import random\n",
    "\n",
    "random_tuple = tuple(random.randint(1, 100) for _ in range(5))\n",
    "\n",
    "print(\"Tuple of random numbers:\", random_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a9a78f67-dc6c-4681-b2f7-ac8578a68c26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tuple is sorted.\n",
      "The tuple is not sorted.\n"
     ]
    }
   ],
   "source": [
    "# Q38: Check if a tuple is sorted.\n",
    "\n",
    "def is_sorted(data):\n",
    "    return data == tuple(sorted(data))\n",
    "\n",
    "sorted_tuple = (1, 2, 3, 4, 5)\n",
    "unsorted_tuple = (5, 2, 3, 1, 4)\n",
    "\n",
    "if is_sorted(sorted_tuple):\n",
    "    print(\"The tuple is sorted.\")\n",
    "else:\n",
    "    print(\"The tuple is not sorted.\")\n",
    "\n",
    "if is_sorted(unsorted_tuple):\n",
    "    print(\"The tuple is sorted.\")\n",
    "else:\n",
    "    print(\"The tuple is not sorted.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "81303a26-4586-4b59-95d8-07b1f3df5939",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated tuple (left): (3, 4, 5, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Q39: Rotate a tuple to the left by `n` positions.\n",
    "\n",
    "def rotate_left(data, n):\n",
    "    n = n % len(data)\n",
    "    return data[n:] + data[:n]\n",
    "\n",
    "number_tuple = (1, 2, 3, 4, 5)\n",
    "rotated_tuple = rotate_left(number_tuple, 2)\n",
    "\n",
    "print(\"Rotated tuple (left):\", rotated_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b49146bc-13a9-4558-a94d-1746378d5ff5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rotated tuple (right): (4, 5, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Q40: Rotate a tuple to the right by `n` positions.\n",
    "\n",
    "def rotate_right(data, n):\n",
    "    n = n % len(data)\n",
    "    return data[-n:] + data[:-n]\n",
    "\n",
    "number_tuple = (1, 2, 3, 4, 5)\n",
    "rotated_tuple = rotate_right(number_tuple, 2)\n",
    "\n",
    "print(\"Rotated tuple (right):\", rotated_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5a61728f-81ac-4db2-af49-3a528b06f967",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of Fibonacci numbers: (0, 1, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Q41: Create a tuple of the first 5 Fibonacci numbers.\n",
    "\n",
    "def fibonacci(n):\n",
    "    fib_sequence = [0, 1]\n",
    "    while len(fib_sequence) < n:\n",
    "        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])\n",
    "    return tuple(fib_sequence)\n",
    "\n",
    "n = 5\n",
    "fibonacci_tuple = fibonacci(n)\n",
    "\n",
    "print(\"Tuple of Fibonacci numbers:\", fibonacci_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d1849de9-1cc9-49ef-9571-001ed97270f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter comma-separated values:  5,10,15,20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User input tuple: (5, 10, 15, 20)\n"
     ]
    }
   ],
   "source": [
    "# Q42: Create a tuple from user input.\n",
    "\n",
    "input_string = input(\"Enter comma-separated values: \")\n",
    "user_tuple = tuple(map(int, input_string.split(',')))\n",
    "\n",
    "print(\"User input tuple:\", user_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a4d275a3-8af6-4dbb-9f16-961d8e9fd956",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple after swapping: (1, 4, 3, 2, 5)\n"
     ]
    }
   ],
   "source": [
    "# Q43: Swap two elements in a tuple.\n",
    "\n",
    "number_tuple = (1, 2, 3, 4, 5)\n",
    "index1, index2 = 1, 3\n",
    "swap_list = list(number_tuple)\n",
    "swap_list[index1], swap_list[index2] = swap_list[index2], swap_list[index1]\n",
    "swapped_tuple = tuple(swap_list)\n",
    "\n",
    "print(\"Tuple after swapping:\", swapped_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7c99f74f-aec9-476f-85e4-60c8bf5bd657",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed tuple: (5, 4, 3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "# Q44: Reverse the elements of a tuple.\n",
    "\n",
    "number_tuple = (1, 2, 3, 4, 5)\n",
    "reversed_tuple = tuple(reversed(number_tuple))\n",
    "\n",
    "print(\"Reversed tuple:\", reversed_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6378dcb4-7fee-4468-88c0-8ca8481b3937",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of powers of 2: (1, 2, 4, 8, 16)\n"
     ]
    }
   ],
   "source": [
    "# Q45: Create a tuple of the first `n` powers of 2.\n",
    "\n",
    "n = 5\n",
    "powers_of_2_tuple = tuple(2 ** i for i in range(n))\n",
    "\n",
    "print(\"Tuple of powers of 2:\", powers_of_2_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b23c8c04-175a-42a4-9e90-0018c5468e1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest string: banana\n"
     ]
    }
   ],
   "source": [
    "# Q46: Find the longest string in a tuple of strings.\n",
    "\n",
    "string_tuple = (\"apple\", \"banana\", \"cherry\", \"date\")\n",
    "longest_string = max(string_tuple, key=len)\n",
    "\n",
    "print(\"Longest string:\", longest_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ebf2ccb8-a2ea-41dc-b2f0-8979dd330e0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest string: date\n"
     ]
    }
   ],
   "source": [
    "# Q47: Find the shortest string in a tuple of strings.\n",
    "\n",
    "string_tuple = (\"apple\", \"banana\", \"cherry\", \"date\")\n",
    "shortest_string = min(string_tuple, key=len)\n",
    "\n",
    "print(\"Shortest string:\", shortest_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4d0bd9b3-ef20-4d3a-b614-f9e170f26f9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple of triangular numbers: (1, 3, 6, 10, 15)\n"
     ]
    }
   ],
   "source": [
    "# Q48: Create a tuple of the first `n` triangular numbers.\n",
    "\n",
    "def triangular_number(n):\n",
    "    return n * (n + 1) // 2\n",
    "\n",
    "n = 5\n",
    "triangular_numbers_tuple = tuple(triangular_number(i) for i in range(1, n + 1))\n",
    "\n",
    "print(\"Tuple of triangular numbers:\", triangular_numbers_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "b74d5686-b6ca-4c12-826c-8993bbacf954",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The main tuple does not contain the sub tuple.\n"
     ]
    }
   ],
   "source": [
    "# Q49: Check if a tuple contains another tuple as a subsequence.\n",
    "\n",
    "main_tuple = (1, 2, (3, 4), 5, 6)\n",
    "sub_tuple = (3, 4)\n",
    "\n",
    "contains_sub_tuple = any(sub_tuple == main_tuple[i:i+len(sub_tuple)] for i in range(len(main_tuple) - len(sub_tuple) + 1))\n",
    "\n",
    "if contains_sub_tuple:\n",
    "    print(\"The main tuple contains the sub tuple.\")\n",
    "else:\n",
    "    print(\"The main tuple does not contain the sub tuple.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9f933fca-c43e-47e6-bf86-e1a46ad97fe9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The main tuple does not contain the sub tuple.\n"
     ]
    }
   ],
   "source": [
    "# Q49: Check if a tuple contains another tuple as a subsequence.\n",
    "\n",
    "main_tuple = (1, 2, (3, 4), 5, 6)\n",
    "sub_tuple = (3, 4)\n",
    "\n",
    "contains_sub_tuple = any(sub_tuple == main_tuple[i:i+len(sub_tuple)] for i in range(len(main_tuple) - len(sub_tuple) + 1))\n",
    "\n",
    "if contains_sub_tuple:\n",
    "    print(\"The main tuple contains the sub tuple.\")\n",
    "else:\n",
    "    print(\"The main tuple does not contain the sub tuple.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "559a4a17-aa55-4f7f-9201-d6ac91539fb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SET QS "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0371e87e-d8ac-4184-8720-2adeb3026550",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integer set: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q1: Create a set with integers from 1 to 5.\n",
    "\n",
    "integer_set = {1, 2, 3, 4, 5}\n",
    "\n",
    "print(\"Integer set:\", integer_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d9a904c8-5f12-4245-bd71-63bb9ad52ecf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated set: {1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "# Q2: Add an element to a set.\n",
    "\n",
    "integer_set = {1, 2, 3}\n",
    "integer_set.add(4)\n",
    "\n",
    "print(\"Updated set:\", integer_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "33d33f0e-05af-4059-8358-93694fb8f8e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated set: {1, 2, 4}\n"
     ]
    }
   ],
   "source": [
    "# Q3: Remove an element from a set.\n",
    "\n",
    "integer_set = {1, 2, 3, 4}\n",
    "integer_set.remove(3)\n",
    "\n",
    "print(\"Updated set:\", integer_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4365cd0f-f4b5-4b6d-91ca-89ab128f7fa2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element exists in the set.\n"
     ]
    }
   ],
   "source": [
    "# Q4: Check if an element exists in a set.\n",
    "\n",
    "integer_set = {1, 2, 3, 4}\n",
    "element_to_check = 3\n",
    "exists = element_to_check in integer_set\n",
    "\n",
    "if exists:\n",
    "    print(\"Element exists in the set.\")\n",
    "else:\n",
    "    print(\"Element does not exist in the set.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "35295a86-727c-428f-8c42-6b5691278b6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the set: 5\n"
     ]
    }
   ],
   "source": [
    "# Q5: Find the length of a set without using the `len()` function.\n",
    "\n",
    "integer_set = {1, 2, 3, 4, 5}\n",
    "length = sum(1 for _ in integer_set)\n",
    "\n",
    "print(\"Length of the set:\", length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "6cd902c5-5639-45ff-b316-efcf89550213",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cleared set: set()\n"
     ]
    }
   ],
   "source": [
    "# Q6: Clear all elements from a set.\n",
    "\n",
    "integer_set = {1, 2, 3, 4, 5}\n",
    "integer_set.clear()\n",
    "\n",
    "print(\"Cleared set:\", integer_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "615e1518-42ee-4cfb-9f9b-6d3b84723a91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of even numbers: {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "# Q7: Create a set of even numbers from 1 to 10.\n",
    "\n",
    "even_set = {num for num in range(2, 11, 2)}\n",
    "\n",
    "print(\"Set of even numbers:\", even_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "259c645d-d885-4785-844a-7a2cb5c177a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of odd numbers: {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "# Q8: Create a set of odd numbers from 1 to 10.\n",
    "\n",
    "odd_set = {num for num in range(1, 11, 2)}\n",
    "\n",
    "print(\"Set of odd numbers:\", odd_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8b78ef1b-f2ab-4726-a34e-a8cc8262f006",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of sets: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q9: Find the union of two sets.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "union_set = set1.union(set2)\n",
    "\n",
    "print(\"Union of sets:\", union_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "93e8e943-60c7-4763-9853-7c732454ec78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection of sets: {3}\n"
     ]
    }
   ],
   "source": [
    "# Q10: Find the intersection of two sets.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "intersection_set = set1.intersection(set2)\n",
    "\n",
    "print(\"Intersection of sets:\", intersection_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "224e171e-911a-4b7e-a2df-87d986859de6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference of sets: {1, 2}\n"
     ]
    }
   ],
   "source": [
    "# Q11: Find the difference between two sets.\n",
    "\n",
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {3, 4, 5}\n",
    "difference_set = set1.difference(set2)\n",
    "\n",
    "print(\"Difference of sets:\", difference_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "f7a92e75-c1e3-4acc-a7bd-c0c0b054a94a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set1 is a subset of Set2.\n"
     ]
    }
   ],
   "source": [
    "# Q12: Check if a set is a subset of another set.\n",
    "\n",
    "set1 = {1, 2}\n",
    "set2 = {1, 2, 3, 4}\n",
    "is_subset = set1.issubset(set2)\n",
    "\n",
    "if is_subset:\n",
    "    print(\"Set1 is a subset of Set2.\")\n",
    "else:\n",
    "    print(\"Set1 is not a subset of Set2.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "fc2485dd-c83c-47f9-a793-731d4592d271",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set1 is a superset of Set2.\n"
     ]
    }
   ],
   "source": [
    "# Q13: Check if a set is a superset of another set.\n",
    "\n",
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {3, 4}\n",
    "is_superset = set1.issuperset(set2)\n",
    "\n",
    "if is_superset:\n",
    "    print(\"Set1 is a superset of Set2.\")\n",
    "else:\n",
    "    print(\"Set1 is not a superset of Set2.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2198262f-b26a-49c9-908d-d013cadb4c41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set1 is a superset of Set2.\n"
     ]
    }
   ],
   "source": [
    "# Q13: Check if a set is a superset of another set.\n",
    "\n",
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {3, 4}\n",
    "is_superset = set1.issuperset(set2)\n",
    "\n",
    "if is_superset:\n",
    "    print(\"Set1 is a superset of Set2.\")\n",
    "else:\n",
    "    print(\"Set1 is not a superset of Set2.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "6e125feb-036f-4795-b650-24c02e417733",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created set from list: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q14: Create a set from a list.\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_set = set(my_list)\n",
    "\n",
    "print(\"Created set from list:\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "4a4ff7b3-7171-46e7-83e4-9b0c3b3418d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted list: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q15: Convert a set to a list.\n",
    "\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_list = list(my_set)\n",
    "\n",
    "print(\"Converted list:\", my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "88101fcf-b24f-4573-a7a2-17c15ac041c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after removing a random element: {1, 2, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q16: Remove a random element from a set.\n",
    "\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "random_element = random.choice(list(my_set))\n",
    "my_set.remove(random_element)\n",
    "\n",
    "print(\"Set after removing a random element:\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d877da3b-f359-44e9-aa44-cec31f05747f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after popping an element: {2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q17: Pop an element from a set.\n",
    "\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "popped_element = my_set.pop()\n",
    "\n",
    "print(\"Set after popping an element:\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "26503fd0-4a78-4b5b-ba08-9191acbe7d6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets have no elements in common.\n"
     ]
    }
   ],
   "source": [
    "# Q18: Check if two sets have no elements in common.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "no_common_elements = set1.isdisjoint(set2)\n",
    "\n",
    "if no_common_elements:\n",
    "    print(\"The sets have no elements in common.\")\n",
    "else:\n",
    "    print(\"The sets have elements in common.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f7ea47b1-128d-48ed-ac82-4b68349da423",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symmetric difference of sets: {1, 2, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q19: Find the symmetric difference between two sets.\n",
    "\n",
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {3, 4, 5}\n",
    "symmetric_difference = set1.symmetric_difference(set2)\n",
    "\n",
    "print(\"Symmetric difference of sets:\", symmetric_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "eac7e734-1fe1-453c-8a03-1c9457213769",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated set1: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q20: Update a set with elements from another set.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set1.update(set2)\n",
    "\n",
    "print(\"Updated set1:\", set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1904e62e-59fd-4171-b19e-dbcecc872dcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of prime numbers: {2, 3, 5, 7, 11}\n"
     ]
    }
   ],
   "source": [
    "# Q21: Create a set of the first 5 prime numbers.\n",
    "\n",
    "prime_set = {2, 3, 5, 7, 11}\n",
    "\n",
    "print(\"Set of prime numbers:\", prime_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "b01e11fa-82e4-4fc7-a790-a43c62bff026",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets are identical.\n"
     ]
    }
   ],
   "source": [
    "# Q22: Check if two sets are identical.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 2, 1}\n",
    "are_identical = set1 == set2\n",
    "\n",
    "if are_identical:\n",
    "    print(\"The sets are identical.\")\n",
    "else:\n",
    "    print(\"The sets are not identical.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0e304d93-e69b-493b-978a-9963b56aefe2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frozen set: frozenset({1, 2, 3, 4, 5})\n"
     ]
    }
   ],
   "source": [
    "# Q23: Create a frozen set.\n",
    "\n",
    "frozen_set = frozenset({1, 2, 3, 4, 5})\n",
    "\n",
    "print(\"Frozen set:\", frozen_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "c20dfbbe-682e-4e7f-9c60-7102402d1aea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets are disjoint.\n"
     ]
    }
   ],
   "source": [
    "# Q24: Check if a set is disjoint with another set.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "is_disjoint = set1.isdisjoint(set2)\n",
    "\n",
    "if is_disjoint:\n",
    "    print(\"The sets are disjoint.\")\n",
    "else:\n",
    "    print(\"The sets are not disjoint.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "9815b590-054f-49e0-a7b8-fb503ff63293",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of squares: {1, 4, 9, 16, 25}\n"
     ]
    }
   ],
   "source": [
    "# Q25: Create a set of squares of numbers from 1 to 5.\n",
    "\n",
    "squares_set = {num ** 2 for num in range(1, 6)}\n",
    "\n",
    "print(\"Set of squares:\", squares_set)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "41523d9f-373b-48ba-bee7-ef88a09abc71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of odd numbers: {1, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q26: Filter out all even numbers from a set.\n",
    "\n",
    "number_set = {1, 2, 3, 4, 5, 6}\n",
    "odd_set = {num for num in number_set if num % 2 != 0}\n",
    "\n",
    "print(\"Set of odd numbers:\", odd_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "488e41a9-bd77-47b0-bda8-8424571ea3c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set with elements doubled: {2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "# Q27: Multiply all elements in a set by 2.\n",
    "\n",
    "number_set = {1, 2, 3, 4, 5}\n",
    "doubled_set = {num * 2 for num in number_set}\n",
    "\n",
    "print(\"Set with elements doubled:\", doubled_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "41152edf-f7bd-4f08-99cf-d3ecc0c96533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of random numbers: {65, 97, 70, 7, 22}\n"
     ]
    }
   ],
   "source": [
    "# Q28: Create a set of random numbers.\n",
    "\n",
    "random_set = {random.randint(1, 100) for _ in range(5)}\n",
    "\n",
    "print(\"Set of random numbers:\", random_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "1f0b2336-f3a4-43c1-8dfd-3dccb2f73602",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The set is empty.\n"
     ]
    }
   ],
   "source": [
    "# Q29: Check if a set is empty.\n",
    "\n",
    "empty_set = set()\n",
    "\n",
    "if not empty_set:\n",
    "    print(\"The set is empty.\")\n",
    "else:\n",
    "    print(\"The set is not empty.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "827cd53f-8ab3-4769-aca5-38f419ae9d51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested set: {frozenset({3, 4}), frozenset({1, 2})}\n"
     ]
    }
   ],
   "source": [
    "# Q30: Create a nested set (hint: use frozenset).\n",
    "\n",
    "nested_set = {frozenset({1, 2}), frozenset({3, 4})}\n",
    "\n",
    "print(\"Nested set:\", nested_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "db46102a-389e-421b-8e7b-c602dbab2850",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set after removing element: {1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q31: Remove an element from a set using the discard method.\n",
    "\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "element_to_remove = 3\n",
    "my_set.discard(element_to_remove)\n",
    "\n",
    "print(\"Set after removing element:\", my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "181357b8-8aef-4888-acae-e8538846519c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets are not equal.\n"
     ]
    }
   ],
   "source": [
    "# Q32: Compare two sets.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {2, 3, 4}\n",
    "are_equal = set1 == set2\n",
    "\n",
    "if are_equal:\n",
    "    print(\"The sets are equal.\")\n",
    "else:\n",
    "    print(\"The sets are not equal.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "64305ca6-a063-41d9-b251-ee7ac581c3e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set from string: {'h', 'o', 'l', 'e'}\n"
     ]
    }
   ],
   "source": [
    "# Q33: Create a set from a string.\n",
    "\n",
    "my_string = \"hello\"\n",
    "string_set = set(my_string)\n",
    "\n",
    "print(\"Set from string:\", string_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "6c8127a0-bd9b-46b3-a7a5-be7507381898",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of integers: {1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# Q34: Convert a set of strings to a set of integers.\n",
    "\n",
    "string_set = {\"1\", \"2\", \"3\"}\n",
    "integer_set = {int(item) for item in string_set}\n",
    "\n",
    "print(\"Set of integers:\", integer_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "cfea91b0-0ba7-47a6-aca9-2e54419e31a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of strings: {'1', '2', '3'}\n"
     ]
    }
   ],
   "source": [
    "# Q35: Convert a set of integers to a set of strings.\n",
    "\n",
    "integer_set = {1, 2, 3}\n",
    "string_set = {str(item) for item in integer_set}\n",
    "\n",
    "print(\"Set of strings:\", string_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "12bf6f63-490b-402a-87de-1a99df31195d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set from tuple: {1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q36: Create a set from a tuple.\n",
    "\n",
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "tuple_set = set(my_tuple)\n",
    "\n",
    "print(\"Set from tuple:\", tuple_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d7bffb33-7593-4cd4-8231-b14db7e4991d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple from set: (1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# Q37: Convert a set to a tuple.\n",
    "\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "set_tuple = tuple(my_set)\n",
    "\n",
    "print(\"Tuple from set:\", set_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "a4d48a1d-499c-482a-b04b-cde70bdf2da8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value: 5\n"
     ]
    }
   ],
   "source": [
    "# Q38: Find the maximum value in a set.\n",
    "\n",
    "number_set = {3, 1, 5, 2, 4}\n",
    "max_value = max(number_set)\n",
    "\n",
    "print(\"Maximum value:\", max_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e43acc0c-9521-4f12-be40-998a93e8c09f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value: 1\n"
     ]
    }
   ],
   "source": [
    "# Q39: Find the minimum value in a set.\n",
    "\n",
    "number_set = {3, 1, 5, 2, 4}\n",
    "min_value = min(number_set)\n",
    "\n",
    "print(\"Minimum value:\", min_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "93cb1cd2-6600-4879-a8e3-7083f1fa9239",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter elements separated by spaces:  A Q W E\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User set: {'E', 'A', 'W', 'Q'}\n"
     ]
    }
   ],
   "source": [
    "# Q40: Create a set from user input.\n",
    "\n",
    "user_input = input(\"Enter elements separated by spaces: \")\n",
    "user_list = user_input.split()\n",
    "user_set = set(user_list)\n",
    "\n",
    "print(\"User set:\", user_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "5b091af1-a7a9-477f-87e7-92ee17c3be03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The intersection is empty.\n"
     ]
    }
   ],
   "source": [
    "# Q41: Check if the intersection of two sets is empty.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "intersection_empty = len(set1.intersection(set2)) == 0\n",
    "\n",
    "if intersection_empty:\n",
    "    print(\"The intersection is empty.\")\n",
    "else:\n",
    "    print(\"The intersection is not empty.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "4230a6a0-6462-4c6d-89da-5780d08fc5b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of Fibonacci numbers: {0, 1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# Q42: Create a set of the first 5 Fibonacci numbers.\n",
    "\n",
    "def generate_fibonacci(n):\n",
    "    fibonacci = [0, 1]\n",
    "    for i in range(2, n):\n",
    "        next_fib = fibonacci[i-1] + fibonacci[i-2]\n",
    "        fibonacci.append(next_fib)\n",
    "    return fibonacci\n",
    "\n",
    "n = 5\n",
    "fibonacci_set = set(generate_fibonacci(n))\n",
    "\n",
    "print(\"Set of Fibonacci numbers:\", fibonacci_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "bd1a442c-667f-4024-bf33-2dfbc88e6135",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List with duplicates removed: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Q43: Remove duplicates from a list using sets.\n",
    "\n",
    "original_list = [1, 2, 2, 3, 4, 4, 5]\n",
    "unique_set = set(original_list)\n",
    "unique_list = list(unique_set)\n",
    "\n",
    "print(\"List with duplicates removed:\", unique_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "8d1479ac-1764-4355-b26a-88ddeb993008",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sets have the same elements.\n"
     ]
    }
   ],
   "source": [
    "# Q44: Check if two sets have the same elements, regardless of their count.\n",
    "\n",
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {4, 3, 2, 1, 1, 2, 3, 4}\n",
    "have_same_elements = set1 == set2\n",
    "\n",
    "if have_same_elements:\n",
    "    print(\"The sets have the same elements.\")\n",
    "else:\n",
    "    print(\"The sets do not have the same elements.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "f054cc9f-ccc5-43e5-b2b3-11b80a076202",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of powers of 2: {1, 2, 4, 8, 16}\n"
     ]
    }
   ],
   "source": [
    "# Q45: Create a set of the first `n` powers of 2.\n",
    "\n",
    "n = 5\n",
    "powers_of_2_set = {2 ** i for i in range(n)}\n",
    "\n",
    "print(\"Set of powers of 2:\", powers_of_2_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "2269735c-1ea7-472b-9fa2-661256dfc31b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common elements: {3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Q46: Find the common elements between a set and a list.\n",
    "\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_list = [3, 4, 5, 6, 7]\n",
    "common_elements = my_set.intersection(my_list)\n",
    "\n",
    "print(\"Common elements:\", common_elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "5271308a-aa63-419e-9d12-c10849a385a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of triangular numbers: {1, 3, 6, 10, 15}\n"
     ]
    }
   ],
   "source": [
    "# Q47: Create a set of the first `n` triangular numbers.\n",
    "\n",
    "def triangular_number(n):\n",
    "    return n * (n + 1) // 2\n",
    "\n",
    "n = 5\n",
    "triangular_numbers_set = {triangular_number(i) for i in range(1, n + 1)}\n",
    "\n",
    "print(\"Set of triangular numbers:\", triangular_numbers_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "655b1785-bbf0-4058-88d7-c6320a8809d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The subset is contained in the set.\n"
     ]
    }
   ],
   "source": [
    "# Q48: Check if a set contains another set as a subset.\n",
    "\n",
    "set1 = {1, 2, 3, 4, 5}\n",
    "subset = {2, 3}\n",
    "is_subset = subset.issubset(set1)\n",
    "\n",
    "if is_subset:\n",
    "    print(\"The subset is contained in the set.\")\n",
    "else:\n",
    "    print(\"The subset is not contained in the set.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "c61b632b-4557-4f50-9101-4a22f7c74051",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set of alternating 1s and 0s: {0, 1}\n"
     ]
    }
   ],
   "source": [
    "# Q49: Create a set of alternating 1s and 0s of length `n`.\n",
    "\n",
    "n = 5\n",
    "alternating_set = {1 if i % 2 == 0 else 0 for i in range(n)}\n",
    "\n",
    "print(\"Set of alternating 1s and 0s:\", alternating_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "a3d69934-be50-4bab-8fcb-361b0d68a1b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged set: {1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "# Q50: Merge multiple sets into one.\n",
    "\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set3 = {5, 6, 7}\n",
    "merged_set = set1.union(set2, set3)\n",
    "\n",
    "print(\"Merged set:\", merged_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ff06308-43fb-498a-9394-d32905dae808",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}