Lab Assignment 1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: BaNaNa\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "# STRING\n",
    "\"\"\" 1. From a given string, print the string in all uppercase if the number of uppercase letters is more than lowercase letters.\n",
    "Otherwise if lowercase is greater or equal to uppercase letters, print all lowercase.\n",
    "The inputs will contain letters (A-Z, a-z) only. \"\"\"\n",
    "\n",
    "string = input(\"Enter String: \")\n",
    "count_lower=0\n",
    "count_upper=0\n",
    "for val in string:\n",
    "    if val.islower():\n",
    "        count_lower+=1\n",
    "    else:\n",
    "        count_upper+=1\n",
    "\n",
    "if count_lower >= count_upper:\n",
    "    print(string.lower())\n",
    "else:\n",
    "    print(string.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: a1asfghsf22222\n",
      "MIXED\n"
     ]
    }
   ],
   "source": [
    "\"\"\"2. Given a string, print whether it is a number, word or mixed with digit and letters. \n",
    "If all the characters are numeric values, print NUMBER. \n",
    "If they are all letters, print WORD. If it is mixed, print MIXED\"\"\"\n",
    "\n",
    "string = input(\"Enter String: \")\n",
    "\n",
    "if string.isnumeric():\n",
    "   print(\"NUMBER\")\n",
    "elif string.isalpha():\n",
    "   print(\"WORD\")\n",
    "else:\n",
    "   print(\"MIXED\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: coDIng\n",
      "BLANK\n"
     ]
    }
   ],
   "source": [
    "\"\"\"3. In a given string, there will be two uppercase letters in between some lowercase letters.\n",
    "Print the substring from the first uppercase letter to the last uppercase letter excluding them. \n",
    "If there are no letters in between them, print the word BLANK. \n",
    "It is guaranteed that there will be only two uppercase letters in the string\"\"\"\n",
    "\n",
    "user = input(\"Enter String: \")\n",
    "capital_letters= \" ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "first_capital=0\n",
    "second_capital=0\n",
    "str_len = len(user)\n",
    "\n",
    "for x in range(len(user)):\n",
    "    letter= user[x]\n",
    "    if letter in capital_letters:\n",
    "        first_capital= x\n",
    "        new_str= user[x:str_len]\n",
    "        new_strLen = len(new_str)\n",
    "        break\n",
    "\n",
    "for y in range(first_capital+1,new_strLen):\n",
    "    letter2 = new_str[y]\n",
    "    if letter2 in capital_letters:\n",
    "        second_capital= x+y\n",
    "        break\n",
    "\n",
    "if second_capital==0:\n",
    "    print(\"BLANK\")\n",
    "else:\n",
    "    string = user[first_capital+1:second_capital]\n",
    "    print(string)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: The book is not too good!\n",
      "The book is not excellent!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "4. Write a Python program to find the first appearance of the substring 'too' and 'good' from a given string. \n",
    "If 'too' follows the 'good', replace the whole 'too'' good' substring with 'excellent' and print the resulting string.\n",
    "If the above does not appear, print the string as it is.\n",
    "\"\"\"\n",
    "\n",
    "string = input(\"Enter String: \")\n",
    "\n",
    "if \"too good\" in string:\n",
    "    print(string.replace(\"too good\",\"excellent\"))\n",
    "else:\n",
    "    print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Strings: harry,hermione\n",
      "hrrhr\n"
     ]
    }
   ],
   "source": [
    "\"\"\"5. Create a string from two given strings by concatenating common characters of the given strings.\"\"\"\n",
    "\n",
    "user = input('Enter Strings: ')\n",
    "new_str=\"\"\n",
    "str1,str2= user.split(\",\")\n",
    "str1_len = len(str1)\n",
    "str2_len=len(str2)\n",
    "\n",
    "for val in range(str1_len):\n",
    "    char =str1[val]\n",
    "    if char in str2:\n",
    "        new_str+=char\n",
    "for val2 in range(str2_len):\n",
    "    char=str2[val2]\n",
    "    if char in str1:\n",
    "        new_str+=char\n",
    "if new_str==\"\":\n",
    "    print(\"Nothin in Common\")\n",
    "else:\n",
    "    print(new_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Password: dasd\n",
      "Uppercase Missing\n",
      "Special Missing\n",
      "Digit Missing\n"
     ]
    }
   ],
   "source": [
    "\"\"\"STring. 6\"\"\"\n",
    "\n",
    "user = input(\"Enter Password: \")\n",
    "str_len= len(user)\n",
    "lower = False\n",
    "upper = False\n",
    "number = False\n",
    "special = False\n",
    "\n",
    "for val in range(str_len):\n",
    "    char = user[val]\n",
    "    asci = ord(char)\n",
    "\n",
    "    if asci == 35 or asci == 36 or asci==64 or asci==95:\n",
    "        special=True\n",
    "    if 48 <= asci <= 57:\n",
    "        number = True\n",
    "    if 65<= asci <= 90:\n",
    "        upper=True\n",
    "    if 97<= asci <= 122:\n",
    "        lower=True\n",
    "if upper ==True and lower == True and number == True and special == True:\n",
    "    print(\"Ok\")\n",
    "if upper == True and lower == True and number == True and special == False:\n",
    "    print(\"Special Missing\")\n",
    "if     upper ==True and lower == True and number == False and special == True:\n",
    "    print(\"Digit Missing\")\n",
    "if upper ==True and lower == False and number == True and special == True:\n",
    "    print(\"Lowercase Missing\")\n",
    "if upper ==False and lower == True and number == True and special == True:\n",
    "    print(\"Uppercase Missing\")\n",
    "if upper ==True and lower == True and number == False and special == False:\n",
    "    print(\"Digit Missing\")\n",
    "    print(\"Special Missing\")\n",
    "if upper ==True and lower == False and number == True and special == False:\n",
    "    print(\"Special Missing\")\n",
    "    print(\"Lowercase Missing\")\n",
    "if upper ==False and lower == True and number == True and special == False:\n",
    "    print(\"Special Missing\")\n",
    "    print(\"Uppercase Missing\")\n",
    "if upper ==True and lower == False and number == False and special == True:\n",
    "    print(\"Digit Missing\")\n",
    "    print(\"Lowercase Missing\")\n",
    "if upper ==False and lower == True and number == False and special == True:\n",
    "    print(\"Uppercase Missing\")\n",
    "    print(\"Digit Missing\")\n",
    "if upper ==False and lower == False and number == True and special == True:\n",
    "    print(\"Uppercase Missing\")\n",
    "    print(\"Lowercase Missing\")\n",
    "if upper ==False and lower == False and number == False and special == True:\n",
    "    print(\"Uppercase Missing\")\n",
    "    print(\"Lowercase Missing\")\n",
    "    print(\"Digit Missing\")\n",
    "if upper ==False and lower == False and number == True and special == False:\n",
    "    print(\"Uppercase Missing\")\n",
    "    print(\"Lowercase Missing\")\n",
    "    print(\"Special Missing\")\n",
    "if upper ==False and lower == True and number == False and special == False:\n",
    "    print(\"Uppercase Missing\")\n",
    "    print(\"Special Missing\")\n",
    "    print(\"Digit Missing\")\n",
    "if upper ==True and lower == False and number == False and special == False:\n",
    "    print(\"Lowercase Missing\")\n",
    "    print(\"Special Missing\")\n",
    "    print(\"Digit Missing\")\n",
    "if upper ==False and lower == False and number == False and special == False:\n",
    "    print(\"Lowercase Missing\")\n",
    "    print(\"Special Missing\")\n",
    "    print(\"Digit Missing\")\n",
    "    print(\"Lowercase Missing\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number: 10\n",
      "Enter Number: 20\n",
      "Enter Number: 20\n",
      "Enter Number: 30\n",
      "Enter Number: 10\n",
      "Enter Number: 50\n",
      "Enter Number: 90\n",
      "Enter Number: stop\n",
      "10 - 2 times\n",
      "20 - 2 times\n",
      "30 - 1 times\n",
      "50 - 1 times\n",
      "90 - 1 times\n"
     ]
    }
   ],
   "source": [
    "# LIST\n",
    "\"\"\"1. Write a python program which prints the frequency of the numbers that were given as input by the user. Stop taking input when you find the string “STOP”. \n",
    "Do not print the frequency of numbers that were not given as input.\"\"\"\n",
    "\n",
    "list = []\n",
    "for i in range(9999999999999):\n",
    "    num = input(\"Enter Number: \")\n",
    "    if num ==\"STOP\" or num==\"stop\":\n",
    "        break\n",
    "    else:\n",
    "        list.append(num)\n",
    "list_two= []\n",
    "list_len=len(list)\n",
    "for i in range(list_len):\n",
    "    val = list[i]\n",
    "    if val in list_two:\n",
    "        continue\n",
    "    else:\n",
    "        list_two.append(val)\n",
    "list_two_len = len(list_two)\n",
    "for x in range(list_two_len):\n",
    "    val2 = 0\n",
    "    for y in range(list_len):\n",
    "        if list_two[x]==list[y]:\n",
    "            val2+=1\n",
    "        else:\n",
    "            continue\n",
    "    print(f\"{list_two[x]} - {val2} times\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter List ammount: 4\n",
      "Enter values: 1 2 3\n",
      "Enter values: 4 5 6\n",
      "Enter values: 7 8 9\n",
      "Enter values: 10 11 12\n",
      "33\n",
      "['10', '11', '12']\n"
     ]
    }
   ],
   "source": [
    "\"\"\"2. Write a python program that calculates the sum of N given lists and prints the highest sum and its respective list.\n",
    "Input starts with N and followed by N lists.\"\"\"\n",
    "\n",
    "list_size = int(input(\"Enter List ammount: \"))\n",
    "highest_size = -9999999999999999999\n",
    "list = []\n",
    "\n",
    "for i in range(list_size):\n",
    "    str = input(\"Enter values: \")\n",
    "    lst = str.split(\" \")\n",
    "    list_len = len(lst)\n",
    "    sum = 0\n",
    "    for j in range(list_len):\n",
    "        sum+=int(lst[j])\n",
    "\n",
    "    if sum>highest_size:\n",
    "        highest_size=sum\n",
    "        list=lst\n",
    "print(highest_size)\n",
    "print(list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 8, 10, 9, 12, 15, 18, 24, 30]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"3. Write a python program that prints a list which contains cross multiplication between two given lists.\"\"\"\n",
    "\n",
    "first_list=[2,3,6]\n",
    "\n",
    "second_list = [3,4,5]\n",
    "\n",
    "final_list=[]\n",
    "for num in first_list:\n",
    "    for val in second_list:\n",
    "        cal = num*val\n",
    "        final_list.append(cal)\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter: 1 4 2 3\n",
      "UB Jumper\n",
      "Enter: 2 1 4 6 10\n",
      "UB Jumper\n",
      "Enter: 1 4 2 -1 6\n",
      "Not UB Jumper\n",
      "Enter: STOP\n"
     ]
    }
   ],
   "source": [
    "\"\"\"4. Let there are N numbers in a list and that list is said to be a UB Jumper if the absolute values of the difference between the successive elements take on all the values 1 through N − 1. For example, 2 1 4 6 10 is a UB Jumper because the absolute differences between them are 1 3 2 4 which is all numbers from 1 to (5 - 1) or 4. Write a python program that takes a number sequence as input and prints whether it is a UB Jumper or Not UB Jumper. Input will stop after getting “STOP” as input. \n",
    "(Number order or absolute difference order doesn’t follow any sequence.)\"\"\"\n",
    "\n",
    "def ubjumper(inp):\n",
    "    ub_jumper = False\n",
    "    list = inp.split(\" \")\n",
    "    new_list =[]\n",
    "    list_len = len(list)\n",
    "    for x in range(list_len):\n",
    "        num = int(list[x+1])- int(list[x])\n",
    "        if num<0:\n",
    "            num=-1*num\n",
    "            new_list.append(num)\n",
    "        else:\n",
    "            new_list.append(num)\n",
    "        if x == (list_len - 2) :\n",
    "            break\n",
    "    new_list.sort()\n",
    "    new_len =len(new_list)\n",
    "    if new_len== (list_len-1):\n",
    "        count =0\n",
    "        for i in range(new_len):\n",
    "            count+=1\n",
    "\n",
    "            if count == new_list[i]:\n",
    "                ub_jumper=True\n",
    "            else:\n",
    "                ub_jumper=False\n",
    "                break\n",
    "    if ub_jumper==True:\n",
    "        print(\"UB Jumper\")\n",
    "\n",
    "    else:\n",
    "        print(\"Not UB Jumper\")\n",
    "for z in range(999999999999):\n",
    "    inp = input(\"Enter: \")\n",
    "    if inp == \"STOP\" or inp==\"stop\":\n",
    "        break\n",
    "    else:\n",
    "        ubjumper(inp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Bracu1234\n",
      "racuB1324\n"
     ]
    }
   ],
   "source": [
    "\"\"\"5. You are given a string that contains alphanumeric characters only. Your task is to sort the string in the following manner:\n",
    "a. All sorted lowercase letters are ahead of uppercase letters.\n",
    "b. All sorted uppercase letters are ahead of digits.\n",
    "c. All sorted odd digits are ahead of sorted even digits.\"\"\"\n",
    "\n",
    "user = input(\"Enter String: \")\n",
    "str_len = len(user)\n",
    "new_str= \"\"\n",
    "upeer = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "upper_list = []\n",
    "\n",
    "lower= \"abcdefghijklmnopqrstuvwxyz\"\n",
    "lower_list =[]\n",
    "\n",
    "odd =\"13579\"\n",
    "odd_list=[]\n",
    "\n",
    "even = \"02468\"\n",
    "even_list=[]\n",
    "\n",
    "for i in range(str_len):\n",
    "    chr = user[i]\n",
    "    if chr in upeer:\n",
    "        upper_list.append(chr)\n",
    "    if chr in lower:\n",
    "        lower_list.append(chr)\n",
    "    if chr in odd:\n",
    "        odd_list.append(chr)\n",
    "    if chr in even:\n",
    "        even_list.append(chr)\n",
    "\n",
    "up_len = len(upper_list)\n",
    "lw_len = len(lower_list)\n",
    "odd_len = len(odd_list)\n",
    "even_len = len(even_list)\n",
    "\n",
    "for x in range(lw_len):\n",
    "    new_str+=lower_list[x]\n",
    "for x in range(up_len):\n",
    "    new_str+=upper_list[x]\n",
    "for x in range(odd_len):\n",
    "    new_str+=odd_list[x]\n",
    "for x in range(even_len):\n",
    "    new_str+=even_list[x]\n",
    "print(new_str)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Candidate and competition num: 6 5\n",
      "Enter the list of candidate according participation: 0 0 0 0 0 0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#LIST_6\n",
    "\n",
    "user = input(\"Enter Candidate and competition num: \")\n",
    "candidate_num ,comp_num = user.split(\" \")\n",
    "\n",
    "user2 = input(\"Enter the list of candidate according participation: \")\n",
    "candidate = user2.split(\" \")\n",
    "candidate.sort()\n",
    "\n",
    "num_candidate = int(candidate_num)\n",
    "num_comp = int(comp_num)\n",
    "list=[]\n",
    "for x in range(num_candidate):\n",
    "    candidates =int(candidate[x])\n",
    "    count = 5-candidates\n",
    "    if count>= num_comp:\n",
    "        list.append(candidates)\n",
    "    else:\n",
    "        break\n",
    "list_len = len(list)\n",
    "for num in range(1,100000000000000):\n",
    "    if 3*num > list_len:\n",
    "        print(num-1)\n",
    "        break\n",
    "    if 3*num <= list_len <= 3*(2*num):\n",
    "        print(num)\n",
    "        break\n",
    "    if 3*(2*num) > list_len:\n",
    "        continue\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Dictionary: a: 100, b: 100, c: 200, d: 300\n",
      "Enter Dictionary: a: 300, b: 200, d: 400, e: 200\n",
      "{'a': 400, 'b': 300, 'c': 200, 'd': 700, 'e': 200}\n",
      "Values:  (200, 300, 400, 700)\n"
     ]
    }
   ],
   "source": [
    "#Dictionary & Tuple\n",
    "\"\"\"1. Write a Python program to combine two dictionaries into one by adding values for common keys. Input contains two comma separated dictionaries.\n",
    "Print the new dictionary and create a tuple which contains unique values in sorted order.\"\"\"\n",
    "\n",
    "def dictionary(string):\n",
    "    first_list = string.split(\", \")\n",
    "    len_list=len(first_list)\n",
    "    dict_f = {}\n",
    "    for x in range(len_list):\n",
    "        list2= first_list[x].split(\": \")\n",
    "        dict_f[list2[0]]=int(list2[1])\n",
    "    return dict_f\n",
    "\n",
    "for i in range(2):\n",
    "    str1 = input(\"Enter Dictionary: \")\n",
    "    if i ==0:\n",
    "        dict ={}\n",
    "        dict_1 = dictionary(str1)\n",
    "    else:\n",
    "        dict_2={}\n",
    "        dict_2=dictionary(str1)\n",
    "new_dict= {}\n",
    "for k,v in dict_1.items():\n",
    "    new_dict.update({k:v})\n",
    "for items in dict_2:\n",
    "    if items  in new_dict.keys():\n",
    "        new_dict[items]=new_dict[items]+dict_2[items]\n",
    "    else:\n",
    "        new_dict[items]=dict_2[items]\n",
    "\n",
    "tuples = []\n",
    "for item in new_dict.values():\n",
    "    if item in tuples:\n",
    "        continue\n",
    "    else:\n",
    "        tuples.append(item)\n",
    "tuples.sort()\n",
    "tuples=tuple(tuples)\n",
    "print(new_dict)\n",
    "print(\"Values: \",tuples)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Numbers: 10\n",
      "Enter Numbers: 20\n",
      "Enter Numbers: 20\n",
      "Enter Numbers: 30\n",
      "Enter Numbers: 10\n",
      "Enter Numbers: 50\n",
      "Enter Numbers: 90\n",
      "Enter Numbers: STOP\n",
      "{'10': 2, '20': 2, '30': 1, '50': 1, '90': 1}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"2. Write a python program which prints the frequency of the numbers that were given as input by the user. \n",
    "Stop taking input when you find the string “STOP”.\n",
    "Do not print the frequency of numbers that were not given as input. Use a dictionary to solve the problem\"\"\"\n",
    "\n",
    "\n",
    "list=[]\n",
    "new_dict={}\n",
    "for num in range(10000000000000000):\n",
    "    n = input(\"Enter Numbers: \")\n",
    "    if n == \"STOP\" or n==\"stop\":\n",
    "        break\n",
    "    else:\n",
    "        list.append(n)\n",
    "\n",
    "for char in list:\n",
    "    if char not in new_dict:\n",
    "        new_dict[char]=1\n",
    "    else:\n",
    "        new_dict[char]+=1\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many values: 3\n",
      "Enter KEy: key1\n",
      "Enter Value: value1\n",
      "Enter KEy: key2\n",
      "Enter Value: value2\n",
      "Enter KEy: key3\n",
      "Enter Value: value1\n",
      "{'value1': ['key1', 'key3'], 'value2': ['key2']}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"3. Write python code to invert a dictionary. It should print a dictionary where the keys are values\n",
    "from the input dictionary and the values are lists of keys from the input dictionary having the same value.\n",
    "Make sure the program handles multiple same values.\"\"\"\n",
    "\n",
    "dict={}\n",
    "new_dict={}\n",
    "num= int(input(\"How many values: \"))\n",
    "for x in range(num):\n",
    "    k = input(\"Enter KEy: \")\n",
    "    v= input(\"Enter Value: \")\n",
    "    dict[k]=v\n",
    "\n",
    "for key,value in dict.items():\n",
    "    if value not in new_dict:\n",
    "        new_dict[value] = []\n",
    "        new_dict[value].append(key)\n",
    "    else:\n",
    "        new_dict[value].append(key)\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter string1: evil\n",
      "Enter string2: live\n",
      "Those strings are anagram\n"
     ]
    }
   ],
   "source": [
    "\"\"\"4. Two words are anagrams if they contain all of the same letters, but in a different order. For example, “evil” and “live” are anagrams because each contains one “e”, one “i”, one “l”, and one “v”.\n",
    "Write a program that reads two strings from the user and determines whether or not they are anagrams. Use a dictionary to solve the problem.\"\"\"\n",
    "\n",
    "str1 = input(\"Enter string1: \")\n",
    "str2 = input(\"Enter string2: \" )\n",
    "len_str1= len(str1)\n",
    "len_str2 = len(str2)\n",
    "\n",
    "an =  True\n",
    "if len_str1==len_str2:\n",
    "    dict1 = {}\n",
    "    dict2 = {}\n",
    "\n",
    "    dict1[1]=str1\n",
    "    dict2[1]=str2\n",
    "    for i in dict1:\n",
    "        string1 = dict1[i]\n",
    "        string2 = dict2[1]\n",
    "        if an == False:\n",
    "            break\n",
    "        for x in range(len(string1)):\n",
    "            if an == False:\n",
    "                break\n",
    "            for j in range(len(string2)):\n",
    "                if string1[x] == string2[j] :\n",
    "                    an = True\n",
    "                    break\n",
    "                else:\n",
    "                    an = False\n",
    "else:\n",
    "    an = False\n",
    "if an == True:\n",
    "    print(\"Those strings are anagram\")\n",
    "else:\n",
    "    print(\"Those strings are not anagram\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Input: Hello, World!\n",
      "4433555555666110966677755531111"
     ]
    }
   ],
   "source": [
    "\"\"\"5. On some basic cell phones, text messages can be sent using the numeric keypad. \n",
    "Because each key has multiple letters associated with it, multiple key presses are needed for most letters.\n",
    "Pressing the number once generates the first character listed for that key. Pressing the number 2, 3, 4 or 5 times generates the second, third, fourth or fifth character.\"\"\"\n",
    "\n",
    "phone_dic ={\".\":1,\",\":11,\"?\":111,\"!\":1111,\":\":11111,\"A\":2,\"a\":2,\"B\":22,\"b\":22,\"C\":222,\"c\":222,\"D\":3,\"d\":3,\"E\":33,\n",
    " \"e\":33,\"F\":333,\"f\":333,\"G\":4,\"g\":4,\"H\":44,\"h\":44,\"I\":444,\"i\":444,\"J\":5,\"j\":5,\"K\":55,\"k\":55,\"L\":555,\"l\":555,\n",
    " \"M\":6,\"m\":6,\"N\":66,\"n\":66,\"O\":666,\"o\":666,\"P\":7,\"p\":7,\"Q\":77,\"q\":77,\"R\":777,\"r\":777,\"S\":7777,\"s\":7777,\"T\":8,\"t\":8,\n",
    " \"U\":88,\"u\":88,\"V\":888,\"v\":888,\"W\":9,\"w\":9,\"X\":99,\"x\":99,\"y\":999,\"Y\":999,\"Z\":9999,\"z\":9999,\" \":0}\n",
    "\n",
    "user = input(\"Enter Input: \")\n",
    "\n",
    "for val in user:\n",
    "    c = phone_dic.get(val)\n",
    "    print(c,end='')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}