Python Practice Problems Basics (81-100).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1697fb7e",
   "metadata": {},
   "source": [
    "# Python Practice Problems(81-100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc7552d4",
   "metadata": {},
   "source": [
    "#### 81. Write a Python program that uses double quotes to display strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "32bce5a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without escape character :  Namaste World\n",
      "With use of escape character :  \"Namaste World\"\n"
     ]
    }
   ],
   "source": [
    "input_string = \"Namaste World\"\n",
    "\n",
    "print(\"Without escape character : \", input_string)\n",
    "\n",
    "input_string = \"\\\"Namaste World\\\"\"\n",
    "\n",
    "print(\"With use of escape character : \" , input_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fa686c5",
   "metadata": {},
   "source": [
    "#### 82. Write a Python program to split a variable length string into variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ccbd093b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given string is : apple,banana,orange,grape\n",
      "These are going to be converted into multiple  variables :  ['apple', 'banana', 'orange', 'grape']\n",
      "var1 = apple\n",
      "var2 = banana\n",
      "var3 = orange\n",
      "var4 = grape\n"
     ]
    }
   ],
   "source": [
    "given_string = \"apple,banana,orange,grape\"\n",
    "\n",
    "print(\"Given string is :\", given_string)\n",
    "\n",
    "substrings = given_string.split(\",\")\n",
    "\n",
    "print(\"These are going to be converted into multiple  variables : \", substrings)\n",
    "\n",
    "var1, var2, var3, var4 = substrings\n",
    "\n",
    "print(\"var1 =\",var1)\n",
    "print(\"var2 =\",var2)\n",
    "print(\"var3 =\",var3)\n",
    "print(\"var4 =\",var4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "14dfb25a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking newly created variable\n",
    "var1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "42ec25ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : Life is about enjoying\n",
      "You have entered : Life is about enjoying\n",
      "These are going to be converted into multiple  variables :  ['Life', 'is', 'about', 'enjoying']\n",
      "The value of variable var1 is : Life\n",
      "The value of variable var2 is : is\n",
      "The value of variable var3 is : about\n",
      "The value of variable var4 is : enjoying\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered :\", input_string)\n",
    "\n",
    "sub_strings = input_string.split(\" \")\n",
    "\n",
    "print(\"These are going to be converted into multiple  variables : \", sub_strings)\n",
    "\n",
    "for i, substring in enumerate(sub_strings):\n",
    "    exec(f\"var{i+1} = '{substring}'\")\n",
    "    print(f\"The value of variable var{i+1} is :\",substring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "707533f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'enjoying'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking newly created variable\n",
    "var4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5979a9f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : Life is about exploration\n",
      "You have entered : Life is about exploration\n",
      "These are going to be converted into multiple  variables :  ['indi', 'id']\n",
      "var1 Life\n",
      "var2 is\n",
      "var3 about\n",
      "var4 exploration\n",
      "Here is all variables with their values :\n",
      " {'var1': 'Life', 'var2': 'is', 'var3': 'about', 'var4': 'exploration'}\n"
     ]
    }
   ],
   "source": [
    "# Use dictionary\n",
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered :\", input_string)\n",
    "\n",
    "sub_strings = input_string.split(\" \")\n",
    "\n",
    "print(\"These are going to be converted into multiple  variables : \", string_split_list)\n",
    "\n",
    "var_dict = {}\n",
    "\n",
    "for i, substring in enumerate(sub_strings):\n",
    "    var_name = f\"var{i+1}\"\n",
    "    var_dict[var_name] = substring\n",
    "    print(var_name,var_dict[var_name])\n",
    "    \n",
    "print(\"Here is all variables with their values :\\n\", var_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "84d1320e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Life'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking newly created variable\n",
    "var_dict['var1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "56e91aad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string : Life is all about exploration\n",
      "You have entered : Life is all about exploration\n",
      "These are going to be converted into multiple  variables :  ['Life', 'is', 'all', 'about', 'exploration']\n",
      "var1= Life\n",
      "var2= is\n",
      "var3= all\n",
      "var4= about\n",
      "var5= exploration\n"
     ]
    }
   ],
   "source": [
    "input_string = input(\"Enter the string : \")\n",
    "\n",
    "print(\"You have entered :\", input_string)\n",
    "\n",
    "string_split_list = input_string.split(\" \")\n",
    "\n",
    "print(\"These are going to be converted into multiple  variables : \", string_split_list)\n",
    "\n",
    "for i in range(len(string_split_list)):\n",
    "    globals()[f\"var {i}\"] = string_split_list[i]\n",
    "    \n",
    "    print(f\"var{i+1}=\",globals()[f\"var {i}\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a70d846",
   "metadata": {},
   "source": [
    "#### 83. Write a Python program to input two integers on a single line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5af555f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two integers separated by a comma : 2,5\n",
      "The first integer :  2\n",
      "The second integer :  5\n"
     ]
    }
   ],
   "source": [
    "input_int = input(\"Enter two integers separated by a comma : \").split(\",\")\n",
    "\n",
    "int1, int2 = map(int,input_int)\n",
    "\n",
    "print(\"The first integer : \", int1)\n",
    "\n",
    "print(\"The second integer : \", int2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "21870155",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking integer value\n",
    "int1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "960067ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two integers separated by a comma : 3,5\n",
      "The first integer :  3\n",
      "The second integer :  5\n"
     ]
    }
   ],
   "source": [
    "int1, int2 = map(int,input(\"Enter two integers separated by a comma : \").split(\",\"))\n",
    "\n",
    "print(\"The first integer : \", int1)\n",
    "\n",
    "print(\"The second integer : \", int2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "027abeed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two integers separated by a comma : 6,5\n",
      "The first integer :  6\n",
      "The second integer :  5\n"
     ]
    }
   ],
   "source": [
    "input_integers = input(\"Enter two integers separated by a comma : \").split(\",\")\n",
    "\n",
    "int1, int2 = [int(int_input) for int_input in input_integers]\n",
    "\n",
    "print(\"The first integer : \", int1)\n",
    "\n",
    "print(\"The second integer : \", int2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "18593d29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two integers separated by a comma : 9,5\n",
      "The first integer :  9\n",
      "The second integer :  5\n"
     ]
    }
   ],
   "source": [
    "int1, int2 = [int(int_input) for int_input in input(\"Enter two integers separated by a comma : \").split(\",\")]\n",
    "\n",
    "print(\"The first integer : \", int1)\n",
    "\n",
    "print(\"The second integer : \", int2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b4f35f",
   "metadata": {},
   "source": [
    "#### 84. Write a Python program to print a variable without spaces between values."
   ]
  },
  {
   "cell_type": "raw",
   "id": "01dc5e11",
   "metadata": {},
   "source": [
    "Sample value : x =30\n",
    "Expected output : Value of x is \"30\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "edb8f744",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is \"30\"\n"
     ]
    }
   ],
   "source": [
    "x = 30\n",
    "\n",
    "print(f\"The value of x is \\\"{x}\\\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "933ab4f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is \"30\"\n"
     ]
    }
   ],
   "source": [
    "x = 30\n",
    "\n",
    "print(f'The value of x is \"{x}\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81285df9",
   "metadata": {},
   "source": [
    "#### 85. Write a Python program to extract a single key-value pair from a dictionary into variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "4e3080d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given dictionaryis :\n",
      " {'key1': 'val1', 'key2': 'val2', 'key3': 'val3', 'key4': 'val4'}\n",
      "Now extract specific single key-value pair...\n",
      "key1 val1\n",
      "key3 val3\n"
     ]
    }
   ],
   "source": [
    "dict_given = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3', 'key4': 'val4'}\n",
    "\n",
    "print(\"Given dictionaryis :\\n\",dict_given)\n",
    "\n",
    "print(\"Now extract specific single key-value pair...\")\n",
    "\n",
    "key,value = list(dict_given.items())[0]\n",
    "print(key,value)\n",
    "\n",
    "key,value = list(dict_given.items())[2]\n",
    "print(key,value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "d63628cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'key3'"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking  for variable\n",
    "key"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "638c8384",
   "metadata": {},
   "source": [
    "#### 86. Write a Python program to convert true to 1 and false to 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "28b9247c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "print(int(x))\n",
    "\n",
    "y = False\n",
    "print(int(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0413689",
   "metadata": {},
   "source": [
    "#### 87. Write a Python program to convert an integer to binary that keeps leading zeros."
   ]
  },
  {
   "cell_type": "raw",
   "id": "7bfe1bab",
   "metadata": {},
   "source": [
    "Sample data : \n",
    "x=12\n",
    "\n",
    "Expected output : \n",
    "00001100\n",
    "0000001100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "5e5d7280",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00001100\n",
      "0000001100\n"
     ]
    }
   ],
   "source": [
    "x = 12\n",
    "print(format(x, '08b'))\n",
    "print(format(x, '010b'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1da4f2a7",
   "metadata": {},
   "source": [
    "#### 88. Write a python program to convert decimal to hexadecimal"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d730bc7e",
   "metadata": {},
   "source": [
    "Sample decimal number: \n",
    "30, 4\n",
    "\n",
    "Expected output: \n",
    "1e, 04 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "976aeb19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1e\n",
      "04\n"
     ]
    }
   ],
   "source": [
    "x = 30\n",
    "print(format(x, '02x'))\n",
    "x = 4\n",
    "print(format(x, '02x'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88589584",
   "metadata": {},
   "source": [
    "#### 89. Write a Python program to check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones of same length in a given string. Return True/False."
   ]
  },
  {
   "cell_type": "raw",
   "id": "df7eca24",
   "metadata": {},
   "source": [
    "Original sequence: 01010101\n",
    "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
    "True\n",
    "\n",
    "Original sequence: 00\n",
    "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
    "False\n",
    "\n",
    "Original sequence: 000111000111\n",
    "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
    "True\n",
    "\n",
    "Original sequence: 00011100011\n",
    "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "b7ea6f49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original sequence: 01010101\n",
      "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
      "False\n",
      "Original sequence: 00\n",
      "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
      "False\n",
      "Original sequence: 000111000111\n",
      "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
      "False\n",
      "Original sequence: 00011100011\n",
      "Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def check_zero_one_sequence(s):\n",
    "    # Initialize variables to track the length of the zero and one sequences\n",
    "    zero_count = 0\n",
    "    one_count = 0\n",
    "\n",
    "    # Loop through the string\n",
    "    for i in range(len(s)):\n",
    "        if s[i] == \"0\":\n",
    "            # Increment the zero sequence count\n",
    "            zero_count += 1\n",
    "            if one_count > 0 and zero_count != one_count:\n",
    "                # Zero sequence is not followed by a one sequence of same length\n",
    "                return False\n",
    "        elif s[i] == \"1\":\n",
    "            # Increment the one sequence count\n",
    "            one_count += 1\n",
    "            if zero_count > 0 and zero_count != one_count:\n",
    "                # Zero sequence is not followed by a one sequence of same length\n",
    "                return False\n",
    "        else:\n",
    "            # Invalid character in string\n",
    "            return False\n",
    "\n",
    "    # All zero sequences are followed by a one sequence of same length\n",
    "    return True if zero_count == one_count else False\n",
    "\n",
    "\n",
    "# Test the function with sample strings\n",
    "strings = [\"01010101\", \"00\", \"000111000111\", \"00011100011\"]\n",
    "for s in strings:\n",
    "    print(f\"Original sequence: {s}\")\n",
    "    print(\"Check if every consecutive sequence of zeroes is followed by a consecutive sequence of ones in the said string:\")\n",
    "    print(check_zero_one_sequence(s))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e652d58d",
   "metadata": {},
   "source": [
    "#### 90. Write a Python program to test if a variable is a list, tuple, or set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "732ffcf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a tuple\n"
     ]
    }
   ],
   "source": [
    "#x = ['a', 'b', 'c', 'd']\n",
    "#x = {'a', 'b', 'c', 'd'}\n",
    "x = ('tuple', False, 3.2, 1)\n",
    "if type(x) is list:\n",
    "    print('x is a list')\n",
    "elif type(x) is set:\n",
    "    print('x is a set')\n",
    "elif type(x) is tuple:\n",
    "    print('x is a tuple')    \n",
    "else:\n",
    "    print('Neither a list or a set or a tuple.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "98c25a37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a list\n"
     ]
    }
   ],
   "source": [
    "x = ['a', 'b', 'c', 'd']\n",
    "#x = {'a', 'b', 'c', 'd'}\n",
    "if type(x) is list:\n",
    "    print('x is a list')\n",
    "elif type(x) is set:\n",
    "    print('x is a set')\n",
    "elif type(x) is tuple:\n",
    "    print('x is a tuple')    \n",
    "else:\n",
    "    print('Neither a list or a set or a tuple.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "a5ed22cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is a set\n"
     ]
    }
   ],
   "source": [
    "x = {'a', 'b', 'c', 'd'}\n",
    "\n",
    "if type(x) is list:\n",
    "    print('x is a list')\n",
    "elif type(x) is set:\n",
    "    print('x is a set')\n",
    "elif type(x) is tuple:\n",
    "    print('x is a tuple')    \n",
    "else:\n",
    "    print('Neither a list or a set or a tuple.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f9dbf55",
   "metadata": {},
   "source": [
    "#### 91. Write a Python function to check whether a number is divisible by another number. Accept two integer values from the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "b2b3fa79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the dividend : 15\n",
      "You have entered the dividend :\n",
      "Enter the divisor : 5\n",
      "You have entered the divisor :\n",
      "The number 15 is divisible by 5\n"
     ]
    }
   ],
   "source": [
    "input_dividend = int(input(\"Enter the dividend : \"))\n",
    "\n",
    "print(\"You have entered the dividend :\")\n",
    "\n",
    "input_divisor= int(input(\"Enter the divisor : \"))\n",
    "\n",
    "print(\"You have entered the divisor :\")\n",
    "\n",
    "divisiility_check = input_dividend%input_divisor\n",
    "\n",
    "if divisiility_check==0:\n",
    "    print(f\"The number {input_dividend} is divisible by {input_divisor}\")\n",
    "else:\n",
    "    print(f\"The number {input_dividend} is not divisible by {input_divisor}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd9994d",
   "metadata": {},
   "source": [
    "#### 92. Write a Python function to find the maximum and minimum numbers from a sequence of numbers.\n",
    "\n",
    "Note: Do not use built-in functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "a66c54fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given sequence is :  [0, 10, 15, 40, -5, 42, 17, 28, 75]\n",
      "Maximum and minimum numbers from the  given sequence [0, 10, 15, 40, -5, 42, 17, 28, 75] are 75 and -5 respectively\n"
     ]
    }
   ],
   "source": [
    "input_sequence = [0, 10, 15, 40, -5, 42, 17, 28, 75]\n",
    "\n",
    "print(\"Given sequence is : \", input_sequence)\n",
    "\n",
    "max_num = input_sequence[0]\n",
    "\n",
    "min_num = input_sequence[0]\n",
    "\n",
    "for num in input_sequence:\n",
    "    if num>max_num:\n",
    "        max_num = num\n",
    "    elif num<min_num:\n",
    "        min_num = num\n",
    "        \n",
    "print(f\"Maximum and minimum numbers from the  given sequence {input_sequence} are {max_num} and {min_num} respectively\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2376abc9",
   "metadata": {},
   "source": [
    "#### 93. Write a Python function that takes a positive integer and returns the sum of the cube of all positive integers smaller than the specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "3c186201",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any positive integer : 10\n",
      "You have entered : 10\n",
      "The sum of cube of all positive numbers smaller than 10 is 2025\n"
     ]
    }
   ],
   "source": [
    "input_number = int(input(\"Enter any positive integer : \"))\n",
    "\n",
    "print(\"You have entered :\", input_number)\n",
    "\n",
    "num_cube = 0\n",
    "\n",
    "\n",
    "if input_number>0:\n",
    "    for num in range(1,input_number):\n",
    "        num_cube += num**3\n",
    "        num_cube\n",
    "    print(f\"The sum of cube of all positive numbers smaller than {input_number} is {num_cube}\")\n",
    "else:\n",
    "    print(\"Input is not a positive integer\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7279e5c4",
   "metadata": {},
   "source": [
    "#### 94. Write a Python function to check whether a distinct pair of numbers whose product is odd is present in a sequence of integer values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "70494d39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1 :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "List 2 :  [11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
      "(1, 11) (1, 13) (1, 15) (1, 17) (1, 19) (3, 11) (3, 13) (3, 15) (3, 17) (3, 19) (5, 11) (5, 13) (5, 15) (5, 17) (5, 19) (7, 11) (7, 13) (7, 15) (7, 17) (7, 19) (9, 11) (9, 13) (9, 15) (9, 17) (9, 19) \n",
      "Above are the pairs for which product is odd\n"
     ]
    }
   ],
   "source": [
    "list_1 = [num for num in range(1,10)]\n",
    "\n",
    "print(\"List 1 : \", list_1)\n",
    "\n",
    "list_2 = [num for num in range(11,20)]\n",
    "\n",
    "print(\"List 2 : \", list_2)\n",
    "\n",
    "for num in list_1:\n",
    "    num1 = num\n",
    "    for num in list_2:\n",
    "        num2 = num\n",
    "        if (num1*num2)%2!=0:\n",
    "            print((num1,num2), end= \" \")\n",
    "            #print(f\"Product of {num1} and {num2} is odd\")\n",
    "print(\"\\nAbove are the pairs for which product is odd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "ca0c31ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lIst :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "(1, 3) (1, 5) (1, 7) (1, 9) (3, 1) (3, 5) (3, 7) (3, 9) (5, 1) (5, 3) (5, 7) (5, 9) (7, 1) (7, 3) (7, 5) (7, 9) (9, 1) (9, 3) (9, 5) (9, 7) \n",
      "Above are the pairs for which product is odd\n"
     ]
    }
   ],
   "source": [
    "list_given = [num for num in range(1,10)]\n",
    "\n",
    "print(\"Given lIst : \", list_given)\n",
    "\n",
    "for i in range(len(list_given)):\n",
    "    for j in range(len(list_given)):\n",
    "        if i != j:\n",
    "            if (list_given[i]*list_given[j])%2 != 0:\n",
    "                print((list_given[i], list_given[j]), end=\" \")\n",
    "print(\"\\nAbove are the pairs for which product is odd\")            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "589d204a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Pair of numbers exist for which product is odd.\n"
     ]
    }
   ],
   "source": [
    "list_given = [num for num in range(1,10)]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "num_odd_count = 0\n",
    "for num in list_given:\n",
    "    if num%2 != 0:\n",
    "        num_odd_count +=1\n",
    "        \n",
    "if num_odd_count>2:\n",
    "    print(\"Pair of numbers exist for which product is odd.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "49cd01b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Pair of numbers exist for which product is odd.\n"
     ]
    }
   ],
   "source": [
    "list_given = [num for num in range(1,10)]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "num_odd_count = sum(map(lambda x: x%2 !=0, list_given))\n",
    "\n",
    "if num_odd_count>2:\n",
    "    print(\"Pair of numbers exist for which product is odd.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4a32b07",
   "metadata": {},
   "source": [
    "#### 95. Write a Python function that takes a sequence of numbers and determines whether all the numbers are different from each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "dfbe0ff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "All numbers in the list are different from each other.\n"
     ]
    }
   ],
   "source": [
    "list_given = [num for num in range(1,10)]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "if len(list_given)==len(set(list_given)):\n",
    "    print(\"All numbers in the list are different from each other.\")\n",
    "else:\n",
    "    print(\"List contains some same numbers\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "0455db15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 3, 5, 4, 6, 6]\n",
      "List contains some same numbers\n"
     ]
    }
   ],
   "source": [
    "list_given = [1,2,3,3,5,4,6,6]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "if len(list_given)==len(set(list_given)):\n",
    "    print(\"All numbers in the list are different from each other.\")\n",
    "else:\n",
    "    print(\"List contains some same numbers\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "aa85a215",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "All numbers are different\n"
     ]
    }
   ],
   "source": [
    "list_given = [num for num in range(1,10)]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "for num in list_given:\n",
    "    if list_given.index(num) == len(list_given)-1:\n",
    "        print(\"All numbers are different\")\n",
    "    elif list_given.count(num)>1:\n",
    "        print(\"There are two identical numbers\")\n",
    "        break\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "eb8a886b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 3, 5, 4, 6, 6]\n",
      "There are two identical numbers\n"
     ]
    }
   ],
   "source": [
    "list_given = [1,2,3,3,5,4,6,6]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "for num in list_given:\n",
    "    if list_given.index(num) == len(list_given)-1:\n",
    "        print(\"All numbers are different\")\n",
    "    elif list_given.count(num)>1:\n",
    "        print(\"There are two identical numbers\")\n",
    "        break\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "0c0c5057",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List :  [1, 2, 3, 3, 5, 4, 6, 6]\n",
      "The list contains duplicates\n"
     ]
    }
   ],
   "source": [
    "list_given = [1,2,3,3,5,4,6,6]\n",
    "\n",
    "print(\"Given List : \", list_given)\n",
    "\n",
    "for num in list_given:\n",
    "    if list_given.count(num)>1:\n",
    "        print(\"The list contains duplicates\")\n",
    "        break\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "d98910fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List:  [1, 2, 3, 3, 5, 4, 6, 6]\n",
      "The list contains duplicates\n"
     ]
    }
   ],
   "source": [
    "list_given = [1, 2, 3, 3, 5, 4, 6, 6]\n",
    "\n",
    "print(\"Given List: \", list_given)\n",
    "\n",
    "has_duplicates = False\n",
    "for num in list_given:\n",
    "    if list_given.count(num) > 1:\n",
    "        has_duplicates = True\n",
    "        break\n",
    "\n",
    "if has_duplicates:\n",
    "    print(\"The list contains duplicates\")\n",
    "else:\n",
    "    print(\"The list contains unique numbers\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66ab7d0",
   "metadata": {},
   "source": [
    "#### 96. Write a Python program that creates all possible strings using the letters 'a', 'e', 'i', 'o', and 'u'. Ensure that each character is used only once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1cc4869e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List:  ['a', 'e', 'i', 'o', 'u']\n",
      "\n",
      "\n",
      "List of all possible strings using ['a', 'e', 'i', 'o', 'u'] without repeatition :\n",
      "\n",
      "\n",
      "Word 1 : a u e i o\n",
      "Word 2 : a u e o i\n",
      "Word 3 : a u i e o\n",
      "Word 4 : a u i o e\n",
      "Word 5 : a u o e i\n",
      "Word 6 : a u o i e\n",
      "Word 7 : a e u i o\n",
      "Word 8 : a e u o i\n",
      "Word 9 : a e i u o\n",
      "Word 10 : a e i o u\n",
      "Word 11 : a e o u i\n",
      "Word 12 : a e o i u\n",
      "Word 13 : a i u e o\n",
      "Word 14 : a i u o e\n",
      "Word 15 : a i e u o\n",
      "Word 16 : a i e o u\n",
      "Word 17 : a i o u e\n",
      "Word 18 : a i o e u\n",
      "Word 19 : a o u e i\n",
      "Word 20 : a o u i e\n",
      "Word 21 : a o e u i\n",
      "Word 22 : a o e i u\n",
      "Word 23 : a o i u e\n",
      "Word 24 : a o i e u\n",
      "Word 25 : e u a i o\n",
      "Word 26 : e u a o i\n",
      "Word 27 : e u i a o\n",
      "Word 28 : e u i o a\n",
      "Word 29 : e u o a i\n",
      "Word 30 : e u o i a\n",
      "Word 31 : e a u i o\n",
      "Word 32 : e a u o i\n",
      "Word 33 : e a i u o\n",
      "Word 34 : e a i o u\n",
      "Word 35 : e a o u i\n",
      "Word 36 : e a o i u\n",
      "Word 37 : e i u a o\n",
      "Word 38 : e i u o a\n",
      "Word 39 : e i a u o\n",
      "Word 40 : e i a o u\n",
      "Word 41 : e i o u a\n",
      "Word 42 : e i o a u\n",
      "Word 43 : e o u a i\n",
      "Word 44 : e o u i a\n",
      "Word 45 : e o a u i\n",
      "Word 46 : e o a i u\n",
      "Word 47 : e o i u a\n",
      "Word 48 : e o i a u\n",
      "Word 49 : i u e a o\n",
      "Word 50 : i u e o a\n",
      "Word 51 : i u a e o\n",
      "Word 52 : i u a o e\n",
      "Word 53 : i u o e a\n",
      "Word 54 : i u o a e\n",
      "Word 55 : i e u a o\n",
      "Word 56 : i e u o a\n",
      "Word 57 : i e a u o\n",
      "Word 58 : i e a o u\n",
      "Word 59 : i e o u a\n",
      "Word 60 : i e o a u\n",
      "Word 61 : i a u e o\n",
      "Word 62 : i a u o e\n",
      "Word 63 : i a e u o\n",
      "Word 64 : i a e o u\n",
      "Word 65 : i a o u e\n",
      "Word 66 : i a o e u\n",
      "Word 67 : i o u e a\n",
      "Word 68 : i o u a e\n",
      "Word 69 : i o e u a\n",
      "Word 70 : i o e a u\n",
      "Word 71 : i o a u e\n",
      "Word 72 : i o a e u\n",
      "Word 73 : o u e a i\n",
      "Word 74 : o u e i a\n",
      "Word 75 : o u a e i\n",
      "Word 76 : o u a i e\n",
      "Word 77 : o u i e a\n",
      "Word 78 : o u i a e\n",
      "Word 79 : o e u a i\n",
      "Word 80 : o e u i a\n",
      "Word 81 : o e a u i\n",
      "Word 82 : o e a i u\n",
      "Word 83 : o e i u a\n",
      "Word 84 : o e i a u\n",
      "Word 85 : o a u e i\n",
      "Word 86 : o a u i e\n",
      "Word 87 : o a e u i\n",
      "Word 88 : o a e i u\n",
      "Word 89 : o a i u e\n",
      "Word 90 : o a i e u\n",
      "Word 91 : o i u e a\n",
      "Word 92 : o i u a e\n",
      "Word 93 : o i e u a\n",
      "Word 94 : o i e a u\n",
      "Word 95 : o i a u e\n",
      "Word 96 : o i a e u\n",
      "Word 97 : u e a i o\n",
      "Word 98 : u e a o i\n",
      "Word 99 : u e i a o\n",
      "Word 100 : u e i o a\n",
      "Word 101 : u e o a i\n",
      "Word 102 : u e o i a\n",
      "Word 103 : u a e i o\n",
      "Word 104 : u a e o i\n",
      "Word 105 : u a i e o\n",
      "Word 106 : u a i o e\n",
      "Word 107 : u a o e i\n",
      "Word 108 : u a o i e\n",
      "Word 109 : u i e a o\n",
      "Word 110 : u i e o a\n",
      "Word 111 : u i a e o\n",
      "Word 112 : u i a o e\n",
      "Word 113 : u i o e a\n",
      "Word 114 : u i o a e\n",
      "Word 115 : u o e a i\n",
      "Word 116 : u o e i a\n",
      "Word 117 : u o a e i\n",
      "Word 118 : u o a i e\n",
      "Word 119 : u o i e a\n",
      "Word 120 : u o i a e\n"
     ]
    }
   ],
   "source": [
    "list_given = ['a','e','i','o','u']\n",
    "\n",
    "print(\"Given List: \", list_given)\n",
    "\n",
    "count = 0\n",
    "\n",
    "print(f\"\\n\\nList of all possible strings using {list_given} without repeatition :\\n\\n\")\n",
    "\n",
    "for first in list_given:\n",
    "    remaining1 = set(list_given) - {first}\n",
    "    for second in remaining1:\n",
    "        remaining2 = remaining1 - {second}\n",
    "        for third in remaining2:\n",
    "            remaining3 = remaining2 - {third}\n",
    "            for fourth in remaining3:\n",
    "                remaining4 = remaining3 - {fourth}\n",
    "                for fifth in remaining4:\n",
    "                    print(f\"Word {count+1} :\", first, second, third, fourth, fifth)\n",
    "                    count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fa66cae5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List:  ['a', 'e', 'i', 'o', 'u']\n",
      "\n",
      "\n",
      "List of all possible strings using ['a', 'e', 'i', 'o', 'u'] without repeatition :\n",
      "\n",
      "\n",
      "('e', 'o', 'u', 'i', 'a')\n",
      "('a', 'u', 'e', 'o', 'i')\n",
      "('a', 'i', 'u', 'o', 'e')\n",
      "('a', 'e', 'i', 'u', 'o')\n",
      "('e', 'o', 'u', 'a', 'i')\n",
      "('u', 'i', 'e', 'o', 'a')\n",
      "('e', 'a', 'i', 'u', 'o')\n",
      "('e', 'u', 'a', 'o', 'i')\n",
      "('i', 'u', 'o', 'a', 'e')\n",
      "('i', 'e', 'a', 'o', 'u')\n",
      "('o', 'i', 'u', 'e', 'a')\n",
      "('e', 'i', 'a', 'o', 'u')\n",
      "('u', 'o', 'e', 'i', 'a')\n",
      "('i', 'u', 'e', 'a', 'o')\n",
      "('o', 'u', 'i', 'e', 'a')\n",
      "('u', 'i', 'o', 'e', 'a')\n",
      "('e', 'u', 'o', 'a', 'i')\n",
      "('u', 'i', 'a', 'e', 'o')\n",
      "('a', 'u', 'i', 'o', 'e')\n",
      "('i', 'e', 'o', 'a', 'u')\n",
      "('a', 'e', 'o', 'u', 'i')\n",
      "('i', 'o', 'u', 'a', 'e')\n",
      "('o', 'e', 'i', 'u', 'a')\n",
      "('a', 'i', 'e', 'o', 'u')\n",
      "('a', 'o', 'u', 'i', 'e')\n",
      "('e', 'u', 'i', 'a', 'o')\n",
      "('o', 'i', 'a', 'u', 'e')\n",
      "('e', 'o', 'i', 'u', 'a')\n",
      "('u', 'a', 'e', 'i', 'o')\n",
      "('o', 'a', 'e', 'u', 'i')\n",
      "('a', 'o', 'u', 'e', 'i')\n",
      "('o', 'e', 'u', 'a', 'i')\n",
      "('i', 'a', 'e', 'o', 'u')\n",
      "('i', 'a', 'u', 'e', 'o')\n",
      "('u', 'e', 'i', 'a', 'o')\n",
      "('e', 'a', 'o', 'u', 'i')\n",
      "('a', 'i', 'o', 'e', 'u')\n",
      "('a', 'u', 'o', 'e', 'i')\n",
      "('e', 'i', 'a', 'u', 'o')\n",
      "('o', 'a', 'e', 'i', 'u')\n",
      "('o', 'u', 'a', 'e', 'i')\n",
      "('u', 'a', 'i', 'o', 'e')\n",
      "('e', 'i', 'u', 'a', 'o')\n",
      "('a', 'u', 'i', 'e', 'o')\n",
      "('o', 'i', 'e', 'a', 'u')\n",
      "('o', 'e', 'i', 'a', 'u')\n",
      "('o', 'u', 'i', 'a', 'e')\n",
      "('u', 'e', 'i', 'o', 'a')\n",
      "('a', 'o', 'e', 'i', 'u')\n",
      "('i', 'a', 'o', 'e', 'u')\n",
      "('a', 'e', 'u', 'i', 'o')\n",
      "('e', 'o', 'i', 'a', 'u')\n",
      "('a', 'i', 'e', 'u', 'o')\n",
      "('e', 'a', 'o', 'i', 'u')\n",
      "('o', 'a', 'i', 'e', 'u')\n",
      "('u', 'a', 'o', 'i', 'e')\n",
      "('i', 'u', 'a', 'o', 'e')\n",
      "('u', 'o', 'i', 'e', 'a')\n",
      "('u', 'e', 'o', 'a', 'i')\n",
      "('i', 'o', 'a', 'u', 'e')\n",
      "('o', 'i', 'e', 'u', 'a')\n",
      "('o', 'a', 'u', 'e', 'i')\n",
      "('u', 'i', 'a', 'o', 'e')\n",
      "('a', 'o', 'i', 'e', 'u')\n",
      "('i', 'u', 'e', 'o', 'a')\n",
      "('u', 'a', 'i', 'e', 'o')\n",
      "('u', 'o', 'a', 'e', 'i')\n",
      "('a', 'o', 'i', 'u', 'e')\n",
      "('a', 'e', 'i', 'o', 'u')\n",
      "('e', 'i', 'o', 'u', 'a')\n",
      "('o', 'i', 'u', 'a', 'e')\n",
      "('i', 'e', 'a', 'u', 'o')\n",
      "('i', 'a', 'u', 'o', 'e')\n",
      "('u', 'i', 'o', 'a', 'e')\n",
      "('a', 'i', 'o', 'u', 'e')\n",
      "('a', 'u', 'e', 'i', 'o')\n",
      "('i', 'u', 'a', 'e', 'o')\n",
      "('e', 'a', 'u', 'i', 'o')\n",
      "('i', 'o', 'e', 'u', 'a')\n",
      "('u', 'a', 'e', 'o', 'i')\n",
      "('u', 'i', 'e', 'a', 'o')\n",
      "('u', 'o', 'a', 'i', 'e')\n",
      "('u', 'e', 'a', 'i', 'o')\n",
      "('o', 'e', 'a', 'u', 'i')\n",
      "('e', 'o', 'a', 'u', 'i')\n",
      "('e', 'i', 'u', 'o', 'a')\n",
      "('u', 'o', 'i', 'a', 'e')\n",
      "('o', 'a', 'i', 'u', 'e')\n",
      "('i', 'o', 'u', 'e', 'a')\n",
      "('e', 'o', 'a', 'i', 'u')\n",
      "('a', 'u', 'o', 'i', 'e')\n",
      "('i', 'e', 'o', 'u', 'a')\n",
      "('o', 'u', 'a', 'i', 'e')\n",
      "('u', 'a', 'o', 'e', 'i')\n",
      "('a', 'o', 'e', 'u', 'i')\n",
      "('i', 'a', 'e', 'u', 'o')\n",
      "('i', 'e', 'u', 'a', 'o')\n",
      "('a', 'e', 'u', 'o', 'i')\n",
      "('e', 'a', 'i', 'o', 'u')\n",
      "('o', 'e', 'a', 'i', 'u')\n",
      "('o', 'u', 'e', 'i', 'a')\n",
      "('a', 'e', 'o', 'i', 'u')\n",
      "('i', 'o', 'e', 'a', 'u')\n",
      "('e', 'a', 'u', 'o', 'i')\n",
      "('o', 'u', 'e', 'a', 'i')\n",
      "('e', 'u', 'o', 'i', 'a')\n",
      "('e', 'u', 'i', 'o', 'a')\n",
      "('u', 'e', 'a', 'o', 'i')\n",
      "('e', 'u', 'a', 'i', 'o')\n",
      "('i', 'u', 'o', 'e', 'a')\n",
      "('i', 'o', 'a', 'e', 'u')\n",
      "('u', 'o', 'e', 'a', 'i')\n",
      "('o', 'i', 'a', 'e', 'u')\n",
      "('o', 'a', 'u', 'i', 'e')\n",
      "('u', 'e', 'o', 'i', 'a')\n",
      "('a', 'i', 'u', 'e', 'o')\n",
      "('i', 'e', 'u', 'o', 'a')\n",
      "('e', 'i', 'o', 'a', 'u')\n",
      "('o', 'e', 'u', 'i', 'a')\n",
      "('i', 'a', 'o', 'u', 'e')\n"
     ]
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "list_given = ['a','e','i','o','u']\n",
    "\n",
    "print(\"Given List: \", list_given)\n",
    "\n",
    "combination_strings = permutations(list_given)\n",
    "\n",
    "print(f\"\\n\\nList of all possible strings using {list_given} without repeatition :\\n\\n\")\n",
    "\n",
    "for i in set(combination_strings):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "183b5c47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given List:  ['a', 'e', 'i', 'o', 'u']\n",
      "\n",
      "\n",
      "List of all possible strings using ['a', 'e', 'i', 'o', 'u'] without repeatition :\n",
      "\n",
      "\n",
      "aeiou\n",
      "aeiuo\n",
      "aeoiu\n",
      "aeoui\n",
      "aeuio\n",
      "aeuoi\n",
      "aieou\n",
      "aieuo\n",
      "aioeu\n",
      "aioue\n",
      "aiueo\n",
      "aiuoe\n",
      "aoeiu\n",
      "aoeui\n",
      "aoieu\n",
      "aoiue\n",
      "aouei\n",
      "aouie\n",
      "aueio\n",
      "aueoi\n",
      "auieo\n",
      "auioe\n",
      "auoei\n",
      "auoie\n",
      "eaiou\n",
      "eaiuo\n",
      "eaoiu\n",
      "eaoui\n",
      "eauio\n",
      "eauoi\n",
      "eiaou\n",
      "eiauo\n",
      "eioau\n",
      "eioua\n",
      "eiuao\n",
      "eiuoa\n",
      "eoaiu\n",
      "eoaui\n",
      "eoiau\n",
      "eoiua\n",
      "eouai\n",
      "eouia\n",
      "euaio\n",
      "euaoi\n",
      "euiao\n",
      "euioa\n",
      "euoai\n",
      "euoia\n",
      "iaeou\n",
      "iaeuo\n",
      "iaoeu\n",
      "iaoue\n",
      "iaueo\n",
      "iauoe\n",
      "ieaou\n",
      "ieauo\n",
      "ieoau\n",
      "ieoua\n",
      "ieuao\n",
      "ieuoa\n",
      "ioaeu\n",
      "ioaue\n",
      "ioeau\n",
      "ioeua\n",
      "iouae\n",
      "iouea\n",
      "iuaeo\n",
      "iuaoe\n",
      "iueao\n",
      "iueoa\n",
      "iuoae\n",
      "iuoea\n",
      "oaeiu\n",
      "oaeui\n",
      "oaieu\n",
      "oaiue\n",
      "oauei\n",
      "oauie\n",
      "oeaiu\n",
      "oeaui\n",
      "oeiau\n",
      "oeiua\n",
      "oeuai\n",
      "oeuia\n",
      "oiaeu\n",
      "oiaue\n",
      "oieau\n",
      "oieua\n",
      "oiuae\n",
      "oiuea\n",
      "ouaei\n",
      "ouaie\n",
      "oueai\n",
      "oueia\n",
      "ouiae\n",
      "ouiea\n",
      "uaeio\n",
      "uaeoi\n",
      "uaieo\n",
      "uaioe\n",
      "uaoei\n",
      "uaoie\n",
      "ueaio\n",
      "ueaoi\n",
      "ueiao\n",
      "ueioa\n",
      "ueoai\n",
      "ueoia\n",
      "uiaeo\n",
      "uiaoe\n",
      "uieao\n",
      "uieoa\n",
      "uioae\n",
      "uioea\n",
      "uoaei\n",
      "uoaie\n",
      "uoeai\n",
      "uoeia\n",
      "uoiae\n",
      "uoiea\n"
     ]
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "list_given = ['a','e','i','o','u']\n",
    "\n",
    "print(\"Given List: \", list_given)\n",
    "\n",
    "\n",
    "print(f\"\\n\\nList of all possible strings using {list_given} without repeatition :\\n\\n\")\n",
    "\n",
    "for i in list(permutations(range(len(list_given)))):print(''.join([str(list_given[x]) for x in i ]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3736c774",
   "metadata": {},
   "source": [
    "#### 97. Write a Python program that removes and prints every third number from a list of numbers until the list is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7fd255f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given numbers :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "Here is the required output : \n",
      "\n",
      "3\n",
      "6\n",
      "9\n",
      "4\n",
      "8\n",
      "5\n",
      "2\n",
      "7\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "given_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "print(\"Given numbers : \", given_numbers)\n",
    "\n",
    "count=0\n",
    "\n",
    "print(\"\\nHere is the required output : \\n\")\n",
    "\n",
    "while len(given_numbers) > 0:\n",
    "    count += 1\n",
    "    if count == 3:\n",
    "        count=0\n",
    "        print(given_numbers.pop(count))\n",
    "    else:\n",
    "        given_numbers.append(given_numbers.pop(0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a68b146",
   "metadata": {},
   "source": [
    "#### 98. Write a Python program to identify unique triplets whose three elements sum to zero from an array of n integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e3d66a95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given numbers :  [1, -6, 4, 2, -1, 2, 0, -2, 0]\n",
      "\n",
      "Unique triplets whose three elements sum to zero :\n",
      "\n",
      "[[-1, 0, 1], [-6, 2, 4], [-2, 0, 2]]\n"
     ]
    }
   ],
   "source": [
    "given_numbers = [1, -6, 4, 2, -1, 2, 0, -2, 0 ]\n",
    "\n",
    "print(\"Given numbers : \", given_numbers)\n",
    "\n",
    "n = len(given_numbers)\n",
    "\n",
    "unique_triplets = []\n",
    "\n",
    "\n",
    "for i in range(n-2):\n",
    "    for j in range(i+1,n-1):\n",
    "        for k in range(j+1,n):\n",
    "            if (given_numbers[i] + given_numbers[j] + given_numbers[k]) == 0:\n",
    "                triplet = sorted([given_numbers[i], given_numbers[j], given_numbers[k]])\n",
    "                if triplet not in unique_triplets:\n",
    "                    unique_triplets.append(triplet)\n",
    "                    \n",
    "\n",
    "print(\"\\nUnique triplets whose three elements sum to zero :\\n\")                    \n",
    "print(unique_triplets)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5cf8f1a",
   "metadata": {},
   "source": [
    "#### 99. Write a Python program to make combinations of 3 digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0ca143d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given numbers :  [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "3 digit Combination Numbers :\n",
      "\n",
      "[(0, 1, 2), (0, 1, 3), (0, 1, 4), (0, 1, 5), (0, 1, 6), (0, 1, 7), (0, 1, 8), (0, 2, 3), (0, 2, 4), (0, 2, 5), (0, 2, 6), (0, 2, 7), (0, 2, 8), (0, 3, 4), (0, 3, 5), (0, 3, 6), (0, 3, 7), (0, 3, 8), (0, 4, 5), (0, 4, 6), (0, 4, 7), (0, 4, 8), (0, 5, 6), (0, 5, 7), (0, 5, 8), (0, 6, 7), (0, 6, 8), (0, 7, 8), (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 2, 6), (1, 2, 7), (1, 2, 8), (1, 3, 4), (1, 3, 5), (1, 3, 6), (1, 3, 7), (1, 3, 8), (1, 4, 5), (1, 4, 6), (1, 4, 7), (1, 4, 8), (1, 5, 6), (1, 5, 7), (1, 5, 8), (1, 6, 7), (1, 6, 8), (1, 7, 8), (2, 3, 4), (2, 3, 5), (2, 3, 6), (2, 3, 7), (2, 3, 8), (2, 4, 5), (2, 4, 6), (2, 4, 7), (2, 4, 8), (2, 5, 6), (2, 5, 7), (2, 5, 8), (2, 6, 7), (2, 6, 8), (2, 7, 8), (3, 4, 5), (3, 4, 6), (3, 4, 7), (3, 4, 8), (3, 5, 6), (3, 5, 7), (3, 5, 8), (3, 6, 7), (3, 6, 8), (3, 7, 8), (4, 5, 6), (4, 5, 7), (4, 5, 8), (4, 6, 7), (4, 6, 8), (4, 7, 8), (5, 6, 7), (5, 6, 8), (5, 7, 8), (6, 7, 8)]\n"
     ]
    }
   ],
   "source": [
    "given_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "print(\"Given numbers : \", given_numbers)\n",
    "\n",
    "n = len(given_numbers)\n",
    "\n",
    "combination_3digit = []\n",
    "\n",
    "for i in range(n):\n",
    "    for j in range(i+1,n):\n",
    "        for k in range(j+1,n):\n",
    "            combination_3digit.append((i,j,k))\n",
    " \n",
    "print(\"\\n3 digit Combination Numbers :\\n\")\n",
    "print(combination_3digit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1781fb1a",
   "metadata": {},
   "source": [
    "#### 100. Write a Python program that prints long text, converts it to a list, and prints all the words and the frequency of each word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ec7327bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String:\n",
      " India is great India is part of Asia India has rich culture and heritage \n",
      "\n",
      "List:\n",
      " ['India', 'is', 'great', 'India', 'is', 'part', 'of', 'Asia', 'India', 'has', 'rich', 'culture', 'and', 'heritage'] \n",
      "\n",
      "Pairs (Words and Frequencies):\n",
      "\n",
      "India 3\n",
      "is 2\n",
      "great 1\n",
      "part 1\n",
      "of 1\n",
      "Asia 1\n",
      "has 1\n",
      "rich 1\n",
      "culture 1\n",
      "and 1\n",
      "heritage 1\n"
     ]
    }
   ],
   "source": [
    "string_words = \"India is great India is part of Asia India has rich culture and heritage\"\n",
    "\n",
    "print(f\"String:\\n {string_words} \\n\")\n",
    "\n",
    "word_list = string_words.split()\n",
    "\n",
    "print(f\"List:\\n {word_list} \\n\")\n",
    "\n",
    "word_freq = {}\n",
    "\n",
    "for word in word_list:\n",
    "    if word not in word_freq:\n",
    "        word_freq[word] = 1\n",
    "    else:\n",
    "        word_freq[word] += 1\n",
    "        \n",
    "print(\"Pairs (Words and Frequencies):\\n\")\n",
    "\n",
    "for word, freq in word_freq.items():\n",
    "    print(word, freq)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "da8989f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String:\n",
      " India is great India is part of Asia India has rich culture and heritage \n",
      "\n",
      "List:\n",
      " ['India', 'is', 'great', 'India', 'is', 'part', 'of', 'Asia', 'India', 'has', 'rich', 'culture', 'and', 'heritage'] \n",
      "\n",
      "Pairs (Words and Frequencies:\n",
      " [('India', 3), ('is', 2), ('great', 1), ('India', 3), ('is', 2), ('part', 1), ('of', 1), ('Asia', 1), ('India', 3), ('has', 1), ('rich', 1), ('culture', 1), ('and', 1), ('heritage', 1)]\n"
     ]
    }
   ],
   "source": [
    "string_words = \"India is great India is part of Asia India has rich culture and heritage\"\n",
    "\n",
    "word_list = string_words.split()\n",
    "\n",
    "word_freq = [word_list.count(n) for n in word_list]\n",
    "\n",
    "print(f\"String:\\n {string_words} \\n\")\n",
    "\n",
    "print(f\"List:\\n {word_list} \\n\")\n",
    "\n",
    "print(\"Pairs (Words and Frequencies:\\n {}\".format(str(list(zip(word_list, word_freq)))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "252e1d87",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "2b551c35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String:\n",
      " India is great India is part of Asia India has rich culture and heritage \n",
      "\n",
      "Pairs (Character and Frequencies):\n",
      " \n",
      "I 3\n",
      "n 4\n",
      "d 4\n",
      "i 8\n",
      "a 9\n",
      "  13\n",
      "s 4\n",
      "g 2\n",
      "r 5\n",
      "e 4\n",
      "t 4\n",
      "p 1\n",
      "o 1\n",
      "f 1\n",
      "A 1\n",
      "h 3\n",
      "c 2\n",
      "u 2\n",
      "l 1\n"
     ]
    }
   ],
   "source": [
    "string_words = \"India is great India is part of Asia India has rich culture and heritage\"\n",
    "\n",
    "print(f\"String:\\n {string_words} \\n\")\n",
    "\n",
    "word_freq = {}\n",
    "\n",
    "for word in string_words:\n",
    "    if word not in word_freq:\n",
    "        word_freq[word] = 1\n",
    "    else:\n",
    "        word_freq[word] += 1\n",
    "\n",
    "print(\"Pairs (Character and Frequencies):\\n \")\n",
    "\n",
    "# Print the frequency of each word\n",
    "for word, freq in word_freq.items():\n",
    "    print(word, freq)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}