Python_Program8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1ba4a202",
   "metadata": {},
   "source": [
    "# Program 71\n",
    "#### Write a Python program to insertion at the beginning in OrderedDict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fc50c402",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated OrderedDict: OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "# Create an OrderedDict\n",
    "ordered_dict = OrderedDict([('b', 2), ('c', 3), ('d', 4)])\n",
    "# Item to insert at the beginning\n",
    "new_item = ('a', 1)\n",
    "# Create a new OrderedDict with the new item as the first element\n",
    "new_ordered_dict = OrderedDict([new_item])\n",
    "# Merge the new OrderedDict with the original OrderedDict\n",
    "new_ordered_dict.update(ordered_dict)\n",
    "# Print the updated OrderedDict\n",
    "print(\"Updated OrderedDict:\", new_ordered_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6a44189",
   "metadata": {},
   "source": [
    "# Program 72\n",
    "#### Write a Python program to check order of character in string using OrderedDict()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d898448c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The order of characters in the input string matches the reference\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "def check_order(string, reference):\n",
    " # Create OrderedDicts for both strings\n",
    "    string_dict = OrderedDict.fromkeys(string)\n",
    "    reference_dict = OrderedDict.fromkeys(reference)\n",
    " \n",
    "    # Check if the OrderedDict for the string matches the OrderedDict from keys\n",
    "    return string_dict == reference_dict\n",
    "# Input strings\n",
    "input_string = \"hello world\"\n",
    "reference_string = \"helo wrd\"\n",
    "# Check if the order of characters in input_string matches reference_string\n",
    "if check_order(input_string, reference_string):\n",
    "    print(\"The order of characters in the input string matches the reference\")\n",
    "else:\n",
    "    print(\"The order of characters in the input string does not match the reference\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68385e3a",
   "metadata": {},
   "source": [
    "# Program 73\n",
    "#### Write a Python program to sort Python Dictionaries by Key or Value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9190552b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted by keys:\n",
      "apple: 3\n",
      "banana: 1\n",
      "cherry: 2\n",
      "date: 4\n"
     ]
    }
   ],
   "source": [
    "# Sort by Keys:\n",
    "sample_dict = {'apple': 3, 'banana': 1, 'cherry': 2, 'date': 4}\n",
    "sorted_dict_by_keys = dict(sorted(sample_dict.items()))\n",
    "print(\"Sorted by keys:\")\n",
    "for key, value in sorted_dict_by_keys.items():\n",
    "    print(f\"{key}: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e2a85582",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1172891907.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[5], line 3\u001b[1;36m\u001b[0m\n\u001b[1;33m    sorted_dict_by_values = dict(sorted(sample_dict.items(), key=lambda items))\u001b[0m\n\u001b[1;37m                                                                             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Sort by values\n",
    "sample_dict = {'apple': 3, 'banana': 1, 'cherry': 2, 'date': 4}\n",
    "sorted_dict_by_values = dict(sorted(sample_dict.items(), key=lambda items))\n",
    "print(\"Sorted by values:\")\n",
    "for key, value in sorted_dict_by_values.items():\n",
    "    print(f\"{key}: {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8632c19",
   "metadata": {},
   "source": [
    "# Program 74\n",
    "### Write a program that calculates and prints the value according to the given formula:\n",
    "- Following are the fixed values of C and H:\n",
    "- C is 50. H is 30.\n",
    "- D is the variable whose values should be input to your program in a comma\u0002separated sequence.\n",
    "- Example\n",
    "  - Let us assume the following comma separated input sequence is given to the\n",
    "  - program:\n",
    "  - 100,150,180\n",
    "  - The output of the program should be:\n",
    "  - 18,22,24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fd236009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter comma-separated values of D: 100,150,180\n",
      "18,22,24\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "# Fixed values\n",
    "C = 50\n",
    "H = 30\n",
    "# Function to calculate Q\n",
    "def calculate_Q(D):\n",
    "    return int(math.sqrt((2 * C * D) / H))\n",
    "# Input comma-separated sequence of D values\n",
    "input_sequence = input(\"Enter comma-separated values of D: \")\n",
    "D_values = input_sequence.split(',')\n",
    "# Calculate and print Q for each D value\n",
    "result = [calculate_Q(int(D)) for D in D_values]\n",
    "print(','.join(map(str, result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "774e0429",
   "metadata": {},
   "source": [
    "# Program 75\n",
    "#### Write a program which takes 2 digits, X,Y as input and generates a 2-dimensional array. \n",
    "#### The element value in the i-th row and j-th column of the array should be i*j.\n",
    "    - Note: i=0,1.., X-1; j=0,1,¡Y-1.\n",
    "    - Example\n",
    "    - Suppose the following inputs are given to the program:\n",
    "    - 3,5\n",
    "    - Then, the output of the program should be:\n",
    "    - [[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aa7856a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two digits (X, Y): 3,5\n",
      "[0, 0, 0, 0, 0]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# Input two digits, X and Y\n",
    "X, Y = map(int, input(\"Enter two digits (X, Y): \").split(','))\n",
    "# Initialize a 2D array filled with zeros\n",
    "array = [[0 for j in range(Y)] for i in range(X)]\n",
    "# Fill the array with values i * j\n",
    "for i in range(X):\n",
    "    for j in range(Y):\n",
    "        array[i][j] = i * j\n",
    "# Print the 2D array\n",
    "for row in array:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a202543",
   "metadata": {},
   "source": [
    "# Program 76\n",
    "#### Write a program that accepts a comma separated sequence of words as input and prints the words in a comma-separated #### sequence after sorting them alphabetically.\n",
    "    - Suppose the following input is supplied to the program: without,hello,bag,world\n",
    "    - Then, the output should be:\n",
    "         - bag,hello,without,world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "75a34c3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a comma-separated sequence of words: without,hello,bag,world\n",
      "Sorted words: bag,hello,without,world\n"
     ]
    }
   ],
   "source": [
    "# Accept input from the user\n",
    "input_sequence = input(\"Enter a comma-separated sequence of words: \")\n",
    "# Split the input into a list of words\n",
    "words = input_sequence.split(',')\n",
    "# Sort the words alphabetically\n",
    "sorted_words = sorted(words)\n",
    "# Join the sorted words into a comma-separated sequence\n",
    "sorted_sequence = ','.join(sorted_words)\n",
    "# Print the sorted sequence\n",
    "print(\"Sorted words:\", sorted_sequence)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64be415a",
   "metadata": {},
   "source": [
    "# Program 77\n",
    "#### Write a program that accepts a sequence of whitespace separated words as input and prints the words after removing all #### duplicate words and sorting them alphanumerically.\n",
    "    - Suppose the following input is supplied to the program: hello world and practice makes perfect and hello world again\n",
    "    - Then, the output should be: again and hello makes perfect practice world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "edf65b8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sequence of whitespace-separated words: hello world and practice makes perfect and hello world again\n",
      "Result: again and hello makes perfect practice world\n"
     ]
    }
   ],
   "source": [
    "# Accept input from the user\n",
    "input_sequence = input(\"Enter a sequence of whitespace-separated words:\")\n",
    "# Split the input into words and convert it into a set to remove duplicates\n",
    "words = set(input_sequence.split())\n",
    "# Sort the unique words alphanumerically\n",
    "sorted_words = sorted(words)\n",
    "# Join the sorted words into a string with whitespace separation\n",
    "result = ' '.join(sorted_words)\n",
    "# Print the result\n",
    "print(\"Result:\", result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "596c7e6d",
   "metadata": {},
   "source": [
    "# Program 78\n",
    "#### Write a program that accepts a sentence and calculate the number of letters and digits. \n",
    "     - Suppose the following input is supplied to the program: hello world! 123\n",
    "     - Then, the output should be: LETTERS 10\n",
    "     - DIGITS 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "21cca046",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: hello world! 123\n",
      "LETTERS 10\n",
      "DIGITS 3\n"
     ]
    }
   ],
   "source": [
    "# Accept input from the user\n",
    "sentence = input(\"Enter a sentence: \")\n",
    "# Initialize counters for letters and digits\n",
    "letter_count = 0\n",
    "digit_count = 0\n",
    "# Iterate through each character in the sentence\n",
    "for char in sentence:\n",
    "    if char.isalpha():\n",
    "        letter_count += 1\n",
    "    elif char.isdigit():\n",
    "        digit_count += 1\n",
    "# Print the results\n",
    "print(\"LETTERS\", letter_count)\n",
    "print(\"DIGITS\", digit_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98aaf32a",
   "metadata": {},
   "source": [
    "# Program 79\n",
    "#### A website requires the users to input username and password to register. \n",
    "#### Write a program to check the validity of password input by users. Following are the criteria\n",
    "   - for checking the password:\n",
    "   - 1. At least 1 letter between [a-z]\n",
    "   - 2. At least 1 number between [0-9]\n",
    "   - 3. At least 1 letter between [A-Z]\n",
    "   - 4. At least 1 character from [$#@]\n",
    "   - 5. Minimum length of transaction password: 6\n",
    "   - 6. Maximum length of transaction password: 12\n",
    "- Your program should accept a sequence of comma separated passwords and will check them according to the above criteria.     Passwords that match the criteria are to be printed, each separated by a comma.\n",
    "  - Example\n",
    "  - If the following passwords are given as input to the program:\n",
    "  - ABd1234@1,a F1#,2w3E*,2We3345 Then, the output of the program should be:ABd1234@1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d27ad151",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter passwords separated by commas: ABd1234@1,a F1#,2w3E*,2We3345, ABd1234@1\n",
      "ABd1234@1, ABd1234@1\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "# Function to check if a password is valid\n",
    "def is_valid_password(password):\n",
    "    # Check the length of the password\n",
    "    if 6 <= len(password) <= 12:\n",
    "        # Check if the password matches all the criteria using regular expression\n",
    "        if re.match(r\"^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[$#@])\", password):\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "# Accept input from the user as comma-separated passwords\n",
    "passwords = input(\"Enter passwords separated by commas: \").split(',')\n",
    "\n",
    "# Initialize a list to store valid passwords\n",
    "valid_passwords = []\n",
    "\n",
    "# Iterate through the passwords and check their validity\n",
    "for psw in passwords:\n",
    "    if is_valid_password(psw):\n",
    "        valid_passwords.append(psw)\n",
    "\n",
    "# Print the valid passwords separated by commas\n",
    "print(','.join(valid_passwords))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eb317a7",
   "metadata": {},
   "source": [
    "# Program 80\n",
    "#### Define a class with a generator which can iterate the numbers, which are divisible by 7, between a given range 0 and n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bc525644",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your desired range: 50\n",
      "0\n",
      "7\n",
      "14\n",
      "21\n",
      "28\n",
      "35\n",
      "42\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "class DivisibleBySeven:\n",
    "    def __init__(self, n):\n",
    "        self.n = n\n",
    "\n",
    "    def generate_divisible_by_seven(self):\n",
    "        for num in range(self.n + 1):\n",
    "            if num % 7 == 0:\n",
    "                yield num\n",
    "\n",
    "# Get user input for the desired range\n",
    "n = int(input(\"Enter your desired range: \"))\n",
    "\n",
    "# Create an instance of DivisibleBySeven\n",
    "divisible_by_seven_generator = DivisibleBySeven(n)\n",
    "\n",
    "# Generate and print numbers divisible by seven\n",
    "for num in divisible_by_seven_generator.generate_divisible_by_seven():\n",
    "    print(num)"
   ]
  }
 ],
 "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
}