Assignment_6_(Dictionary_and_tuple).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPjY9f/j6I6pe9ea66F8bN/",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/azaynul10/Assignments-Of-Programming-Language-1/blob/main/Assignment_6_(Dictionary_and_tuple).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This Assignment is to help you develop your concept of Tuples and Dictionary in Python.\n",
        "[Please follow variable naming conventions including using meaningful variable names for all the tasks]\n",
        "When you run your code, please make sure your outputs exactly match the sample outputs for each of the sample inputs given. Check if your code works for other valid inputs not given in the samples.\n",
        "Write the code in Python to do the following tasks:\n",
        "\n",
        "\n",
        "**Part** 1: Tuples\n",
        "# Task 1\n",
        "\n",
        "Assume, you have been given a tuple.\n",
        "\n",
        "a_tuple = (\"The Institute\", (\"Best Mystery & Thriller\", \"The Silent Patient\", 68821), 75717,\n",
        "[1, 2, 3, 400, 5, 6, 7], (\"Best Fiction\", \"The Testaments\", 98291))\n",
        "Write one line of Python code to access and print the value 400.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Output: 400\n"
      ],
      "metadata": {
        "id": "5QM876B7826V"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eaCfGVZneEi5",
        "outputId": "49147297-9092-43ab-f5b9-a3c16ad9f127"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "400\n"
          ]
        }
      ],
      "source": [
        "#Task1\n",
        "a_tuple = (\"The Institute\", (\"Best Mystery & Thriller\", \"The Silent Patient\", 68821), 75717,\n",
        "[1, 2, 3, 400, 5, 6, 7], (\"Best Fiction\", \"The Testaments\", 98291))\n",
        "print(a_tuple[3][3])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 2\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",
        "\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "(10, 20, 24, 25, 26, 35, 70)\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "(24, 25, 26)\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "(-10, 20, 30, 40)\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "()\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample Input 3:\n",
        "\n",
        "(-10, 20, 25, 30, 40)\n",
        "\n",
        "Sample Output 3:\n",
        "\n",
        "(25,)\n"
      ],
      "metadata": {
        "id": "DVDJWfa79L6P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task2\n",
        "tuple1=(-10, 20, 25, 30, 40)\n",
        "print(tuple1[2:len(tuple1)-2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UobOITtWfuq9",
        "outputId": "46f3e6d4-7221-43fc-cae9-15bbcfad3b74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(25,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 3\n",
        "Assume, you have been given a tuple.\n",
        "\n",
        "\n",
        "---\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",
        "Write a Python program that prints the size of the tuple and all its elements as shown below.\n",
        "\n",
        "\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"
      ],
      "metadata": {
        "id": "XzWELAOIJuCA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task3\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",
        "tupl=book_info[:]\n",
        "print(\"Size of the tuple is:\",len(book_info))\n",
        "for i in tupl:\n",
        "  print(i)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nws4Tys3gc2M",
        "outputId": "7be05cf7-6098-4223-f54b-731f5e8a574e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 4\n",
        "Assume, you have been given a tuple with details about books that won the Good Reads Choice Awards.\n",
        "\n",
        "\n",
        "---\n",
        "\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",
        "Write a Python program that prints the award category, the book name, and its total votes earned as shown below.\n",
        "[Must use Tuple unpacking for printing and need to handle the quotation marks as a part of the output]\n",
        "\n",
        "\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"
      ],
      "metadata": {
        "id": "hE8aJ0KIKAZK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task4\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",
        "for i in book_info:\n",
        "  a,b,c=i\n",
        "  print(f\"{b} won the '{a}'category with {c} votes\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9lf0wT3Li87h",
        "outputId": "efb7b871-33aa-45bd-bc8f-82d94d862ea6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "\n",
        "Example 1:\n",
        "\n",
        "Given tuple: (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)\n",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "8\n",
        "\n",
        "Sample Output 1:\n",
        "\n",
        "8 appears 4 times in the tuple\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example 2\n",
        "\n",
        "Given tuple: (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)\n",
        "\n",
        "Sample Input 2:\n",
        "\n",
        "1\n",
        "\n",
        "Sample Output 2:\n",
        "\n",
        "1 appears 0 times in the tuple\n",
        "\n"
      ],
      "metadata": {
        "id": "qlbuFhqsOuUT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task5\n",
        "given_tuple= (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)\n",
        "num=int(input())\n",
        "times=0\n",
        "for i in range(len(given_tuple)):\n",
        "  if num==given_tuple[i]:\n",
        "    times+=1\n",
        "print(f\"{num} appears {times} times in the tuple\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Ht0yofGk0ca",
        "outputId": "041920a1-1ef9-4d2f-9091-bec24ed0b1c1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "8 appears 4 times in the tuple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 6\n",
        "Write a Python program to reverse a given tuple.\n",
        "[You are not allowed to use slicing]\n",
        "\n",
        "Note: 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",
        "\n",
        "\n",
        "Example 1:\n",
        "\n",
        "Given tuple: ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')\n",
        "\n",
        "Output:\n",
        "\n",
        "('h', 'g', 'f', 'e', 'd', 'c', 'b', 'a')\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example 2:\n",
        "\n",
        "Given tuple: (10, 20, 30, 40, 50, 60)\n",
        "\n",
        "Output:\n",
        "\n",
        "(60, 50, 40, 30, 20, 10)\n"
      ],
      "metadata": {
        "id": "7_Wft3gxPHNB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task6\n",
        "given_tuple = (10, 20, 30, 40, 50, 60)\n",
        "list1=list(given_tuple)\n",
        "list2=[]\n",
        "for i in range(1,len(list1)+1):\n",
        "    list2.append(list1[i*-1])\n",
        "print(tuple(list2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UJ0tvGuDmn2X",
        "outputId": "d181fe02-ead9-4c02-94e5-556b45c491be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(60, 50, 40, 30, 20, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part 2: Dictionary\n",
        "\n",
        "# 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",
        "Note: You can not use .update() function\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Given:\n",
        "\n",
        "{'Harry':15, 'Draco':8, 'Nevil':19}\n",
        "{'Ginie':18, 'Luna': 14}\n",
        "\n",
        "Output:\n",
        "\n",
        "{'Harry': 15, 'Draco': 8, 'Nevil': 19, 'Ginie': 18, 'Luna': 14}\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Given:\n",
        "\n",
        "{'A':90, 'B': 0}\n",
        "{'C':50}\n",
        "\n",
        "Output:\n",
        "\n",
        "{'A': 90, 'B': 0, 'C': 50}\n",
        "\n"
      ],
      "metadata": {
        "id": "2cIWL3kWPHOx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task7\n",
        "dict1={'Harry':15, 'Draco':8, 'Nevil':19}\n",
        "dict2={'Ginie':18, 'Luna': 14}\n",
        "dict3={}\n",
        "for k,v in dict1.items():\n",
        "  dict3[k]=v\n",
        "for k,v in dict2.items():\n",
        "  dict3[k]=v\n",
        "print(dict3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ATSGd_hhrJo8",
        "outputId": "009e0522-3c40-42a6-ad7c-a5a6dc3a39a3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Harry': 15, 'Draco': 8, 'Nevil': 19, 'Ginie': 18, 'Luna': 14}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Task 8\n",
        "\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",
        "[You are not allowed to use len() and sum()]\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Hint (1): For taking dictionary input\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",
        "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",
        "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",
        "\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",
        "\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"
      ],
      "metadata": {
        "id": "p5-twXvrPvqZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task8\n",
        "str1=input().split(\", \")\n",
        "dict1={}\n",
        "sum=0\n",
        "count=0\n",
        "for i in str1:\n",
        "  str2=i.split(\":\")\n",
        "  values=int(str2[1])\n",
        "  keys=str2[0]\n",
        "  dict1[keys]=values\n",
        "for i in dict1.values():\n",
        "  sum+=i\n",
        "  count+=1\n",
        "print(\"Average is\",sum//count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vEQMG2c87WDL",
        "outputId": "f4c6d39f-7865-44c6-b954-428f2ea3fc3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jon:100, Dan:200, Rob:300\n",
            "Average is 200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "number = int(input(\"Enter a number: \"))\n",
        "dict1 = {}\n",
        "for i in range(number):\n",
        "    key = input(\"write key of dictionary: \")\n",
        "    val = int(input(\"write value for key of dictionary: \"))\n",
        "    dict1[key] = val\n",
        "total = 0\n",
        "counter = 0\n",
        "for key, val in dict1.items():\n",
        "    total += val\n",
        "    counter += 1\n",
        "average = total / counter\n",
        "print('Average is',average)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k-M67ZgvCOR8",
        "outputId": "640ec177-00ab-47ff-9e40-08dda7b3ec00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 4\n",
            "write key of dictionary: Jon\n",
            "write value for key of dictionary: 100\n",
            "write key of dictionary: Dan\n",
            "write value for key of dictionary: 200\n",
            "write key of dictionary: Rob\n",
            "write value for key of dictionary: 30\n",
            "write key of dictionary: Ned\n",
            "write value for key of dictionary: 110\n",
            "Average is 110.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Task 9\n",
        "Suppose there is a dictionary named exam_marks as given below.\n",
        "exam_marks = {'Cierra Vega': 175, 'Alden Cantrell': 200, 'Kierra Gentry': 165, 'Pierre Cox': 190}\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",
        "\n",
        "Sample Input 1:\n",
        "\n",
        "170\n",
        "\n",
        "Sample Output 1:\n",
        "{'Cierra Vega': 175, 'Alden Cantrell': 200, 'Pierre Cox': 190}\n",
        "\n",
        "\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"
      ],
      "metadata": {
        "id": "wGmcMy7ZQUCh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task9\n",
        "exam_marks = {'Cierra Vega': 175, 'Alden Cantrell': 200, 'Kierra Gentry': 165, 'Pierre Cox': 190}\n",
        "num=int(input())\n",
        "dict3={}\n",
        "for k,v in exam_marks.items():\n",
        "  if v>=num:\n",
        "    dict3[k]=v\n",
        "print(dict3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DzEyPhz82UqO",
        "outputId": "148a88b0-f523-45ad-fce3-1dc48f4ee452"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "190\n",
            "{'Alden Cantrell': 200, 'Pierre Cox': 190}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 10\n",
        "Write a Python program that finds the largest value with its key from a given dictionary.\n",
        "\n",
        "[You are not allowed to use the max() function for this task]\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",
        "Hint: Think of membership operators (in and not in). You can use dictionary functions to get the values.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Sample 1:\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",
        "\n",
        "\n",
        "Sample 2:\n",
        "\n",
        "Given:\n",
        "\n",
        "{'sci fi': 5, 'mystery': 3, 'horror': 14, '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"
      ],
      "metadata": {
        "id": "14J8VAfSQvo4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task10\n",
        "given_list={'sci fi': 5, 'mystery': 3, 'horror': 14, 'young_adult': 2, 'adventure':9}\n",
        "max=0\n",
        "for k,v in given_list.items():\n",
        "  if v>max:\n",
        "    max=v\n",
        "    max_key=k\n",
        "print(f\"The highest selling book genre is '{max_key}' and the number of books sold are {max}.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wZF69f2U4HM-",
        "outputId": "23896336-70e6-4022-bf65-1f0346a16d0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The highest selling book genre is 'horror' and the number of books sold are 14.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "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. [You are not allowed to use the count() function]\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",
        "\n",
        "Sample Input:\n",
        "\n",
        "\"Python programming is fun\"\n",
        "\n",
        "Sample Output:\n",
        "\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"
      ],
      "metadata": {
        "id": "grmf7z4QRA7I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task11\n",
        "str1=input().lower()\n",
        "count=0\n",
        "dict3={}\n",
        "for i in str1:\n",
        "  if i!=\" \" and i!='\"':\n",
        "    for j in str1:\n",
        "      if i==j:\n",
        "        count+=1\n",
        "        dict3[i]=count\n",
        "    count=0\n",
        "print(dict3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9nBeVmP28UVF",
        "outputId": "6ce341a6-3cf6-4fec-c179-6e9a0d5c7434"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\"Python programming is fun\"\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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 12\n",
        "Suppose you are given the following dictionary where the values are lists.\n",
        "\n",
        "dict_1 = {'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.\n",
        "\n",
        "[Without using sum(), len(), count() functions]\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",
        "\n",
        "\n",
        "Output:\n",
        "\n",
        "9\n",
        "\n"
      ],
      "metadata": {
        "id": "Z_xVfOFbRMR6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task12\n",
        "dict_1 = {'A': [1, 2, 3], 'b': ['1', '2'], \"c\": [4, 5, 6, 7]}\n",
        "count=0\n",
        "for i in dict_1.values():\n",
        "  for j in i:\n",
        "    count+=1\n",
        "print(count)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9JrSDCgIXIZu",
        "outputId": "39a409ae-4fb5-414a-bce6-89e9b06ef9a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 13\n",
        "Suppose you have been given the following list of tuples.\n",
        "\n",
        "list_1 = [(\"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. The items in each tuple are a key and its value respectively. You need to group the values with the same keys into a list as shown below.\n",
        "\n",
        "[You are not allowed to use set]\n",
        "\n",
        "Hint: Think of membership operators (in and not in).\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Output:\n",
        "{'a': [1, 3, 2], 'b': [2, 1], 'c': [1]}\n"
      ],
      "metadata": {
        "id": "KPWxV5p9RaqS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task13\n",
        "list_1 = [(\"a\", 1), (\"b\", 2), (\"a\", 3), (\"b\", 1), (\"a\", 2), (\"c\", 1)]\n",
        "dict1={}\n",
        "dup=\"\"\n",
        "for i,j in list_1:\n",
        "  if i not in dict1.keys():\n",
        "    dict1[i]=[j]\n",
        "  else:\n",
        "    dict1[i]+=[j]\n",
        "print(dict1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "78x5hy8lWGnP",
        "outputId": "a252c3cb-34e8-4118-e284-038cccc31588"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'a': [1, 3, 2], 'b': [2, 1], 'c': [1]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 17\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",
        "\n",
        "\n",
        "Output:\n",
        "\n",
        "{'c1':'Red', 'c2':'Green', 'd4':'Blue'}\n",
        "\n"
      ],
      "metadata": {
        "id": "xKA_MscdRs-E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dictionary = {'c1':'Red', 'c2':'Green', 'c3':None, 'd4':'Blue', 'a5':None}\n",
        "dict1={}\n",
        "for k,v in my_dictionary.items():\n",
        "  if v!=None:\n",
        "    dict1[k]=v\n",
        "  else:\n",
        "    continue\n",
        "print(dict1)"
      ],
      "metadata": {
        "id": "C0htcEjhqjXO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fc6d606-dbc0-473c-85ff-217ffeb007b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'c1': 'Red', 'c2': 'Green', 'd4': 'Blue'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 18\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",
        "dict_1 = {'a' : 6, 'b' : 7, 'c' : 9, 'd' : 8, 'e' : 11, 'f' : 12, 'g' : 13}\n",
        "\n",
        "\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",
        "\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"
      ],
      "metadata": {
        "id": "sdUQ5hjcR8wO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dict_1 = {'a' : 6, 'b' : 7, 'c' : 9, 'd' : 8, 'e' : 11, 'f' : 12, 'g' : 13}\n",
        "num1=int(input())\n",
        "num2=int(input())\n",
        "dict1={}\n",
        "for k,v in dict_1.items():\n",
        "  if v==(num1) or v==(num2-1):\n",
        "    dict1[k]=v\n",
        "  else:\n",
        "    continue\n",
        "print(dict1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pf8yg-e9ncqM",
        "outputId": "3ad0c3a4-b871-4799-f09b-652ce9a0a55a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "14\n",
            "18\n",
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 19\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",
        "[You do not need to take tuple as input and can assume that it is given as below]\n",
        "\n",
        "\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",
        "\n",
        "\n",
        "Example 2:\n",
        "\n",
        "Given:\n",
        "\n",
        "[(20, 'Sad'), (31, 'Sad'), (88, 'NotSad'), (27, 'NotSad')]\n",
        "\n",
        "Output:\n",
        "\n",
        "\n",
        "{'NotSad': [(88, 'NotSad'), (27, 'NotSad')],\n",
        "'Sad: [(20, 'Sad'), (31, 'Sad')]}"
      ],
      "metadata": {
        "id": "Nb4SSqcZSOds"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task 19\n",
        "given_tuple=[(20, 80), (31, 80), (1, 22), (88, 11), (27, 11)]\n",
        "dict1={}\n",
        "for k,v in given_tuple:\n",
        "  if v not in dict1.keys():\n",
        "    dict1[v]=[(k,v)]\n",
        "  else:\n",
        "     dict1[v]+=[(k,v)]\n",
        "print(dict1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S9a1AK4Bv-Ua",
        "outputId": "fd5028e3-043b-4490-fd3c-6161c6659192"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{80: [(20, 80), (31, 80)], 22: [(1, 22)], 11: [(88, 11), (27, 11)]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "oRGllkSESKih"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}