To-Do (Tuple & Dictionary).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PD425BrvtDRy"
   },
   "source": [
    "## Write the code in Python to do the following tasks:\n",
    "\n",
    "**<font color='red'>[MUST MAINTAIN VARIABLE NAMING CONVENTIONS FOR ALL THE TASKS]</font>**\n",
    "\n",
    "## Part 1: Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FNOorLYXtDRz"
   },
   "source": [
    "### Task 1\n",
    "\n",
    "Assume, you have been given a tuple.\n",
    "\n",
    "a_tuple = (\"The Institute\",\\\n",
    "        (\"Best Mystery & Thriller\", \"The Silent Patient\", 68821),\\\n",
    "        75717,\\\n",
    "        [1, 2, 3, 400, 5, 6, 7],\\\n",
    "        (\"Best Fiction\", \"The Testaments\", 98291)\\\n",
    ")\n",
    "\n",
    "Write **one line** of Python code to access and print the value 400.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "Output: 400\n",
    "\n",
    "===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "NDKB1cIMtDR0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400\n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "a_tuple = (\"The Institute\",\\\n",
    "        (\"Best Mystery & Thriller\", \"The Silent Patient\", 68821),\\\n",
    "        75717,\\\n",
    "        [1, 2, 3, 400, 5, 6, 7],\\\n",
    "        (\"Best Fiction\", \"The Testaments\", 98291)\\\n",
    ")\n",
    "print(a_tuple[-2][3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BXlIw1svtDR-"
   },
   "source": [
    "### Task 2\n",
    "\n",
    "Assume, you have been given a tuple. Write a Python program that creates a **new tuple** excluding the first and last two elements of the given tuple and prints the new tuple. \n",
    "\n",
    "**Hint:** You may use tuple slicing.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 1:**\\\n",
    "(10, 20, 24, 25, 26, 35, 70)\n",
    "\n",
    "\n",
    "**Sample Output 1:**\\\n",
    "(24, 25, 26)\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 2:**\\\n",
    "(-10, 20, 30, 40)\n",
    "\n",
    "\n",
    "**Sample Output 2:**\\\n",
    "()\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 3:**\\\n",
    "(-10, 20, 25, 30, 40)\n",
    "\n",
    "\n",
    "**Sample Output 3:**\\\n",
    "(25,)\n",
    "\n",
    "===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "FTJ-5AmNtDR_"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('30',)\n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "tuple_1 =input('Please enter tuple : ')\n",
    "tuple_2= tuple_1.split(',')\n",
    "tuple_3 = tuple_2[2:-2]\n",
    "tuple_3= tuple(tuple_3)\n",
    "\n",
    "\n",
    "\n",
    "print(tuple_3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z3GS2TE6tDSG"
   },
   "source": [
    "### Task 3\n",
    "\n",
    "Assume, you have been given a tuple. \n",
    "\n",
    "\n",
    "book_info = (\\\n",
    "    (\"Best Mystery & Thriller\",\"The Silent Patient\",68,821),\\\n",
    "    (\"Best Horror\",\"The Institute\",75,717),\\\n",
    "    (\"Best History & Biography\",\"The five\",31,783 ),\\\n",
    "    (\"Best Fiction\",\"The Testaments\",98,291)\\\n",
    ")\n",
    "\n",
    "Write a Python program that prints the size of the tuple and all its elements as shown below.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Output:**\\\n",
    "Size of the tuple is: 4\\\n",
    "('Best Mystery & Thriller', 'The Silent Patient', 68, 821)\\\n",
    "('Best Horror', 'The Institute', 75, 717)\\\n",
    "('Best History & Biography', 'The five', 31, 783)\\\n",
    "('Best Fiction', 'The Testaments', 98, 291)\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "RPFYcAjntDSG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of tuple is :  4\n",
      "('Best Mystery & Thriller', 'The Silent Patient', 68, 821)\n",
      "('Best Horror', 'The Institute', 75, 717)\n",
      "('Best History & Biography', 'The five', 31, 783)\n",
      "('Best Fiction', 'The Testaments', 98, 291)\n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "book_info = (\\\n",
    "    (\"Best Mystery & Thriller\",\"The Silent Patient\",68,821),\\\n",
    "    (\"Best Horror\",\"The Institute\",75,717),\\\n",
    "    (\"Best History & Biography\",\"The five\",31,783 ),\\\n",
    "    (\"Best Fiction\",\"The Testaments\",98,291)\\\n",
    ")\n",
    "\n",
    "print('Size of tuple is : ', len(book_info))\n",
    "\n",
    "for j in book_info:\n",
    "\n",
    "    print(j)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "glKgAPlGtDSK"
   },
   "source": [
    "### Task 4\n",
    "\n",
    "Assume, you have been given a tuple with details about books that won the Good Reads Choice Awards. \n",
    "\n",
    "book_info = (\\\n",
    "    (\"Best Mystery & Thriller\",\"The Silent Patient\",68821),\\\n",
    "    (\"Best Horror\",\"The Institute\",75717),\\\n",
    "    (\"Best History & Biography\",\"The five\",31783 ),\\\n",
    "    (\"Best Fiction\",\"The Testaments\",98291)\\\n",
    ")\n",
    "\n",
    "Write a Python program that prints the award category, the book name, and its total votes earned as shown below. \n",
    "\n",
    "**<font color='red'>[Must use Tuple unpacking for printing and need to handle the quotation marks as a part of the output]</font>**\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Output:**\\\n",
    "The Silent Patient won the 'Best Mystery & Thriller' category with 68821 votes\\\n",
    "The Institute won the 'Best Horror' category with 75717 votes\\\n",
    "The five won the 'Best History & Biography' category with 31783 votes\\\n",
    "The Testaments won the 'Best Fiction' category with 98291 votes\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "LgTKpSGatDSM"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Silent Patient won the 'Best Mystery & Thriller' category with 68821 votes\n",
      "The Institute won the 'Best Horror' category with 75717 votes\n",
      "The five won the 'Best History & Biography' category with 31783 votes\n",
      "The Testaments won the 'Best Fiction' category with 98291 votes\n"
     ]
    }
   ],
   "source": [
    "book_info = (\n",
    "(\"Best Mystery & Thriller\",\"The Silent Patient\",68821),\n",
    "(\"Best Horror\",\"The Institute\",75717),\n",
    "(\"Best History & Biography\",\"The five\",31783 ),\n",
    "(\"Best Fiction\",\"The Testaments\",98291)\n",
    ")\n",
    "\n",
    "for j in book_info:\n",
    "    award, name, votes = j\n",
    "    print(F\"{name} won the '{award}' category with {votes} votes\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bRe9K_j55zpb"
   },
   "source": [
    "### Task 5\n",
    "Write a python program that takes an input from the user and finds the number of times that the input is present in a given tuple.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "<b>Example 1: </b><br/>\n",
    "\n",
    "Given tuple: (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2) <br/>\n",
    "\n",
    "<b>Sample Input 1:</b> \n",
    "\n",
    "8<br/>\n",
    "\n",
    "<b>Sample Output 1: </b> <br/>\n",
    "\n",
    "8 appears 4 times in the tuple<br/>\n",
    "\n",
    "===================================================================\n",
    "\n",
    "<b> Example 2 </b><br/>\n",
    "\n",
    "Given tuple: (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)<br/>\n",
    "\n",
    "<b>Sample Input 2:</b>\n",
    "\n",
    "1<br/>\n",
    "\n",
    "<b>Sample Output 2:</b><br/>\n",
    "\n",
    "1 appears 0 times in the tuple\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "mC-B1fpStDST"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 appears 4 times in the tuple\n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "\n",
    "t = (10,8,5,2,10,15,10,8,5,8,8,2)\n",
    "k = int(input( ))\n",
    "c= 0\n",
    "for e in t:\n",
    "    if e == k:\n",
    "        c+=1\n",
    "print(f\"{k} appears {c} times in the tuple\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QWNi_JWr6AfC"
   },
   "source": [
    "### Task 6\n",
    "Write a Python program to reverse a given tuple. \n",
    "\n",
    " \n",
    "  <font color='red'>[You are not allowed to use tuple slicing]</font>\n",
    "  \n",
    "===================================================================\n",
    "\n",
    "<b>Note: </b>  Unlike lists, tuples are immutable. So, in order to reverse a tuple, we may need to convert it into a list first, then modify the list, and finally convert it back to a tuple. \n",
    "\n",
    "===================================================================\n",
    "\n",
    "<b>Example 1: </b><br/>\n",
    "\n",
    "Given tuple: ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h') <br/>\n",
    "\n",
    "<b> Output: </b> <br/>\n",
    "\n",
    "('h', 'g', 'f', 'e', 'd', 'c', 'b', 'a')<br/>\n",
    "\n",
    "\n",
    "===================================================================\n",
    "\n",
    "<b> Example 2: </b><br/>\n",
    "\n",
    "Given tuple: (10, 20, 30, 40, 50, 60)<br/>\n",
    "\n",
    "<b> Output: </b><br/>\n",
    "\n",
    "(60, 50, 40, 30, 20, 10)\n",
    "\n",
    "===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CJrUcYAN6Bkx"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30, 40, 50, 60)\n"
     ]
    }
   ],
   "source": [
    "given_tuple = (60,50,40,30,20,10)\n",
    "\n",
    "list_1 = list(given_tuple)\n",
    "list_1.reverse()\n",
    "tuple_2 = tuple(list_1)\n",
    "\n",
    "print(tuple_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "km0QurTJtDSX"
   },
   "source": [
    "## Part 2: Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kvV-HnCntDSc"
   },
   "source": [
    "### Task 7\n",
    "Suppose you are given two dictionaries.\\\n",
    "Now create a new dictionary \"marks\", merging the two dictionaries, **so that the original two dictionaries remain unchanged.**\n",
    "\n",
    "\n",
    "**Note:** You can use dictionary functions.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Given:**\n",
    "\n",
    "{'Harry':15, 'Draco':8, 'Nevil':19}\n",
    "\n",
    "{'Ginie':18, 'Luna': 14}\n",
    "\n",
    "**Output:**\n",
    "\n",
    "{'Harry': 15, 'Draco': 8, 'Nevil': 19, 'Ginie': 18, 'Luna': 14}\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Given:**\n",
    "\n",
    "{'A':90, 'B': 0}\n",
    "\n",
    "{'C':50}\n",
    "\n",
    "**Output:**\n",
    "\n",
    "{'A': 90, 'B': 0, 'C': 50}\n",
    "\n",
    "===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BGSyClBPtDSd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Harry': 15, 'Draco': 8, 'Nevil': 19, 'Ginie': 18, 'Luna': 14}\n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "dict_1 = {'Harry':15, 'Draco':8, 'Nevil':19}\n",
    "\n",
    "dict_2 = {'Ginie':18, 'Luna': 14}\n",
    "\n",
    "marks = dict()\n",
    "\n",
    "marks.update(dict_1)\n",
    "marks.update(dict_2)\n",
    "\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QRzP4HYStDSi"
   },
   "source": [
    "### Task 8\n",
    "Write a Python program that takes a dictionary as an input from the user and then prints the average of all the values in the dictionary.\n",
    "\n",
    " <font color='red'>[You are not allowed to use len() and sum()]</font>\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Hint (1): For taking dictionary input** \n",
    "\n",
    "Approach(1): For taking dictionary as an input from the user, you may take the whole dictionary as a string using the input() function. Then you can use the split(), strip() functions and conditions to get the keys and values from the string. Finally, you can make the dictionary using the obtained data.\n",
    "\n",
    "Approach(2): If the first approach seems too difficult you can create an empty dictionary and then just run a simple loop. For each iteration ask the user for a key and a value using the input() function and keep updating the dictionary with the key and value.\n",
    "\n",
    "\n",
    "**Hint (2):** After you have a dictionary, you can use dictionary functions to get all the values from it, run loop to calculate the sum and the total number of values in the dictionary in order to find out the average.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "{'Jon': 100, 'Dan':200, 'Rob':300}\n",
    "\n",
    "**Sample Output 1:**\n",
    "\n",
    "Average is 200.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "\n",
    "**Sample Input 2:**\n",
    "\n",
    "{'Jon': 100, 'Dan':200, 'Rob':30, 'Ned':110}\n",
    "\n",
    "**Sample Output 2:**\n",
    "\n",
    "Average is 110.\n",
    "\n",
    "===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VMRLnA53tDSk"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Jon Snow': 100, 'Dan': 200, 'Rob': 300}\n",
      "Average is 200.0: \n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "user_input= input()\n",
    "user_input = user_input.strip(\"{}\")\n",
    "\n",
    "dictionary = dict()\n",
    "kv_list = user_input.split(\",\")\n",
    "for kv in kv_list:\n",
    "    key, value = kv.split(\":\")\n",
    "\n",
    "    key = key.strip()\n",
    "    key = key.strip(\"'\")\n",
    "\n",
    "    value = value.strip()\n",
    "    dictionary[key] = int(value)\n",
    "\n",
    "print(dictionary)\n",
    "\n",
    "length = 0\n",
    "accumulator= 0\n",
    "for value in dictionary.values():\n",
    "    accumulator += value\n",
    "    length += 1\n",
    "    pass\n",
    "\n",
    "print(F\"Average is {accumulator/length}: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "le7fZ8XC9j_x"
   },
   "source": [
    "### Task 9\n",
    "Suppose there is a dictionary named exam_marks as given below.\n",
    "\n",
    "exam_marks = {'Cierra Vega': 175, 'Alden Cantrell': 200, 'Kierra Gentry': 165, 'Pierre Cox': 190}\n",
    "\n",
    "Write a Python program that takes an input from the user and creates a new dictionary with only those elements from 'exam_marks' whose keys have values higher than the user input (inclusive).\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "170\n",
    "\n",
    "**Sample Output 1:**\n",
    "\n",
    "{'Cierra Vega': 175, 'Alden Cantrell': 200, 'Pierre Cox': 190}\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 2:**\n",
    "\n",
    "190\n",
    "\n",
    "**Sample Output 2:**\n",
    "\n",
    "{'Alden Cantrell': 200, 'Pierre Cox': 190}\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qJWoUsLN9lBY"
   },
   "outputs": [],
   "source": [
    "#to do\n",
    "exam_marks = {'Cierra Vega': 175, 'Alden Cantrell': 200, 'Kierra Gentry': 165, 'Pierre Cox': 190}\n",
    "\n",
    "user=int(input(\"Enter a number: \"))\n",
    "\n",
    "newdict={}\n",
    "temp=0\n",
    "\n",
    "for key,value in exam_marks.items():\n",
    "    if value>=user:\n",
    "        \n",
    "        newdict[key]=value\n",
    "        \n",
    "print(newdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IsqFQpqKtDSs"
   },
   "source": [
    "### Task 10\n",
    "Write a Python program that finds the largest value with its key from a given dictionary.  \n",
    "\n",
    "<font color='red'>\n",
    "[You are not allowed to use the max() function for this task]</font> \n",
    "\n",
    "**Note:** You do not need to take the dictionaries as an input from the user but your code should work for any given dictionary. Also, you need to handle the quotation marks as a part of the output.\n",
    "\n",
    "**Hint:** Think of membership operators (in and not in). You can use dictionary functions to get the values.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "Sample 1:\n",
    "\n",
    "**Given:**\n",
    "\n",
    "{'sci fi': 12, 'mystery': 15, 'horror': 8, 'mythology': 10, 'young_adult': 4, 'adventure':14}\n",
    "\n",
    "**Output:**\n",
    "\n",
    "The highest selling book genre is 'mystery' and the number of books sold are 15.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "Sample 2:\n",
    "\n",
    "**Given:**\n",
    "\n",
    "{'sci fi': 5, 'mystery': 3, 'horror': 14,\n",
    "             'young_adult': 2, 'adventure':9}\n",
    "\n",
    "**Output:**\n",
    "\n",
    "The highest selling book genre is  'horror'  and the number of books sold are 14.\n",
    "\n",
    "===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v9Kosgs4tDSt"
   },
   "outputs": [],
   "source": [
    "#to do\n",
    "\n",
    "dict1={'sci fi': 12, 'mystery': 15, 'horror': 8, 'mythology': 10, 'young_adult': 4, 'adventure':14}\n",
    "\n",
    "s=-99999999\n",
    "key=0\n",
    "\n",
    "for i in dict1:\n",
    "    if dict1[i]>s:\n",
    "        s=dict1[i]\n",
    "        key=i\n",
    "    \n",
    "print(f\"The highest selling book genre is '{key}' and the number of books sold are {s}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hAqjgwGNtDS2"
   },
   "source": [
    "### Task 11\n",
    "Write a Python program that takes a String as an input from the user and counts the frequency of each character using a dictionary. For solving this problem, you may use each character as a key and its frequency as values. <font color='red'>[You are not allowed to use the count() function]</font> \n",
    "\n",
    "**Hint:** You can create a new dictionary to store the frequencies. You may ignore case for simplicity (i.e. may consider P and p to be the same).\n",
    "\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input:**\\\n",
    "\"Python programming is fun\"\n",
    "\n",
    "**Sample Output:**\\\n",
    "{'p': 2, 'y': 1, 't': 1, 'h': 1, 'o': 2, 'n': 3, 'r': 2, 'g': 2, 'a': 1, 'm': 2, 'i': 2, 's': 1, 'f': 1, 'u': 1}\n",
    "\n",
    "===================================================================\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-m2yPIT7tDS3"
   },
   "outputs": [],
   "source": [
    "#to do\n",
    "\n",
    "s=input().lower()\n",
    "\n",
    "di={}\n",
    "\n",
    "for i in s:\n",
    "    if i in di:\n",
    "        di[i]=di[i]+1\n",
    "    else:\n",
    "        di[i]=1\n",
    "        \n",
    "print(di)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QWf1zsBctDS6"
   },
   "source": [
    "### Task 12\n",
    "Suppose you are given the following dictionary where the values are lists. \n",
    "\n",
    "dict = {'A': [1, 2, 3], 'b': ['1', '2'], \"c\": [4, 5, 6, 7]}\n",
    "\n",
    "Write a Python program that counts the total number of items in a dictionary’s values and prints it. <font color='red'>\n",
    "\n",
    "[without using sum(), len(), count() functions]</font> \n",
    "\n",
    "**Note:**  Make changes to the above dictionary and see if your code works properly for other dictionaries as well.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Output:**\n",
    "\n",
    "9\n",
    "\n",
    "===================================================================\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "atnD3A1utDS6"
   },
   "outputs": [],
   "source": [
    "#to do\n",
    "dict = {'A': [1, 2, 3], 'b': ['1', '2'], \"c\": [4, 5, 6, 7]}\n",
    "count=0\n",
    "\n",
    "for value in dict.values():\n",
    "    \n",
    "    for i in value:\n",
    "        count+=1\n",
    "        \n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-imuPb3EtDTD"
   },
   "source": [
    "### Task 13\n",
    "\n",
    "Suppose you have been given the following list of tuples. \n",
    "\n",
    "list = [(\"a\", 1), (\"b\", 2), (\"a\", 3), (\"b\", 1), (\"a\", 2), (\"c\", 1)]\n",
    "\n",
    "Write a Python program that converts this list of tuples into a dictionary and then prints the dictionary. \n",
    "\n",
    "<font color='red'>[You are not allowed to use set]</font> \n",
    "\n",
    "\n",
    "**Hint:** Think of membership operators (in and not in).\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Output:**\n",
    "\n",
    "{'a': [1, 3, 2], 'b': [2, 1], 'c': [1]}\n",
    "\n",
    " ===================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bBBcHpgYtDTE"
   },
   "outputs": [],
   "source": [
    "#todo\n",
    "list = [(\"a\", 1), (\"b\", 2), (\"a\", 3), (\"b\", 1), (\"a\", 2), (\"c\", 1)]\n",
    "\n",
    "dict={}\n",
    "for i in list:\n",
    "    if i[0] not in dict:\n",
    "        dict[i[0]]=[i[1]]\n",
    "    else:\n",
    "        dict[i[0]].append(i[1])\n",
    "print(dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UrxbFOWk5ASO"
   },
   "source": [
    "## Optional Tasks (14-19) [Ungraded]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vtQRbX994-Se"
   },
   "source": [
    "### Task 14\n",
    "\n",
    "Given a list of tuples, your task is to multiply the elements of the tuple and return a list of multiplied elements as shown below.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Example 1:**\n",
    "\n",
    "Given: \n",
    "\n",
    "[(2, 3), (4, 5), (6, 7), (2, 8)]\n",
    "\n",
    "**Output:**\n",
    "\n",
    "[6, 20, 42, 16]\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Example 2:**\n",
    "\n",
    "Given:\n",
    "\n",
    " [(11, 22), (33, 55), (55, 77), (11, 44)]\n",
    "\n",
    "**Output:**\n",
    "\n",
    "[242, 1815, 4235, 484]\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "xy-E_k6y5maj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2]\n"
     ]
    }
   ],
   "source": [
    "#to do\n",
    "tuple_1 = [(2,3),(4,5),(6,7),(2,8)]\n",
    "\n",
    "n= tuple_1[0]\n",
    "\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jZQHbegc-QBA"
   },
   "source": [
    "### Task 15\n",
    "\n",
    "Assume, you have been given a tuple as below.\n",
    "\n",
    "a_tuple = ( [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12])\n",
    "\n",
    "Write a Python program that asks the user for an input (can be any data type) and **replaces the last element of each of the inner lists with the user given value.**\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "abc\n",
    "\n",
    "**Sample Output 1:** \n",
    "\n",
    "([1, 2, 'abc'], [4, 5, 'abc'], [7, 8, 'abc'], [10, 11, 'abc'])\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "1000\n",
    "\n",
    "**Sample Output 1:** \n",
    "\n",
    "([1, 2, '1000'], [4, 5, '1000'], [7, 8, '1000'], [10, 11, '1000'])\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SjdnEjCz5op1"
   },
   "outputs": [],
   "source": [
    "#to do\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dVZrZ8Od6WwM"
   },
   "source": [
    "### Task 16\n",
    "\n",
    "Suppose there is a dictionary named my_dictionary.\n",
    "\n",
    "my_dictionary = {'c1':'Red', 'c2':'Green', 'c3':None, 'd4':'Blue', 'a5':None}.\n",
    "\n",
    "Now write a Python program to remove empty items from the dictionary. [Empty items means keys without any values (None)].\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Output:**\n",
    "\n",
    "{'c1':'Red', 'c2':'Green', 'd4':'Blue'}\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cK9Nh7-F6YUE"
   },
   "outputs": [],
   "source": [
    "#to do\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_W2bOMJn62xF"
   },
   "source": [
    "### Task 17\n",
    "\n",
    "Suppose you are given a dictionary as shown below. Write a Python program that takes two inputs from the user representing the lower (inclusive) and upper (exclusive) of a range of values. Your task is to extract all the items from the dictionary whose values lie in the range given as input by the user.\n",
    "\n",
    "dictionary = {'a' : 6, 'b' : 7, 'c' : 9, 'd' : 8, 'e' : 11, 'f' : 12, 'g' : 13}\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 1:**\n",
    "\n",
    "9, 12\n",
    "\n",
    "**Sample Output 1:**\n",
    "\n",
    "{'c': 9, 'e': 11}\n",
    "\n",
    "**Explanation:**  Keys with values within the range of 9 and 11 are extracted.\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Sample Input 2:** \n",
    "\n",
    "14, 18\n",
    "\n",
    "**Sample Output 2 :**\n",
    "\n",
    "{}\n",
    "\n",
    "**Explanation:**  No values in range.\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MLh9VlLD633D"
   },
   "outputs": [],
   "source": [
    "#to do\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zC94TVcD7LqM"
   },
   "source": [
    "### Task 18\n",
    "\n",
    "Given a list of tuples, your task is to group the tuples based on the **second** element in the tuples as shown in the examples below. We can achieve this using **dictionary** by checking the second element in each tuple.\n",
    "\n",
    "[You do not need to take tuple as input and can assume that it is given as below]\n",
    "\n",
    "===================================================================\n",
    "\n",
    "**Example 1:**\n",
    "\n",
    "Given:\n",
    "\n",
    "[(20, 80), (31, 80), (1, 22), (88, 11), (27, 11)]\n",
    "\n",
    "**Output:**\n",
    "\n",
    "{80: [(20, 80), (31, 80)],\\\n",
    "         11: [(88, 11), (27, 11)],\\\n",
    "         22: [(1, 22)]}\n",
    "       \n",
    "===================================================================\n",
    "\n",
    "**Example 2:**\n",
    "\n",
    "Given:\n",
    "\n",
    "[(20, 'Sad'), (31, 'Sad'), (88, 'NotSad'), (27, 'NotSad')]\n",
    "\n",
    "**Output:**\n",
    "\n",
    "{'NotSad': [(88, 'NotSad'), (27, 'NotSad')],\\\n",
    "         'Sad: [(20, 'Sad'), (31, 'Sad')]}\n",
    "\n",
    "==================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zAunp7oZ7H-l"
   },
   "outputs": [],
   "source": [
    "#to do\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Al7LDo_m8TAX"
   },
   "source": [
    "### Task 19\n",
    "\n",
    "\n",
    "Write a python program that takes 2 inputs from the user. \n",
    "\n",
    "* Input1: A string containing a single sentence or multiple sentences. Multiple sentences are separated by full stops.\n",
    "* Input2: A list containing special characters.\n",
    "\n",
    "After taking the inputs, your task is to create a dictionary where the **keys** will be the corresponding special characters from the given list and the **values** will be the words in the given sentence. \n",
    "\n",
    "You need to find out which key belongs to which value. To do that, you should calculate the **index number** using the formula given below. **The calculated index is the corresponding key of the word.** Make sure no duplicate values are inserted.\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;\n",
    "\n",
    "**The formula:**\\\n",
    "**<font color='blue'>*Index value of special character list = (ASCII sum of the word) % (length of special character list)*</font>**\n",
    "\n",
    "\n",
    "=============================================================================\n",
    "\n",
    "\n",
    "**Sample Input 1**:\\\n",
    "'I love Programming. Python is love.'\\\n",
    "['@', '$', '&', '#']\n",
    " \n",
    "**Sample Output 1**:\\\n",
    "Words in the given String: ['I', 'love', 'Programming', 'Python', 'is', 'love']\\\n",
    "Answer: {'$': ['I'], '&': ['love', 'Python'], '#': ['Programming'], '@': ['is']}\n",
    " \n",
    "**Explanation 1:**\\\n",
    "From the string 'I love Programming. Python is love.' the {key: value} pair is calculated accordingly:\n",
    "\n",
    "\n",
    "| Word | ASCII sum|List length|Calculated index|Key|\n",
    "| --- | --- | --- | --- | --- | \n",
    "|I| 73|4| 73%4 = 1|'$'|\n",
    "|  |  |  |  |  |\n",
    "|love| 438|4| 438%4 = 2|'&'|\n",
    "|  |  |  |  |  |\n",
    "|Programming| 1155|4| 1155%4 = 3|'#'|\n",
    "|  |  |  |  |  |\n",
    "|Python| 642|4| 642%4 = 2|'&'|\n",
    "|  |  |  |  |  |\n",
    "|is| 220|4| 220%4 = 0|'@'|\n",
    "|  |  |  |  |  |\n",
    "|love| 438|4| 438%4 = 2|'&'|\n",
    "|  |  |  |  |  |\n",
    "\n",
    "\n",
    "The calculation is shown in the given table. Full stops after ‘Programming.’ and ‘love.’ are avoided. Also, the last word ‘love’ is a duplicate, and therefore, it was not inserted again as a value. \n",
    "\n",
    "\n",
    "\n",
    "=============================================================================\n",
    "\n",
    "\n",
    "**Sample Input 2**:\\\n",
    "'The secret of getting ahead is getting started.'\\\n",
    "['-', '=', '+', '*', '%']\n",
    " \n",
    "**Sample Output 2:**\\\n",
    "Words in the given String: ['The', 'secret', 'of', 'getting', 'ahead', 'is', 'getting', 'started']\\\n",
    "Answer: {'%': ['The', 'getting', 'ahead', 'started'], '=': ['secret'], '*': ['of'], '-': ['is']}\n",
    " \n",
    "**Explanation 2:**\\\n",
    "From the string 'The secret of getting ahead is getting started.' the {key: value} pair is calculated accordingly:\n",
    "\n",
    "\n",
    "| Word | ASCII sum|List length|Calculated index|Key|\n",
    "| --- | --- | --- | --- | --- | \n",
    "|The| 289|5| 289%5 = 4|'%'|\n",
    "|  |  |  |  |  |\n",
    "|secret| 646|5| 646%5 = 1|'='|\n",
    "|  |  |  |  |  |\n",
    "|of| 213|5| 213%5 = 3|'*'|\n",
    "|  |  |  |  |  |\n",
    "|getting| 754|5| 754%5 = 4|'%'|\n",
    "|  |  |  |  |  |\n",
    "|ahead| 499|5| 499%5 = 4|'%'|\n",
    "|  |  |  |  |  |\n",
    "|is| 220|5| 220%5 = 0|'-'|\n",
    "|  |  |  |  |  |\n",
    "|getting| 754|5| 754%5 = 4|'%'|\n",
    "|  |  |  |  |  |\n",
    "|started| 759|5| 759%5 = 4|'%'|\n",
    "|  |  |  |  |  |\n",
    "\n",
    "\n",
    "The calculation is shown in the given table. Full stop after ‘started.’ is avoided. Also, the word ‘getting’ is a duplicate and therefore it was not inserted again as a value. \n",
    "\n",
    "=============================================================================\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2w_nmFoN8ZBL"
   },
   "outputs": [],
   "source": [
    "#to do\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "CSE110 Lab Assignment 5 (Tuple and Dictionary).ipynb",
   "provenance": []
  },
  "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}