Python_Program9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e7aabae2",
   "metadata": {},
   "source": [
    "# Programm 81\n",
    "#### Write a program to compute the frequency of the words from the input. The output should output after sorting the key #### alphanumerically. Suppose the following input is\n",
    "- supplied to the program:\n",
    "- New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.\n",
    "- Then, the output should be:\n",
    "   - 2:2\n",
    "   - 3.:1\n",
    "   - 3?:1\n",
    "   - New:1\n",
    "   - Python:5\n",
    "   - Read:1\n",
    "   - and:1\n",
    "   - between:1\n",
    "   - choosing:1\n",
    "   - or:2\n",
    "   - to:1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9860003d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.\n",
      "2: 2\n",
      "3: 2\n",
      "and: 1\n",
      "between: 1\n",
      "choosing: 1\n",
      "new: 1\n",
      "or: 2\n",
      "python: 5\n",
      "read: 1\n",
      "to: 1\n"
     ]
    }
   ],
   "source": [
    "input_sentence = input(\"Enter a sentence: \")\n",
    "# Split the sentence into words\n",
    "words = input_sentence.split()\n",
    "# Create a dictionary to store word frequencies\n",
    "word_freq = {}\n",
    "# Count word frequencies\n",
    "for word in words:\n",
    "    # Remove punctuation (., ?) from the word\n",
    "    word = word.strip('.,?')\n",
    "    # Convert the word to lowercase to ensure case-insensitive counting\n",
    "    word = word.lower()\n",
    "    # Update the word frequency in the dictionary\n",
    "    if word in word_freq:\n",
    "        word_freq[word] += 1\n",
    "    else:\n",
    "        word_freq[word] = 1\n",
    "# Sort the words alphanumerically\n",
    "sorted_words = sorted(word_freq.items())\n",
    "# Print the word frequencies\n",
    "for word, frequency in sorted_words:\n",
    "    print(f\"{word}: {frequency}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dedfd503",
   "metadata": {},
   "source": [
    "# Program 82\n",
    "#### Define a class Person and its two child classes: Male and Female. All classes have a method \"getGender\" which can print \"Male\" for Male class and \"Female\" for Female class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6b0ee8d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unknown\n",
      "Male\n",
      "Female\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def getGender(self):\n",
    "        return \"Unknown\"\n",
    "\n",
    "class Male(Person):\n",
    "    def getGender(self):\n",
    "        return \"Male\"\n",
    "\n",
    "class Female(Person):\n",
    "    def getGender(self):\n",
    "        return \"Female\"\n",
    "\n",
    "# Creating instances of the classes\n",
    "person = Person()\n",
    "male = Male()\n",
    "female = Female()\n",
    "\n",
    "# Printing the gender for each instance\n",
    "print(person.getGender())  # Output: Unknown\n",
    "print(male.getGender())    # Output: Male\n",
    "print(female.getGender())  # Output: Female"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51ca7a52",
   "metadata": {},
   "source": [
    "# Program 83\n",
    "#### Please write a program to generate all sentences where subject is in [\"I\", \"You\"] and verb is in [\"Play\", \"Love\"] and the object is in [\"Hockey\",\"Football\"]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "eb24e3f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I Play Hockey.\n",
      "I Play Football.\n",
      "I Love Hockey.\n",
      "I Love Football.\n",
      "You Play Hockey.\n",
      "You Play Football.\n",
      "You Love Hockey.\n",
      "You Love Football.\n"
     ]
    }
   ],
   "source": [
    "subjects = [\"I\", \"You\"]\n",
    "verbs = [\"Play\", \"Love\"]\n",
    "objects = [\"Hockey\", \"Football\"]\n",
    "sentences = []\n",
    "\n",
    "# Nested loops to iterate through all combinations of subjects, verbs, and objects\n",
    "for sub in subjects:\n",
    "    for vrb in verbs:\n",
    "        for obj in objects:\n",
    "            # Form a sentence using the current combination\n",
    "            sentence = f\"{sub} {vrb} {obj}.\"\n",
    "            # Append the sentence to the list\n",
    "            sentences.append(sentence)\n",
    "\n",
    "# Print each sentence\n",
    "for sentence in sentences:\n",
    "    print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b755f30b",
   "metadata": {},
   "source": [
    "# Program 83\n",
    "#### Please write a program to compress and decompress the string \"hello world!hello world!hello world!hello world!\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c9dee05d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String: hello world!hello world!hello world!hello world!\n",
      "Compressed String: b'x\\x9c\\xcbH\\xcd\\xc9\\xc9W(\\xcf/\\xcaIQ\\xcc \\x82\\r\\x00\\xbd[\\x11\\xf5'\n",
      "Decompressed String: hello world!hello world!hello world!hello world!\n"
     ]
    }
   ],
   "source": [
    "import zlib\n",
    "\n",
    "# Original string\n",
    "string = \"hello world!hello world!hello world!hello world!\"\n",
    "\n",
    "# Compress the string\n",
    "compressed_string = zlib.compress(string.encode())\n",
    "\n",
    "# Decompress the string\n",
    "decompressed_string = zlib.decompress(compressed_string).decode()\n",
    "\n",
    "# Print the results\n",
    "print(\"Original String:\", string)\n",
    "print(\"Compressed String:\", compressed_string)\n",
    "print(\"Decompressed String:\", decompressed_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79f144c9",
   "metadata": {},
   "source": [
    "# Program 84\n",
    "#### Please write a binary search function which searches an item in a sorted list. Thefunction should return the index of element          to be searched in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1818d83b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element 4 found at index 3\n"
     ]
    }
   ],
   "source": [
    "def binary_search(arr, target):\n",
    "    left, right = 0, len(arr) - 1\n",
    "    \n",
    "    while left <= right:\n",
    "        mid = (left + right) // 2\n",
    "        \n",
    "        if arr[mid] == target:\n",
    "            return mid  # Element found, return its index\n",
    "        elif arr[mid] < target:\n",
    "            left = mid + 1  # Target is in the right half\n",
    "        else:\n",
    "            right = mid - 1  # Target is in the left half\n",
    "    \n",
    "    return -1  # Element not found in the list\n",
    "\n",
    "# Example usage:\n",
    "sorted_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "target_element = 4\n",
    "result = binary_search(sorted_list, target_element)\n",
    "\n",
    "if result != -1:\n",
    "    print(f\"Element {target_element} found at index {result}\")\n",
    "else:\n",
    "    print(f\"Element {target_element} not found in the list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "549df3a1",
   "metadata": {},
   "source": [
    "# Program 85\n",
    "#### Please write a program using generator to print the numbers which can be divisible by 5 and 7 between 0 and n in comma              separated form while n is input by console.\n",
    "     - Example:\n",
    "     - If the following n is given as input to the program: 100\n",
    "     - Then, the output of the program should be:\n",
    "     - 0,35,70"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1ca4d062",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value for n: 100\n",
      "0,35,70\n"
     ]
    }
   ],
   "source": [
    "def divisible_by_5_and_7(n):\n",
    "    for num in range(n + 1):\n",
    "        if num % 5 == 0 and num % 7 == 0:\n",
    "            yield num\n",
    "\n",
    "try:\n",
    "    n = int(input(\"Enter a value for n: \"))\n",
    "    result = divisible_by_5_and_7(n)\n",
    "    print(','.join(map(str, result)))\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter a valid integer for n.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4c898aa",
   "metadata": {},
   "source": [
    "# Program 86\n",
    "#### Please write a program using generator to print the even numbers between 0 and n in comma separated form while n is                  input by console.\n",
    "     - Example:\n",
    "     - If the following n is given as input to the program: 10\n",
    "     - Then, the output of the program should be: 0,2,4,6,8,10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bc4a2bcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value for n: 10\n",
      "0,2,4,6,8,10\n"
     ]
    }
   ],
   "source": [
    "def even_numbers(n):\n",
    "    for num in range(n + 1):\n",
    "        if num % 2 == 0:\n",
    "            yield num\n",
    "\n",
    "try:\n",
    "    n = int(input(\"Enter a value for n: \"))\n",
    "    result = even_numbers(n)\n",
    "    print(','.join(map(str, result)))\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter a valid integer for n.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7014332",
   "metadata": {},
   "source": [
    "# Program 87\n",
    "#### The Fibonacci Sequence is computed based on the following formula:\n",
    "### f(n)=0 if n=0\n",
    "### f(n)=1 if n=1\n",
    "### f(n)=f(n-1)+f(n-2) if n>1\n",
    "##### Please write a program using list comprehension to print the Fibonacci Sequence in comma separated form with a given n input by console.\n",
    "     Example:\n",
    "     If the following n is given as input to the program: 8\n",
    "     Then, the output of the program should be: 0,1,1,2,3,5,8,13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "daca43f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value for n: 8\n",
      "0,1,1,2,3,5,8,13\n"
     ]
    }
   ],
   "source": [
    "def fibonacci(n):\n",
    "    sequence = [0, 1]  # Initializing the sequence with the first two Fibonacci numbers\n",
    "    [sequence.append(sequence[-1] + sequence[-2]) for _ in range(2, n)]\n",
    "    return sequence\n",
    "\n",
    "try:\n",
    "    n = int(input(\"Enter a value for n: \"))\n",
    "    result = fibonacci(n)\n",
    "    print(','.join(map(str, result)))\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter a valid integer for n.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68e55fc3",
   "metadata": {},
   "source": [
    "# Program 88\n",
    "#### Assuming that we have some email addresses in the \"username@companyname.com (mailto:username@companyname.com)\" format, please write program to print the user name of a given email address. Both user names and company names are composed of letters only.\n",
    "- Example:\n",
    "- If the following email address is given as input to the program:\n",
    "- john@google.com (mailto:john@google.com)\n",
    "- Then, the output of the program should be:\n",
    " - john"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "954e2594",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an email address: john@google.com\n",
      "john\n"
     ]
    }
   ],
   "source": [
    "def extract_username(email):\n",
    "    # Split the email address at '@' to separate the username and domain\n",
    "    parts = email.split('@')\n",
    "    \n",
    "    # Check if the email address has the expected format\n",
    "    if len(parts) == 2:\n",
    "        return parts[0]  # The username is the first part\n",
    "    else:\n",
    "        return \"Invalid email format\"\n",
    "\n",
    "try:\n",
    "    email = input(\"Enter an email address: \")\n",
    "    username = extract_username(email)\n",
    "    print(username)\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter a valid email address.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bffc60e",
   "metadata": {},
   "source": [
    "# Program 89\n",
    "#### Define a class named Shape and its subclass Square. The Square class has an init function which takes a length as argument. Both classes have an area function which can print the area of the shape where Shape's area is 0 by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "abd6f0eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the length of the square: 5\n",
      "Shape's area by default: 0\n",
      "Area of the square: 25.0\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def __init__(self):\n",
    "        pass  # Default constructor, no need to initialize anything\n",
    "\n",
    "    def area(self):\n",
    "        return 0  # Shape's area is 0 by default\n",
    "\n",
    "class Square(Shape):\n",
    "    def __init__(self, length):\n",
    "        super().__init__()  # Call the constructor of the parent class\n",
    "        self.length = length\n",
    "\n",
    "    def area(self):\n",
    "        return self.length ** 2  # Calculate the area of the square\n",
    "\n",
    "# Create instances of the classes\n",
    "shape = Shape()\n",
    "square_length = float(input(\"Enter the length of the square: \"))\n",
    "square = Square(square_length)\n",
    "\n",
    "# Calculate and print the areas\n",
    "print(\"Shape's area by default:\", shape.area())\n",
    "print(\"Area of the square:\", square.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e820f645",
   "metadata": {},
   "source": [
    "# Program 90\n",
    "#### Write a function that stutters a word as if someone is struggling to read it. The first two letters are repeated twice with an                ellipsis ... and space after each, and then the word is pronounced with a question mark ?.\n",
    "- Examples\n",
    "- stutter(\"incredible\") ➞ \"in... in... incredible?\"\n",
    "- stutter(\"enthusiastic\") ➞ \"en... en... enthusiastic?\"\n",
    "- stutter(\"outstanding\") ➞ \"ou... ou... outstanding?\"\n",
    "- Hint :- Assume all input is in lower case and at least two characters long."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "21c13d82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in... in... incredible?\n",
      "en... en... enthusiastic?\n",
      "ou... ou... outstanding?\n"
     ]
    }
   ],
   "source": [
    "def stutter(word):\n",
    "    if len(word) < 2:\n",
    "        return \"Word must be at least two characters long.\"\n",
    "\n",
    "    stuttered_word = f\"{word[:2]}... {word[:2]}... {word}?\"\n",
    "    return stuttered_word\n",
    "\n",
    "# Test cases\n",
    "print(stutter(\"incredible\"))\n",
    "print(stutter(\"enthusiastic\"))\n",
    "print(stutter(\"outstanding\"))"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}