Python Data Structure Questions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "67155a25-7754-4e0b-a80f-5f402f567eac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PW Skills\n"
     ]
    }
   ],
   "source": [
    "# 1. Write a code to reverse a string.\n",
    "\n",
    "reverse_string = lambda text: text[::-1]\n",
    "\n",
    "string_to_reverse = \"sllikS WP\"\n",
    "reversed_string = reverse_string(string_to_reverse)\n",
    "print(reversed_string)  \n",
    "\n",
    "# Output: PW Skills"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6f34fa02-a3d6-4470-a006-3f1bdb9ef1a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# 2. Write a code to count the number of vowels in a string\n",
    "\n",
    "def count_vowels(text):\n",
    "  vowels = \"aeiouAEIOU\"\n",
    "  count = 0\n",
    "  for char in text:\n",
    "    if char in vowels:\n",
    "      count += 1\n",
    "  return count\n",
    "\n",
    "string_with_vowels = \"This is a string with vowels.\"\n",
    "vowel_count = count_vowels(string_with_vowels)\n",
    "print(vowel_count)  \n",
    "\n",
    "# Output: 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a54a57a8-0b29-4363-ac5f-3809eb03ddab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 3. Write a code to check if a given string is a palindrome or not\n",
    "\n",
    "is_palindrome = lambda text: text.lower().replace(\" \", \"\") == text[::-1]\n",
    "\n",
    "string1 = \"racecar\"\n",
    "string2 = \"hello\"\n",
    "print(is_palindrome(string1))  \n",
    "# Output: True\n",
    "print(is_palindrome(string2))  \n",
    "# Output: False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1001e0b1-bc44-4bc2-a829-28997186a87a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 4. Write a code to check if two given strings are anagrams of each other\n",
    "\n",
    "def are_anagrams(text1, text2):\n",
    "  text1 = text1.lower().replace(\" \", \"\")\n",
    "  text2 = text2.lower().replace(\" \", \"\")\n",
    "  return sorted(text1) == sorted(text2)\n",
    "\n",
    "string1 = \"listen\"\n",
    "string2 = \"silent\"\n",
    "string3 = \"hello\"\n",
    "print(are_anagrams(string1, string2)) \n",
    "# Output: True\n",
    "print(are_anagrams(string1, string3))  \n",
    "# Output: False "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9a1ef0ee-432d-45f7-bdbd-d4a32a24d9e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 42]\n"
     ]
    }
   ],
   "source": [
    "# 5. Write a code to find all occurrences of a given substring within another string\n",
    "\n",
    "import re\n",
    "\n",
    "def find_all_occurrences(text, substring):\n",
    "  return [m.start() for m in re.finditer(f\"(?={substring})\", text)]\n",
    "\n",
    "text = \"This is a test string with the substring 'test' appearing twice.\"\n",
    "substring = \"test\"\n",
    "occurrences = find_all_occurrences(text, substring)\n",
    "print(occurrences)  \n",
    "\n",
    "# Output: [10, 42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "df55bdee-31d3-42e3-96b4-254b7fa75e9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a3b2c5a4\n"
     ]
    }
   ],
   "source": [
    "# 6. Write a code to perform basic string compression using the counts of repeated characters\n",
    "\n",
    "def compress_string(text):\n",
    "  result = []\n",
    "  count = 1\n",
    "  for i in range(len(text)):\n",
    "    if i + 1 < len(text) and text[i] == text[i + 1]:\n",
    "      count += 1\n",
    "    else:\n",
    "      result.append(text[i] + (str(count) if count > 1 else \"\"))\n",
    "      count = 1\n",
    "  return \"\".join(result)\n",
    "\n",
    "# Example usage\n",
    "string_to_compress = \"aaabbcccccaaaa\"\n",
    "compressed_string = compress_string(string_to_compress)\n",
    "print(compressed_string)  \n",
    "\n",
    "# Output: a3b2c5a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2ae212c1-df78-43b4-9d74-43229a70e585",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 7. Write a code to determine if a string has all unique characters\n",
    "\n",
    "def has_unique_characters(text):\n",
    "  return len(set(text)) == len(text)\n",
    "\n",
    "string1 = \"Code\"\n",
    "string2 = \"Skills\"\n",
    "print(has_unique_characters(string1))  \n",
    "# Output: True\n",
    "print(has_unique_characters(string2))  \n",
    "# Output: False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "baf15df8-417d-4aa1-bd79-4bc22d66e7d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO, WORLD!\n",
      "hello, world!\n"
     ]
    }
   ],
   "source": [
    "# 8. Write a code to convert a given string to uppercase or lowercase\n",
    "\n",
    "change_case = lambda text, case=\"upper\": text.upper() if case == \"upper\" else text.lower()\n",
    "\n",
    "text = \"Hello, World!\"\n",
    "\n",
    "uppercase_text = change_case(text)        \n",
    "lowercase_text = change_case(text, \"lower\") \n",
    "print(uppercase_text)  \n",
    "# Output: HELLO, WORLD!\n",
    "print(lowercase_text)  \n",
    "# Output: hello, world! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1dc51f38-02e0-4c2d-ac08-6b6c0a48c5b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# 9. Write a code to count the number of words in a string\n",
    "\n",
    "count_words = lambda text: len(text.split())\n",
    "\n",
    "text = \"This is a sentence with multiple words.\"\n",
    "word_count = count_words(text)\n",
    "print(word_count) \n",
    "\n",
    "# Output: 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "156cd8be-eacb-4ad0-b886-ed9974a293af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "# 10. Write a code to concatenate two strings without using the + operator\n",
    "\n",
    "def concatenate_strings(str1, str2):\n",
    "  return \"\".join([str1, str2])\n",
    "\n",
    "string1 = \"Hello, \"\n",
    "string2 = \"world!\"\n",
    "\n",
    "concatenated_string = concatenate_strings(string1, string2)\n",
    "print(concatenated_string) \n",
    "\n",
    "# Output: Hello, world! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1b87cef8-13b6-49fe-8e39-eac8baa3a366",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# 11. Write a code to remove all occurrences of a specific element from a list\n",
    "\n",
    "def remove_all_occurrences(list1, element):\n",
    "    \n",
    "  while element in list1:\n",
    "    list1.remove(element)\n",
    "  return list1\n",
    "\n",
    "my_list = [1, 2, 3, 2, 4, 2]\n",
    "element_to_remove = 2\n",
    "result = remove_all_occurrences(my_list, element_to_remove)\n",
    "print(result) \n",
    "\n",
    "# Output: [1, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fd6f8ce3-873c-4e11-bc09-dd66f2cf1d42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    }
   ],
   "source": [
    "# 12. Implement a code to find the second largest number in a given list of integers\n",
    "\n",
    "def find_second_largest(numbers):\n",
    "  unique_numbers = set(numbers)\n",
    "  if len(unique_numbers) < 2:\n",
    "    return None  \n",
    "\n",
    "  largest = max(unique_numbers)\n",
    "  unique_numbers.remove(largest)\n",
    "  return max(unique_numbers)\n",
    "\n",
    "\n",
    "numbers = [12, 35, 9, 56, 24, 35]  \n",
    "second_largest_num = find_second_largest(numbers)\n",
    "print(second_largest_num)  \n",
    "\n",
    "# Output: 35 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6ab4a461-3fb3-43fb-8426-d640d63a771c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 3, 'banana': 2, 'cherry': 1}\n"
     ]
    }
   ],
   "source": [
    "# 13. Create a code to count the occurrences of each element in a list and return a dictionary with elements as\n",
    "# keys and their counts as values\n",
    "\n",
    "def count_occurrences(list1):\n",
    "  counts = {}\n",
    "  for element in list1:\n",
    "    if element in counts:\n",
    "      counts[element] += 1\n",
    "    else:\n",
    "      counts[element] = 1\n",
    "  return counts\n",
    "\n",
    "\n",
    "my_list = [\"apple\", \"banana\", \"apple\", \"cherry\", \"banana\", \"apple\"]\n",
    "occurrence_counts = count_occurrences(my_list)\n",
    "print(occurrence_counts)  \n",
    "\n",
    "# Output: {'apple': 3, 'banana': 2, 'cherry': 1} \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "bdcec13b-1741-4549-af11-8085f9fa08b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# 14. Write a code to reverse a list in-place without using any built-in reverse functions\n",
    "\n",
    "def reverse_list(list1):\n",
    "  list1[:] = list1[::-1]\n",
    "  return list1\n",
    "\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "reversed_list = reverse_list(my_list)\n",
    "print(reversed_list) \n",
    "\n",
    "# Output: [5, 4, 3, 2, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cfa58d7c-1328-4ddc-9603-0a36c57bab7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# 15. Implement a code to find and remove duplicates from a list while preserving the original order of\n",
    "# elements\n",
    "\n",
    "def remove_duplicates(list1):\n",
    "  unique_list = []\n",
    "  seen = set()\n",
    "  for element in list1:\n",
    "    if element not in seen:\n",
    "      unique_list.append(element)\n",
    "      seen.add(element)\n",
    "  return unique_list\n",
    "\n",
    "\n",
    "my_list = [1, 2, 2, 3, 4, 4, 5]\n",
    "result = remove_duplicates(my_list)\n",
    "print(result)  \n",
    "\n",
    "# Output: [1, 2, 3, 4, 5]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "1820bca6-67b2-4b41-bc81-e928edd1012f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 16. Create a code to check if a given list is sorted (either in ascending or descending order) or not\n",
    "\n",
    "def is_sorted(list1):\n",
    "  ascending = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))\n",
    "  descending = all(list1[i] >= list1[i+1] for i in range(len(list1)-1))\n",
    "  return ascending or descending\n",
    "\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [5, 4, 3, 2, 1]\n",
    "list3 = [1, 3, 2, 4, 5]\n",
    "print(is_sorted(list1))  # Output: True (ascending)\n",
    "print(is_sorted(list2))  # Output: True (descending)\n",
    "print(is_sorted(list3))  # Output: False "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fdff09a3-5ceb-4925-983e-463560a7833d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "# 17. Write a code to merge two sorted lists into a single sorted list\n",
    "\n",
    "def merge_sorted_lists(list1, list2):\n",
    "  return sorted(list1 + list2)\n",
    "\n",
    "list1 = [1, 3, 5, 7]\n",
    "list2 = [2, 4, 6, 8]\n",
    "merged_list = merge_sorted_lists(list1, list2)\n",
    "print(merged_list)  \n",
    "\n",
    "# Output: [1, 2, 3, 4, 5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8d46378b-d866-411b-93a0-fd2cca65d3b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# 18. Implement a code to find the intersection of two given lists\n",
    "\n",
    "def find_intersection(list1, list2):\n",
    "  return list(set(list1) & set(list2))\n",
    "\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [3, 4, 5, 6, 7]\n",
    "intersection = find_intersection(list1, list2)\n",
    "print(intersection)  \n",
    "\n",
    "# Output: [3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b502cd5a-adc3-46cf-9fca-96b323a3f7db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# 19. Create a code to find the union of two lists without duplicates\n",
    "\n",
    "def union_of_lists(list1, list2):\n",
    "\n",
    "  \n",
    "  union_set = set(list1 + list2)\n",
    "  union_list = list(union_set)\n",
    "  return union_list\n",
    "\n",
    "\n",
    "list1 = [1, 2, 3, 4]\n",
    "list2 = [3, 4, 5, 6]\n",
    "union = union_of_lists(list1, list2)\n",
    "print(union) \n",
    "\n",
    "# Output: [1, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "ffed60ea-42d0-46c4-9ea9-9b8ae7da4f46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 2, 3, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "# 20. Write a code to shuffle a given list randomly without using any built-in shuffle functions\n",
    "\n",
    "import random\n",
    "\n",
    "def shuffle_list(data):\n",
    " \n",
    "  n = len(data)\n",
    "  for i in range(n-1, 0, -1): \n",
    "    j = random.randint(0, i)\n",
    "    data[i], data[j] = data[j], data[i]\n",
    "  return data\n",
    "\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "shuffled_list = shuffle_list(my_list)\n",
    "print(shuffled_list)\n",
    "\n",
    "# Output : [5, 2, 3, 4, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "828f0b40-c818-4e63-83fb-f23f92c39fcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "# 21. Write a code that takes two tuples as input and returns a new tuple containing elements that are common to both input tuples\n",
    "\n",
    "def common_elements(tuple1, tuple2):\n",
    "  \n",
    "  set1 = set(tuple1)\n",
    "  set2 = set(tuple2)\n",
    " \n",
    "  common_set = set1.intersection(set2)\n",
    "\n",
    "  common_tuple = tuple(common_set)\n",
    "  return common_tuple\n",
    "\n",
    "\n",
    "tuple1 = (1, 2, 3, 4)\n",
    "tuple2 = (3, 4, 5, 6)\n",
    "common = common_elements(tuple1, tuple2)\n",
    "print(common)  \n",
    "\n",
    "# Output: (3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4b4878f8-896b-495c-95dd-3aed8749a644",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first set of integers (comma-separated):  65556\n",
      "Enter the second set of integers (comma-separated):  23223232\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection: set()\n"
     ]
    }
   ],
   "source": [
    "# 22. Create a code that prompts the user to enter two sets of integers separated by commas. Then, print the intersection of these two sets\n",
    "\n",
    "def find_intersection():\n",
    " \n",
    "  set1 = set(map(int, input(\"Enter the first set of integers (comma-separated): \").split(\",\")))\n",
    "  set2 = set(map(int, input(\"Enter the second set of integers (comma-separated): \").split(\",\")))\n",
    "  intersection = set1.intersection(set2)\n",
    "  print(\"Intersection:\", intersection)\n",
    "\n",
    "find_intersection()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c17d0b9f-420b-48dc-8e26-94c9bb635c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "# 23. Write a code to concatenate two tuples. The function should take two tuples as input and return a new tuple containing elements from both input tuples.\n",
    "\n",
    "def concatenate_tuples(tuple1, tuple2):\n",
    " \n",
    "  concatenated_tuple = tuple1 + tuple2\n",
    "  return concatenated_tuple\n",
    "\n",
    "tuple1 = (1, 2, 3)\n",
    "tuple2 = (4, 5, 6)\n",
    "concatenated = concatenate_tuples(tuple1, tuple2)\n",
    "print(concatenated)  \n",
    "\n",
    "# Output: (1, 2, 3, 4, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8d2e623c-d21c-4274-a159-6555168048e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first set of strings (comma-separated):  dog man cat\n",
      "Enter the second set of strings (comma-separated):  hen duck man\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements in the first set but not in the second set: {'dog man cat'}\n"
     ]
    }
   ],
   "source": [
    "# 24. Develop a code that prompts the user to input two sets of strings. Then, print the elements that are present in the first set but not in the second set\n",
    "\n",
    "def find_unique_elements():\n",
    " \n",
    "  set1 = set(input(\"Enter the first set of strings :\").split(\",\"))\n",
    "  set2 = set(input(\"Enter the second set of strings : \").split(\",\"))\n",
    "\n",
    "  unique_elements = set1.difference(set2)\n",
    "  print(\"Elements in the first set but not in the second set:\", unique_elements)\n",
    "\n",
    "find_unique_elements()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1641c992-1ec8-4363-b964-602e6dcc4200",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "# 25. Create a code that takes a tuple and two integers as input. The function should return a new tuple containing elements from the original tuple within the specified range of indices\n",
    "\n",
    "def slice_tuple(input_tuple, start_index, end_index):\n",
    " \n",
    "  new_tuple = input_tuple[start_index:end_index]\n",
    "  return new_tuple\n",
    "\n",
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "sliced_tuple = slice_tuple(my_tuple, 1, 4)\n",
    "print(sliced_tuple) \n",
    "\n",
    "# Output: (2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "caeb69ab-00ba-4cc9-8c25-f81a44b69978",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first set of characters:  abcd\n",
      "Enter the second set of characters:  abef\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union of the two sets: {'d', 'f', 'a', 'b', 'e', 'c'}\n"
     ]
    }
   ],
   "source": [
    "# 26. Write a code that prompts the user to input two sets of characters. Then, print the union of these two sets\n",
    "\n",
    "def find_union_of_characters():\n",
    " \n",
    "  set1 = set(input(\"Enter the first set of characters: \"))\n",
    "  set2 = set(input(\"Enter the second set of characters: \"))\n",
    "\n",
    "  union_set = set1.union(set2)\n",
    "  print(\"Union of the two sets:\", union_set)\n",
    "\n",
    "find_union_of_characters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d51c175c-f703-4c2a-89e1-5e3e37918367",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum value: 3\n",
      "Maximum value: 2\n"
     ]
    }
   ],
   "source": [
    "# 27. Develop a code that takes a tuple of integers as input. The function should return the maximum and minimum values from the tuple using tuple unpacking\n",
    "\n",
    "def find_min_max(numbers):\n",
    " \n",
    "  min_value, *_, max_value = numbers\n",
    "  return min_value, max_value\n",
    "\n",
    "my_tuple = (3, 1, 4, 1, 5, 9, 2)\n",
    "min_val, max_val = find_min_max(my_tuple)\n",
    "\n",
    "print(\"Minimum value:\", min_val)\n",
    "print(\"Maximum value:\", max_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fb8fbc8c-52b0-4c77-b0d2-ca06fa169420",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Union: {1, 2, 3, 4, 5, 6, 7, 8}\n",
      "Intersection: {4, 5}\n",
      "Difference (set1 - set2): {1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# 28. Create a code that defines two sets of integers. Then, print the union, intersection, and difference of these two sets\n",
    "\n",
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    "\n",
    "union_set = set1.union(set2)\n",
    "intersection_set = set1.intersection(set2)\n",
    "difference_set = set1.difference(set2)\n",
    "\n",
    "print(\"Union:\", union_set)\n",
    "print(\"Intersection:\", intersection_set)\n",
    "print(\"Difference (set1 - set2):\", difference_set)\n",
    "\n",
    "# Union: {1, 2, 3, 4, 5, 6, 7, 8}\n",
    "# Intersection: {4, 5}\n",
    "# Difference (set1 - set2): {1, 2, 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "792b9e22-2d5a-46c4-a6d2-265db9d5da35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# 29. Write a code that takes a tuple and an element as input. The function should return the count of occurrences of the given element in the tuple\n",
    "\n",
    "def count_occurrences(input_tuple, element):\n",
    "\n",
    "  count = input_tuple.count(element)\n",
    "  return count\n",
    "\n",
    "my_tuple = (1, 2, 2, 3, 4, 2, 5)\n",
    "element_count = count_occurrences(my_tuple, 2)\n",
    "print(element_count) \n",
    "\n",
    "# Output: 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "afb9e0b2-786c-450c-b609-c19a88381d3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the first set of strings :  dog cat man\n",
      "Enter the second set of strings :  cat hen duck\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symmetric Difference: {'dog cat man', 'cat hen duck'}\n"
     ]
    }
   ],
   "source": [
    "# 30. Develop a code that prompts the user to input two sets of strings. Then, print the symmetric difference of these two sets\n",
    "\n",
    "def find_symmetric_difference():\n",
    " \n",
    "  set1 = set(input(\"Enter the first set of strings : \").split(\",\"))\n",
    "  set2 = set(input(\"Enter the second set of strings : \").split(\",\"))\n",
    "\n",
    "  symmetric_difference = set1.symmetric_difference(set2)\n",
    "  print(\"Symmetric Difference:\", symmetric_difference)\n",
    "\n",
    "find_symmetric_difference()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9dc6abf8-a142-4d82-812c-2cd22cf02d2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 3, 'banana': 2, 'cherry': 1}\n"
     ]
    }
   ],
   "source": [
    "# 31. Write a code that takes a list of words as input and returns a dictionary where the keys are unique words and the values are the frequencies of those words in the input list\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "def word_frequencies(words):\n",
    "  return dict(Counter(words))\n",
    "\n",
    "word_list = [\"apple\", \"banana\", \"apple\", \"cherry\", \"banana\", \"apple\"]\n",
    "frequencies = word_frequencies(word_list)\n",
    "\n",
    "print(frequencies)  \n",
    "\n",
    "# Output: {'apple': 3, 'banana': 2, 'cherry': 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2eb719e4-5ffd-4501-a35f-9dbd8c9af66d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 6, 'c': 8, 'd': 6}\n"
     ]
    }
   ],
   "source": [
    "# 32. Write a code that takes two dictionaries as input and merges them into a single dictionary. If there are common keys, the values should be added together\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "def merge_dictionaries(dict1, dict2):\n",
    "  return dict(Counter(dict1) + Counter(dict2))\n",
    "\n",
    "dict1 = {'a': 1, 'b': 2, 'c': 3}\n",
    "dict2 = {'b': 4, 'c': 5, 'd': 6}\n",
    "merged_dict = merge_dictionaries(dict1, dict2)\n",
    "print(merged_dict) \n",
    "\n",
    "# Output: {'a': 1, 'b': 6, 'c': 8, 'd': 6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a59ae01e-5acd-471f-9cec-4e59ed171dff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# 33. Write a code to access a value in a nested dictionary. The function should take the dictionary and a list of keys as input, and return the corresponding value. If any of the keys do not exist in the dictionary, the function should return None\n",
    "\n",
    "def get_nested_value(data, keys):\n",
    " \n",
    "  try:\n",
    "        \n",
    "    for key in keys:\n",
    "      data = data[key]\n",
    "    return data\n",
    "  except KeyError:\n",
    "    return None\n",
    "\n",
    "my_dict = {'a': {'b': {'c': 10}}}\n",
    "value = get_nested_value(my_dict, ['a', 'b', 'c'])\n",
    "\n",
    "print(value)  \n",
    "\n",
    "# Output: 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "df149275-eb7c-4046-9342-f8c862ba7d73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3}\n",
      "{'c': 3, 'b': 2, 'a': 1}\n"
     ]
    }
   ],
   "source": [
    "# 34. Write a code that takes a dictionary as input and returns a sorted version of it based on the values. You\n",
    "# can choose whether to sort in ascending or descending order\n",
    "\n",
    "def sort_dictionary_by_value(input_dict, ascending=True):\n",
    "\n",
    "  sorted_items = sorted(input_dict.items(), key=lambda item: item[1], reverse=not ascending)\n",
    "  sorted_dict = dict(sorted_items)\n",
    "  return sorted_dict\n",
    "\n",
    "my_dict = {'c': 3, 'a': 1, 'b': 2}\n",
    "sorted_dict = sort_dictionary_by_value(my_dict)\n",
    "\n",
    "print(sorted_dict) \n",
    "\n",
    "# Output: {'a': 1, 'b': 2, 'c': 3} \n",
    "\n",
    "sorted_dict_descending = sort_dictionary_by_value(my_dict, ascending=False)\n",
    "\n",
    "print(sorted_dict_descending)  \n",
    "\n",
    "# Output: {'c': 3, 'b': 2, 'a': 1}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6cae25be-fa0c-486a-bf47-4be87e101bf4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ['a', 'c'], 2: ['b'], 3: ['d']}\n"
     ]
    }
   ],
   "source": [
    "# 35. Write a code that inverts a dictionary, swapping keys and values. Ensure that the inverted dictionary correctly handles cases where multiple keys have the same value by storing the keys as a list in the inverted dictionary.\n",
    "\n",
    "def invert_dictionary(original_dict):\n",
    " \n",
    "  inverted_dict = {}\n",
    "  for key, value in original_dict.items():\n",
    "    if value not in inverted_dict:\n",
    "      inverted_dict[value] = [key] \n",
    "    else:\n",
    "      inverted_dict[value].append(key)  \n",
    "  return inverted_dict\n",
    "\n",
    "my_dict = {'a': 1, 'b': 2, 'c': 1, 'd': 3}\n",
    "inverted_dict = invert_dictionary(my_dict)\n",
    "\n",
    "print(inverted_dict)  \n",
    "\n",
    "# Output: {1: ['a', 'c'], 2: ['b'], 3: ['d']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9fb795b-080e-496b-93d6-c2122083756e",
   "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
}