CSE110 All Assignments (questions-solutions).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-ZXkm8Ln6Af"
      },
      "source": [
        "#<font color='red'>SUMAIYA HOSSAIN SUROVI (Owner)\n",
        "BRAC UNIVERSITY\\\n",
        "*CSE DEPARTMENT*\\\n",
        "**SUMMAR'22 SESSION**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "trMmD43xxMze"
      },
      "source": [
        "# #<font color='blue'>Assignment 1 (Branching)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Baka9H-V4Skx"
      },
      "source": [
        "### Task 1\n",
        "\n",
        "Write the Python code of a program that reads two numbers from the user, and prints their sum, product, and difference.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*Hint: subtract the second number from the first one*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "**Sample Input:**\\\n",
        " 4\\\n",
        " 5\n",
        "\n",
        "**Sample Output:**\\\n",
        "Sum = 9\\\n",
        "Product = 20\\\n",
        "Difference = -1\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "**Sample Input:**\\\n",
        " 30\\\n",
        " 2\n",
        "\n",
        "**Sample Output:**\\\n",
        "Sum = 32\\\n",
        "Product = 60\\\n",
        "Difference = 28\n",
        "\n",
        "=========================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6CNQgOSY1Len",
        "outputId": "6d925d5b-af6e-4c8f-87ef-0ff69bd99612"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 5\n",
            "Enter another number: 4\n",
            "Sum = 9\n",
            "Product = 20\n",
            "Difference = -1\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "b=int(input(\"Enter another number: \"))\n",
        "print(\"Sum =\",a+b)\n",
        "print(\"Product =\",a*b)\n",
        "print(\"Difference =\",b-a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YHJPzXH7Lfw5"
      },
      "source": [
        "### Task 2\n",
        "\n",
        "Write the Python code of a program that reads the radius of a circle and prints its circumference and area.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*hint(1): we may import math and then use **math.pi** for getting the value of pi.\\\n",
        "For details, we can read from https://docs.python.org/3/library/math.html*\n",
        "\n",
        "*hint(2): we can import math and use the math function for making squares with math.pow(number, power) or we can simply use the power operator. For example:  S**2.*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "**Sample Input:**\\\n",
        "4\n",
        "\n",
        "**Sample Output:**\\\n",
        "Area is 50.26548245743669\\\n",
        "Circumference is 25.132741228718345\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "**Sample Input:**\\\n",
        "3.5\n",
        "\n",
        "**Sample Output:**\\\n",
        "Area is 38.48451000647496\\\n",
        "Circumference is 21.991148575128552\n",
        "\n",
        "=========================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-w4i_hyQL3VQ",
        "outputId": "6f43702c-0559-49dd-f1bb-00a197910f2c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a radius: 3.5\n",
            "Area is  38.48451000647496\n",
            "Circumference is  21.991148575128552\n"
          ]
        }
      ],
      "source": [
        "import math\n",
        "r=float(input(\"Enter a radius: \"))\n",
        "area=math.pi*(r**2)\n",
        "Circumference=2*math.pi*r\n",
        "print(\"Area is \",area)\n",
        "print(\"Circumference is \",Circumference)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G4grcQ5aOIOI"
      },
      "source": [
        "### Task 3\n",
        "\n",
        "Write the Python code of a program that reads two numbers from the user. The program should then print \"First is greater\" if the first number is greater, \"Second is greater\" if the second number is greater, and \"The numbers are equal\" otherwise.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "7\\\n",
        "3\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "First is greater\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "-33\\\n",
        "-3\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "Second is greater\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "11\\\n",
        "11\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "The numbers are equal"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6lQ1tdoGOPhx",
        "outputId": "b3664ea9-16f9-46ed-f339-10aa4d520902"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: -33\n",
            "Enter another number: -3\n",
            "Second is greater\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "b=int(input(\"Enter another number: \"))\n",
        "if a>b:\n",
        "  print(\"First is greater\")\n",
        "elif a<b:\n",
        "  print(\"Second is greater\")\n",
        "else:\n",
        "  print(\"The numbers are equal\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xPC35hHARQkp"
      },
      "source": [
        "### Task 4\n",
        "\n",
        "Write the Python code of a program that reads two numbers, subtracts the smaller number from the larger one, and prints the result.\n",
        "\n",
        "*Hint: First, we may check which number is greater*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "-40\\\n",
        "-4\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "36\n",
        "\n",
        "**Explanation:** -4 > -40 so -4 - (-40) = -4 + 40 = 36\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "6\\\n",
        "2\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "4\n",
        "\n",
        "==========================================================\n",
        "\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "5\\\n",
        "5\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "0\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZsJ3B_c7ZjkS",
        "outputId": "8c5c4613-ad90-4e50-e597-b297715176d3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: -40\n",
            "Enter another number: -4\n",
            "36\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "b=int(input(\"Enter another number: \"))\n",
        "if b>a:\n",
        "  print(b-a)\n",
        "else:\n",
        "  print(a-b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FTosOoR0aIDO"
      },
      "source": [
        "### Task 5\n",
        "\n",
        "Write the Python code of a program that reads a number, and prints \"The number is even\" or \"The number is odd\", depending on whether the number is even or odd.\n",
        "\n",
        "*hint(1): we may use the modulus (%) operator to check for even or odd*\n",
        "\n",
        "*hint(2): we can consider the number to be an integer*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "7\\\n",
        "**Sample Output 1:**\\\n",
        "The number is odd\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "10\\\n",
        "**Sample Output 2:**\\\n",
        "The number is even\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "-44\\\n",
        "**Sample Output 3:**\\\n",
        "The number is even\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-p9UYTioaw-9",
        "outputId": "1319c82c-3f2c-4f33-b623-924764f007a3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: -44\n",
            "The number is even\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "if a%2==0:\n",
        "  print(\"The number is even\")\n",
        "else:\n",
        "  print(\"The number is odd\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OkQOv1YybYR3"
      },
      "source": [
        "### Task 6\n",
        "\n",
        "Write the Python code of a program that reads an integer as input from the user, and prints the integer if it is a multiple of **2 OR 5** and prints \"Not a multiple of 2 OR 5\" otherwise.\n",
        "\n",
        "For example, 2, 4, 5, 6, 8, 10, 12, 14, 15, 16, 18, 20, 22 … i.e. this includes multiples of 2 only, multiples of 5 only and multiples of 2 and 5 both.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*hint(1): we may use the modulus (%) operator for checking the divisibility*\n",
        "\n",
        "*hint(2): we can consider the number to be an integer*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "5\\\n",
        "**Sample Output 1:**\\\n",
        "5\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "10\\\n",
        "**Sample Output 2:**\\\n",
        "10\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "3\\\n",
        "**Sample Output 3:**\\\n",
        "Not a multiple of 2 OR 5\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ScERz5HlcY7Q",
        "outputId": "f8f8edf2-c314-4cfe-e683-3c78c459b71f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 3\n",
            "Not a multiple of 2 OR 5\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "if a%2==0 and a%5==0:\n",
        "  print(a)\n",
        "else:\n",
        "  print(\"Not a multiple of 2 OR 5\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aubMZHeLqsa1"
      },
      "source": [
        "### Task 7\n",
        "Write the Python code of a program that reads an integer, and prints the integer  it is a multiple of **either 2 or 5 but not both.** If the number is a multiple of 2 and 5 both, then print \"Multiple of 2 and 5 both\". For all other numbers, the program prints \"Not a multiple we want\".\\\n",
        "For example, 2, 4, 5, 6, 8, 12, 14, 15, 16, 18, 22 … i.e. this includes multiples of 2 only and multiples of 5 only, NOT multiples of 2 and 5 both or other numbers.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*hint(1): we may use the modulus (%) operator for checking the divisibility*\\\n",
        "*hint(2): we can consider the number to be an integer*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "6\\\n",
        "**Sample Output 1:**\\\n",
        "6\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "15\\\n",
        "**Sample Output 2:**\\\n",
        "15\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "10\\\n",
        "**Sample Output 3:**\\\n",
        "Multiple of 2 and 5 both\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 4:**\\\n",
        "17\\\n",
        "**Sample Output 4:**\\\n",
        "Not a multiple we want"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KD39l7EIq4iv",
        "outputId": "8c1bec00-f9d4-4c7a-a10d-74f8f3d59427"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 10\n",
            "Multiple of 2 and 5 both\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "if a%2==0 and a%5==0 :\n",
        "  print(\"Multiple of 2 and 5 both\")\n",
        "elif a%2==0 or a%5==0 :\n",
        "   print(a)\n",
        "else:\n",
        "  print(\"Not a multiple we want\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHmlcqu2uOS8"
      },
      "source": [
        "### Task 8\n",
        "Write the Python code of a program that reads an integer, and prints the integer if it is a multiple of **2 AND 5** and prints \"Not multiple of 2 and 5 both\" otherwise.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "For example, 10, 20, 30, 40, 50 … i.e. this only includes numbers which are multiples of both 2 and 5.\n",
        "\n",
        "*hint(1): we may use the modulus (%) operator for checking the divisibility*\\\n",
        "*hint(2): we can consider the number to be an integer*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "30\\\n",
        "**Sample Output 1:**\\\n",
        "30\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "15\\\n",
        "**Sample Output 2:**\\\n",
        "Not multiple of 2 and 5 both\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "6\\\n",
        "**Sample Output 3:**\\\n",
        "Not multiple of 2 and 5 both"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "df9lQR_Iv9hu",
        "outputId": "d5c6ba30-44d1-4a08-ae2d-07a78898f2c4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 15\n",
            "Not multiple of 2 and 5 both\n"
          ]
        }
      ],
      "source": [
        "a=int(input(\"Enter a number: \"))\n",
        "if a%2==0 and a%5==0 :\n",
        "  print(a)\n",
        "else:\n",
        "  print(\"Not multiple of 2 and 5 both\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SXpXDAhAwrIM"
      },
      "source": [
        "### Task 9\n",
        "Write the Python code of a program that finds the number of hours, minutes, and seconds in a **given number of seconds.** The number of seconds is taken as input from the user.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*hint(1): we may consider our user input to be an integer value and use // and % operators to solve the problem* \\\n",
        "*hint(2): 1 hour = 60 mins = 3600 seconds* and *1 min = 60 seconds*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "10000\\\n",
        "**Sample Output 1:**\\\n",
        "Hours: 2  Minutes: 46  Seconds: 40\n",
        "\n",
        "**Explanation:**\\\n",
        "10000 seconds = 10000 // 3600 = 2 hours and 10000 % 3600 = 2800 seconds.\\\n",
        "Then again, 2800 // 60 = 46 minutes and 2800 % 60 = 40 seconds.\\\n",
        "And hence we have arrived at our answer.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "500\\\n",
        "**Sample Output 2:**\\\n",
        "Hours: 0  Minutes: 8  Seconds: 20\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8jBrlGkFwy08",
        "outputId": "cbe230a4-c68d-4e91-a485-010a5e8ecb3e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number of seconds: 500\n",
            "Hours:0 Minutes:8 Seconds:20\n"
          ]
        }
      ],
      "source": [
        "a = int(input(\"Enter the number of seconds: \"))\n",
        "if a>=3600 :\n",
        "  hours = a // 3600\n",
        "  b = a % 3600\n",
        "  minutes = b // 60\n",
        "  seconds = b % 60\n",
        "  print(f\"Hours:{hours} Minutes:{minutes} Seconds:{seconds}\")\n",
        "else:\n",
        "  hours = 0\n",
        "  minutes = a // 60\n",
        "  seconds = a % 60\n",
        "  print(f\"Hours:{hours} Minutes:{minutes} Seconds:{seconds}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Vh3bL6_0Axm"
      },
      "source": [
        "### Task 10\n",
        "\n",
        "Write a Python program to compute and display a person’s weekly salary as determined by the following conditions:\n",
        "\n",
        "* If the hours worked is less than or equal to 40, then the person receives Tk 200 per hour.\n",
        "* If the hours worked is greater than 40, then the person receives Tk 8000 plus Tk 300 for each hour worked over 40 hours.\n",
        "\n",
        "The program should request the hours worked as an input from the user and display the salary as output. You need to make sure that user input is valid. For example, a person cannot work for -5 hours or more than 168 hours in a week. So, the valid hours range is 0 to 168. For invalid hours, print outputs as given in the samples below.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*Hint: you can consider the hour (user input) to be an integer*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "100\\\n",
        "**Sample Output 1:**\\\n",
        "26000\n",
        "\n",
        "**Explanation:** Since, the number of hours worked is 100 > 40, therefore salary = 8000 + (100 - 40) * 300 = 26000.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "30\\\n",
        "**Sample Output 2:**\\\n",
        "6000\n",
        "\n",
        "**Explanation:** Since, the number of hours worked is 30 < 40, therefore salary = 30 * 200 = 6000.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "-30\\\n",
        "**Sample Output 3:**\\\n",
        "Hour cannot be negative\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 4:**\\\n",
        "170\\\n",
        "**Sample Output 4:**\\\n",
        "Impossible to work more than 168 hours weekly"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "utw85C3H0YOz",
        "outputId": "0655b35d-5bfe-498d-cade-a643b38c4ae8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the weekly hours of work: 100\n",
            "26000\n"
          ]
        }
      ],
      "source": [
        "h = int(input(\"Enter the weekly hours of work: \"))\n",
        "if h <= 40 and h >= 0:\n",
        "  salary = h * 200\n",
        "  print(salary)\n",
        "elif h <0:\n",
        "  print(\"Hour cannot be negative\")\n",
        "elif h > 168:\n",
        "  print(\"Impossible to work more than 168 hours weekly\")\n",
        "else:\n",
        "  salary = 8000 + (h-40) * 300\n",
        "  print(salary)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gXMHXPGN0Y7F"
      },
      "source": [
        "### Task 11\n",
        "Suppose the following expressions are used to calculate the values of L for different values of S:\n",
        "\n",
        "$L =  3000-125S^2$\n",
        "if     $S<100$\n",
        "\n",
        "$ L =  \\frac{12000}{4+S^2/14900}$\n",
        "if     $S\\geq100$\n",
        "\n",
        "Write the Python code of a program that reads a value of S and then calculates the value of L.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*hint(1): you can import math and use math function for making squares with math.pow(number, power) or you can simply write S ** 2.*\n",
        "\n",
        "*hint(2): the value of S(user input) will be an integer*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "120\\\n",
        "**Sample Output 1:**\\\n",
        "2416.2162162162163\n",
        "\n",
        "**Explanation:** Since S (user input) given here is 120 >= 100, so L = 12000 / (4 + (120 * 120)/14900) = 2416.2162162162163\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "3\\\n",
        "**Sample Output 2:**\\\n",
        "1875\n",
        "\n",
        "**Explanation:** Since S (user input) given here is 3 < 100, so L = 3000 - 125 * 3 * 3 = 1875"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2lxWQ7cQ05n6",
        "outputId": "f1ad29c2-01c9-43ae-8443-107b43e159aa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a value of S: 120\n",
            "2416.2162162162163\n"
          ]
        }
      ],
      "source": [
        "S = int(input(\"Enter a value of S: \"))\n",
        "if S>=100:\n",
        "  L = 12000/(4+(S*S/14900))\n",
        "  print(L)\n",
        "else:\n",
        "  L = 3000 - (125*S*S)\n",
        "  print(L)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WSAiJUdj093i"
      },
      "source": [
        "### Task 12\n",
        "\n",
        "Write a Python program that takes an hour from the user as input and tells it is time for which meal.\n",
        "\n",
        "•\tThe user will input the number in a 24-hour format. So, 14 means 2 pm, 3 means 3 am, 18 means 6 pm, etc.\\\n",
        "•\tValid inputs are 0 to 23. Inputs less than 0 or more than 23 are invalid in 24-hour clock.\\\n",
        "•\tAssume, input will be whole numbers. For example, 3.5 will NOT be given as input.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Input range: Message to be printed**\\\n",
        "4 to 6: Breakfast\\\n",
        "12 to 13: Lunch\\\n",
        "16 to 17: Snacks\\\n",
        "19 to 20: Dinner\\\n",
        "For all other valid inputs, say \"Patience is a virtue\"\\\n",
        "For all other invalid inputs, say \"Wrong time\"\n",
        "\n",
        "==========================================================\n",
        "\n",
        "For example,\\\n",
        "If the user enters 4, your program should print the message \"Breakfast\".\\\n",
        "If the user enters 5, your program should print the message \"Breakfast\".\\\n",
        "If the user enters 6, your program should print the message \"Breakfast\".\\\n",
        "If the user enters 0, your program should print the message \"Patience is a virtue\".\\\n",
        "If the user enters 1, your program should print the message \"Patience is a virtue\".\\\n",
        "If the user enters 18, your program should print the message \"Patience is a virtue\".\\\n",
        "If the user enters 23, your program should print the message \"Patience is a virtue\".\\\n",
        "If the user enters 24, your program should print the message \"Wrong Time\".\\\n",
        "If the user enters -1, your program should print the message \"Wrong Time\".\\\n",
        "If the user enters 27, your program should print the message \"Wrong time\".\n",
        "\n",
        "==========================================================\n",
        "\n",
        "Hints: You can use nested conditionals (if-else) or chained conditions (if-elif-else) to solve this problem.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HpJK0rBL1I2f",
        "outputId": "f00dde23-00d7-4fd0-b1e6-1db4b86c71b8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter An Hour in 24 Hour format: 0\n",
            "\"Patience is a virtue\"\n"
          ]
        }
      ],
      "source": [
        "hour= int(input(\"Enter An Hour in 24 Hour format: \"))\n",
        "if (hour>=0 and hour<=23):\n",
        "  if(hour>=4 and hour<=6):\n",
        "    print(\"\\\"Breakfast\\\"\")\n",
        "  elif(hour>=12 and hour<=13):\n",
        "    print(\"\\\"Lunch\\\"\")\n",
        "  elif(hour>=16 and hour<=17):\n",
        "    print(\"\\\"Snacks\\\"\")\n",
        "  elif(hour>=19 and hour<=20):\n",
        "    print(\"\\\"Dinner\\\"\")\n",
        "  else:\n",
        "    print(\"\\\"Patience is a virtue\\\"\")\n",
        "else:\n",
        "  print(\"\\\"Wrong time\\\"\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zhpclRDp1SC1"
      },
      "source": [
        "### Task 13\n",
        "\n",
        "Write the Python code of a program that reads a student’s mark for a single subject, and prints out the corresponding grade for that mark. The mark ranges and corresponding grades are shown in the table below. You need to make sure that the mark is valid. For example, a student cannot receive -5 or 110 marks. So, the valid marks range is 0 to 100.\n",
        "\n",
        "*hint(1): you can consider the number to be an integer*\n",
        "\n",
        "*hint(2): this problem can be solved in two ways: top-down (starts from A) and bottom-up (starts from F)*\n",
        "\n",
        "\n",
        "| Marks | Grade|\n",
        "| --- | --- |\n",
        "|90 or above| A |\n",
        "|  |  |\n",
        "|80-89| B |\n",
        "|  |  |\n",
        "|70-79| C |\n",
        "|  |  |\n",
        "|60-69| D |\n",
        "|  |  |\n",
        "|50-59| E |\n",
        "|  |  |\n",
        "|Below 50| F |\n",
        "|  |  |\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xhJw9ADm1UR1",
        "outputId": "72645d6e-e3d4-4824-bb99-44e85166c20f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter Mark for a single subject to see the corresponding grade: 89\n",
            "Grade: B\n"
          ]
        }
      ],
      "source": [
        "mark=int(input(\"Enter Mark for a single subject to see the corresponding grade: \"))\n",
        "if (mark>=0 and mark<=100):\n",
        "  if(mark>=90 and mark<=100):\n",
        "    print(\"Grade: A\")\n",
        "  elif(mark>=80 and mark<=89):\n",
        "    print(\"Grade: B\")\n",
        "  elif(mark>=70 and mark<=79):\n",
        "    print(\"Grade: C\")\n",
        "  elif(mark>=60 and mark<=69):\n",
        "    print(\"Grade: D\")\n",
        "  elif(mark>=50 and mark<=59):\n",
        "    print(\"Grade: E\")\n",
        "  elif(mark<=50 and mark>=0):\n",
        "    print(\"Grade: F\")\n",
        "else:\n",
        "  print(\"The mark is not valid.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rEnksafk1ilf"
      },
      "source": [
        "### Task 14\n",
        "Suppose, your friend is building an automated car called “Besla”. He needs to fix the programming of the car so that it runs at a proper speed. Now, write a python program that takes 2 inputs (distance in meters and time in seconds). The program should then print the velocity in kilometers per hour of that car. Also, it should print whether the car is working properly based on the following chart.\n",
        "\n",
        "|Velocity|Information to be printed|\n",
        "|------|------|\n",
        "|Less than 60 km/h  |Too slow. Needs more changes.\n",
        "|Between 60 km/h to 90 km/h |Velocity is okay. The car is ready!\n",
        "|Greater than 90 km/h|Too fast. Only a few changes should suffice.\n",
        "\n",
        "==========================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "160000\\\n",
        "7200\n",
        "\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "80.0 km/h\\\n",
        "Velocity is okay. The car is ready!\n",
        "\n",
        "\n",
        "**Explanation:** After the conversion of distance and time, the velocity is (160/2) km/h = 80 km/h. So the velocity is okay\n",
        "\n",
        " ==========================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "25400\\\n",
        "3600\n",
        "\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "25.4 km/h\\\n",
        "Too slow. Needs more changes.\n",
        "\n",
        "**Explanation:** After the conversion of distance and time, the velocity is (25.4/1) km/h = 25.4 km/h. So the speed is too slow."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JFceZuOz1kxR",
        "outputId": "0c9ae6fb-24d3-49a5-dc49-2834ff8ddd2e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter distance in meters: 25400\n",
            "Enter time in second: 3600\n",
            "25.4km/h\n",
            "Too slow.Needs more changes.\n"
          ]
        }
      ],
      "source": [
        "d=int(input(\"Enter distance in meters: \"))\n",
        "t=int(input(\"Enter time in seconds: \"))\n",
        "v=((d/1000)/(t/3600))\n",
        "if (v<60):\n",
        "  print(f\"{v}km/h\\nToo slow.Needs more changes.\")\n",
        "elif (v>=60 and v<=90):\n",
        "  print(f\"{v}km/h\\nVelocity is okay.The car is ready!\")\n",
        "else:\n",
        "  print(f\"{v}km/h\\nToo fast.Only a few changes should suffice. \")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U1IXNjUZ161x"
      },
      "source": [
        "### Task 15\n",
        "Write a python program that takes the CGPA and no of credits completed by a student and prints whether the student is eligible for a waiver and of what percentage.\n",
        "\n",
        "To be eligible for a waiver, a student must have completed at least 30 credits and earned a CGPA greater or equal to 3.8. If not, please print \"The students is not eligible for a waiver\".\n",
        "\n",
        "**CGPA** | **Waiver percentage**\n",
        "--- | ---\n",
        "3.80 - 3.89 | 25 percent\n",
        "3.90 - 3.94 | 50 percent\n",
        "3.95 - 3.99 | 75 percent\n",
        "4.00 | 100 percent\n",
        "\n",
        "\n",
        "**Sample Input 1:** \\\n",
        "3.93 \\\n",
        "78\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "The student is eligible for a waiver of 50 percent.\n",
        "\n",
        "================================================================================\n",
        "\n",
        "**Sample Input 2:** \\\n",
        "3.79 \\\n",
        "24\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "The students is not eligible for a waiver \\\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kDYZJEEq19cy",
        "outputId": "e9f22f7b-3823-4d0f-d949-3b13c15b44a7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the CGPA earned by the student: 3.93\n",
            "Enter the amount of credits completed by the student: 78\n",
            "The student is eligible for a waiver of 50 percent.\n"
          ]
        }
      ],
      "source": [
        "cgpa=float(input(\"Enter the CGPA earned by the student: \"))\n",
        "credits=int(input(\"Enter the amount of credits completed by the student: \"))\n",
        "if (credits>=30 and cgpa>=3.8):\n",
        "  if(cgpa>=3.80 and cgpa<=3.89):\n",
        "    print(\"The student is eligible for a waiver of 25 percent.\")\n",
        "  elif(cgpa>=3.90 and cgpa<=3.94):\n",
        "    print(\"The student is eligible for a waiver of 50 percent.\")\n",
        "  elif(cgpa>=3.95 and cgpa<=3.99):\n",
        "    print(\"The student is eligible for a waiver of 75 percent.\")\n",
        "  elif(cgpa==4):\n",
        "    print(\"The student is eligible for a waiver of 100 percent.\")\n",
        "else:\n",
        "  print(\"The student is not eligible for a waiver.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "obCXk8y12A9v"
      },
      "source": [
        "# <font color='purple'> Task 16 to Task 19 are [ Tracing ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XoxuslE42s7b"
      },
      "source": [
        "### Task 20\n",
        "\n",
        "Write the Python code of a program that reads an integer, and prints the integer if it is a multiple of **NEITHER 2 NOR 5.**\n",
        "\n",
        "For example, 1, 3, 7, 9, 11, 13, 17, 19, 21, 23, 27, 29, 31, 33, 37, 39 …\\\n",
        "==========================================================\\\n",
        "*hint(1): you may use the modulus (%) operator for checking the divisibility*\\\n",
        "*hint(2): you can consider the number to be an integer* \\\n",
        "==========================================================\\\n",
        "**Sample Input 1:** \\\n",
        "3\\\n",
        "**Sample Output 1:** \\\n",
        "3\\\n",
        "==========================================================\\\n",
        "**Sample Input 2:** \\\n",
        "19\\\n",
        "**Sample Output 2:** \\\n",
        "19\\\n",
        "==========================================================\\\n",
        "**Sample Input 3:** \\\n",
        "5\\\n",
        "**Sample Output 3:** \\\n",
        "No\\\n",
        "==========================================================\\\n",
        "**Sample Input 4:** \\\n",
        "12\\\n",
        "**Sample Output 4:** \\\n",
        "No\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3yGpGdQP3VrU",
        "outputId": "95b2bb55-6e29-491f-8f7f-6133d529cc48"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 19\n",
            "19\n"
          ]
        }
      ],
      "source": [
        "num = int(input(\"Enter a number: \"))\n",
        "if (num % 2 != 0 and num % 5 != 0):\n",
        "    print(num)\n",
        "else:\n",
        "    print(\"No\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1pecCb-B3cBi"
      },
      "source": [
        "### Task 21\n",
        "\n",
        "Write the Python code of a program that reads an integer, and prints the integer if it is **NOT a multiple of 2** OR **NOT a multiple of 5.**\n",
        "\n",
        "For example, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22\n",
        "\n",
        "==========================================================\n",
        "\n",
        "*hint(1): you may use the modulus (%) operator for checking the divisibility*\n",
        "\n",
        "*hint(2): you can consider the number to be an integer* \\\n",
        "==========================================================\\\n",
        "**Sample Input 1:** \\\n",
        "3\\\n",
        "**Sample Output 1:** \\\n",
        "3\\\n",
        "==========================================================\\\n",
        "**Sample Input 2:** \\\n",
        "15\\\n",
        "**Sample Output 2:** \\\n",
        "15\\\n",
        "==========================================================\\\n",
        "**Sample Input 3:** \\\n",
        "20\\\n",
        "**Sample Output 3:** \\\n",
        "No\\\n",
        "==========================================================\\\n",
        "**Sample Input 4:** \\\n",
        "14\\\n",
        "**Sample Output 4:** \\\n",
        "14"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l318qaC13p-d",
        "outputId": "f9884dc8-1937-4d98-d193-7925096b67d8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 20\n",
            "No\n"
          ]
        }
      ],
      "source": [
        "num = int(input(\"Enter a number: \"))\n",
        "if (num % 2 != 0 or num % 5 != 0):\n",
        "    print(num)\n",
        "else:\n",
        "    print(\"No\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OLGQHL6x31QO"
      },
      "source": [
        "### Task 22\n",
        "Fiona has recently started acrylic painting and she is planning to order a few canvases and paints from an online stationery shop. The price of each 10 x 10 sized canvas is **120 tk** and the price of each 25 ml paint tube is **75 tk**. Depending on the total amount ordered from the shop, she will get some discounts. The table below shows the discount she will get on her total amount.\n",
        "\n",
        "|Total Amount (TK)|Discount (TK)|\n",
        "|------|------|\n",
        "|0 - 299|No Discount|\n",
        "|300 - 499|10|\n",
        "|500 - 749 |20|\n",
        "|750 - 999|50|\n",
        "|>= 1000|150|\n",
        "\n",
        "Write a python program and take two inputs from the user. The first input will be the number of canvases and the second input will be the number of paint tubes ordered. Based on the price of each item, calculate the total amount that Fiona needs to pay including the discount.  \n",
        "\n",
        "=================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "5\\\n",
        "8\\\n",
        "**Sample Output 1:**\\\n",
        "Previous total: 1200\\\n",
        "New total after discount: 1050\n",
        "\n",
        "**Explanation:** 5 * 120 + 8 * 75 = 1200 Tk was her bill without discount.  For 1200 Tk, the discount amount is 150 Tk. So, her new bill with a discount is (1200 - 150) = 1050 Tk.\n",
        "\n",
        "=================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "0\\\n",
        "3\\\n",
        "**Sample Output 2:**\\\n",
        "Previous total: 225\\\n",
        "New total after discount: 225\n",
        "\n",
        "**Explanation:** 0 * 120 + 3 * 75 = 225 Tk was her bill without discount.  For 225 Tk, the discount amount is 0 Tk. So, her new bill with a discount is (225 - 0) = 225 Tk."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xENU13ac4OBV",
        "outputId": "9dd8afaa-3a2f-4c80-c8da-cf6a4e4d8301"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number of ordered Canvases: 5\n",
            "Enter the number of ordered Paint Tubes: 8\n",
            "Previous total: 1200\n",
            "New total after discount: 1050\n"
          ]
        }
      ],
      "source": [
        "canv=int(input(\"Enter the number of ordered Canvases: \"))\n",
        "pt=int(input(\"Enter the number of ordered Paint Tubes: \"))\n",
        "total=((canv*120)+(pt*75))\n",
        "if (total>=0 and total<=299):\n",
        "  discount=(total-0)\n",
        "  print(f\"Previous total: {total}\\nNew total after discount: {discount}\")\n",
        "elif (total>=300 and total<=499):\n",
        "  discount=(total-10)\n",
        "  print(f\"Previous total: {total}\\nNew total after discount: {discount}\")\n",
        "elif (total>=500 and total<=749):\n",
        "  discount=(total-20)\n",
        "  print(f\"Previous total: {total}\\nNew total after discount: {discount}\")\n",
        "elif (total>=750 and total<=999):\n",
        "  discount=(total-50)\n",
        "  print(f\"Previous total: {total}\\nNew total after discount: {discount}\")\n",
        "else:\n",
        "  discount=(total-150)\n",
        "  print(f\"Previous total: {total}\\nNew total after discount: {discount}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hREAgECF4O87"
      },
      "source": [
        "### Task 23\n",
        "\n",
        "You are designing a robot that can calculate the temperature and guess the season. Write a Python program that takes a number as input, representing the temperature in degrees Fahrenheit, and converts it into degrees Celsius, and then prints the season based on the following table:\n",
        "\n",
        "\n",
        "| Temperature (degrees Celsius) | Season|\n",
        "| --- | --- |\n",
        "|Less than 20 degrees| Winter |\n",
        "|  |  |\n",
        "|Between 20 degrees and 25 degrees (inclusive)| Autumn |\n",
        "|  |  |\n",
        "|Greater than 25 degrees and less than 30 degrees| Spring |\n",
        "|  |  |\n",
        "|Greater than or equal to 30 degrees| Summer |\n",
        "|  |  |\n",
        "\n",
        "Use the following formula to convert the temperature:\\\n",
        "(degrees Celsius) = ((degrees Fahrenheit) - 32) * 0.56\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "82\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "28 degrees C\\\n",
        "Spring\n",
        "\n",
        "**Explanation:** The temperature in Celsius is (82 - 32) * 0.56 = 28 degrees, which is printed. This is between 25 and 30 degrees, so “Spring” is printed after that.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "32\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "0 degrees C\\\n",
        "Winter\n",
        "\n",
        "**Explanation:** The temperature in Celsius is (32 - 32) * 0.56 = 0 degrees, which is printed. This is less than 20 degrees, so “Winter” is printed after that.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "76\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "24.64 degrees C\\\n",
        "Autumn\n",
        "\n",
        "**Explanation:** The temperature in Celsius is (76 - 32) * 0.56 = 24.64 degrees, which is printed. This is between 20 degrees and 25 degrees (inclusive), so “Autumn” is printed after that.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 4:**\\\n",
        "77\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "25.2 degrees C\\\n",
        "Spring\n",
        "\n",
        "**Explanation:** The temperature in Celsius is (77 - 32) * 0.56 = 25.2 degrees, which is printed. This is greater than 25 degrees and less than 30 degrees, so “Spring” is printed after that.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QoQzEDT_4jl-",
        "outputId": "9137eab6-f039-43ff-8666-d246a16655be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a temperature in degree Fahrenheit: 76\n",
            "24.64 degrees C\n",
            "Autumn\n"
          ]
        }
      ],
      "source": [
        "t=float(input(\"Enter a temperature in degree Fahrenheit: \"))\n",
        "T =(t-32)*0.56\n",
        "T=round(T, 2)\n",
        "if T<20:\n",
        "  print(f\"{T} degrees C\\nWinter\")\n",
        "elif (T>=20 and T<=25):\n",
        "  print(f\"{T} degrees C\\nAutumn\")\n",
        "elif (T>25 and T<30):\n",
        "  print(f\"{T} degrees C\\nSpring\")\n",
        "else:\n",
        "  print(f\"{T} degrees C\\nSummer\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r0MtZc0R4kUn"
      },
      "source": [
        "# #Extra Problems From BracU Assignments\n",
        "### Task 1\n",
        "Write a Python function that takes the “amount” of money as user input. Then splits that money into 500, 100, 50, 20, 10, 5, 2, and 1 taka notes and print the final result.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "*Hints: This task’s calculation is similar to Assignment-1’s seconds to hours, minutes conversion.*\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example1:**\\\n",
        "**Sample Input:**\\\n",
        "1234\\\n",
        "**Sample Output:**\\\n",
        "500 Taka: 2 note(s)\\\n",
        "100 Taka: 2 note(s)\\\n",
        "20 Taka: 1 note(s)\\\n",
        "10 Taka: 1 note(s)\\\n",
        "2 Taka: 2 note(s)\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example2:**\n",
        "\n",
        "**Sample Input:**\\\n",
        "151\\\n",
        "**Sample Output:**\\\n",
        "100 Taka: 1 note(s)\\\n",
        "50 Taka: 1 note(s)\\\n",
        "1 Taka: 1 note(s)\n",
        "\n",
        "====================================================="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ACS_fX8Y6BUn"
      },
      "source": [
        "###Task 2\n",
        "Write Python code of a program that reads three sides of a triangle and check whether the triangle is valid or not.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input1:**\\\n",
        "7, 10, 5\\\n",
        "**Sample Output1:**\\\n",
        "Valid triangle\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input2:**\\\n",
        "2, 2, 4\\\n",
        "**Sample Output2:**\\\n",
        "Not a valid triangle\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input3:**\\\n",
        "7, 9, 12\\\n",
        "**Sample Output3:**\\\n",
        "Valid triangle"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "viTB65K-7GEy"
      },
      "source": [
        "### Task 3\n",
        "Write Python code of a program that reads a number as a year and determines whether it is aleap year or not.\\\n",
        "Three conditions are used to identify leap years:\n",
        "* The year can be evenly divided by 4, is a leap year, unless\n",
        "* The year can be evenly divided by 100, it is NOT a leap year, unless:\n",
        "* The year is also evenly divisible by 400. Then it is a leap year.\\\n",
        "[which implies -\\\n",
        "if the year can be divided by 4 and NOT divided by 100, then it’s a leap year.\n",
        "If the year can be divided by 4, divided by 100, and divided by 400, then it’s a leap year.]\n",
        "\n",
        "For example, the years 2000, 2024, 2028, and 2400 are leap years, while 1800, 1900, 2100, 2200, 2300, and 2500 are NOT leap years.\\\n",
        "*Here, 2000, 2400 are divided by 4, 100, and 400. Thus, leap year.*\\\n",
        "*Here, 2024, 2028 are divided by 4 but not divided by 100. Thus, leap year.*\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input1:**\\\n",
        "2500\\\n",
        "**Sample Output1:**\\\n",
        "Not a leap year\n",
        "\n",
        "**Explanation:**\\\n",
        "Here, 2500 is evenly divisible by 4 and 100. But it is not divisible by 400. So, 2500 is not a leap year.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input2:**\\\n",
        "2024\\\n",
        "**Sample Output2:**\\\n",
        "A leap year\n",
        "\n",
        "**Explanation:**\\\n",
        "Here, 2024 is evenly divisible by 4 but not divisible by 100. So, 2024 is a leap year.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input3:**\\\n",
        "2400\\\n",
        "**Sample Output3:**\\\n",
        "A leap year\n",
        "\n",
        "**Explanation:**\\\n",
        "Here, 2400 is evenly divisible by 4, 100, and 400. So, 2400 is a leap year."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nadX5WnBA3jG"
      },
      "source": [
        "### Task 4\n",
        "Write a python code of a program that reads the values for the three sides x, y, and z of a triangle, and then calculates its area. The area is calculated as follows:\\\n",
        "**Area =  s$\\sqrt{(s-x)(s-y)(s-z)}$**\n",
        "\n",
        "**where $ s = \\frac{x+y+z}{2}$**\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input1:**\\\n",
        "7, 10, 5\\\n",
        "**Sample Output1:**\\\n",
        "53.88877434122991\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input2:**\\\n",
        "7, 9, 12\\\n",
        "**Sample Output2:**\\\n",
        "117.13240371477058\n",
        "\n",
        "====================================================="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k2hK52FhR1tw"
      },
      "source": [
        "# #<font color='blue'>Assignment 2 (Loop)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXeF6x62SBPC"
      },
      "source": [
        "### Task 1\n",
        "\n",
        "Write the python programs, which prints the following sequences of values in loops:\n",
        "\n",
        "a)\t24, 18, 12, 6, 0, -6\\\n",
        "b)\t-10, -5, 0, 5, 10, 15, 20\\\n",
        "c)\t18, 27, 36, 45, 54, 63\\\n",
        "d)\t18, -27, 36, -45, 54, -63\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Hint(1):** You may use a while loop for solving these problems.\n",
        "\n",
        "**Hint(2):** We are already familiar with the print() function. But, when we use it to print any value, it automatically adds an additional newline after each print statement.\n",
        "\n",
        "For example:\\\n",
        "print(1)\\\n",
        "print(2)\n",
        "\n",
        "Output:\\\n",
        "1\\\n",
        "2\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "To solve this problem, in Python3, we can add an extra argument (end = \" \") in the print function which tells the program to skip printing the additional newline.\n",
        "\n",
        "For example:\\\n",
        "print(1, end =\"\")\\\n",
        "print(2)\n",
        "\n",
        "Output: (prints the next output right to the previous one)\\\n",
        "12\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "In Task-1(a), the loop counter may be initialized at 24 and then the loop should terminate when the loop counter reaches -6. The difference between the first two values is 24 - 18 = 6. So the loop counter value is getting decremented by 6 in every iteration for the given sequence here."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Psdde07TIV3",
        "outputId": "eedd4835-5f66-4465-c9e0-9d986b6e8f5b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "24, 18, 12, 6, 0, -6.  \n",
            "-10, -5, 0, 5, 10, 15, 20.  \n",
            "18, 27, 36, 45, 54, 63.  \n",
            "18, -27.  36, -45.  54, -63.  "
          ]
        }
      ],
      "source": [
        "#a\n",
        "for i in range (24,-7,-6):\n",
        "  if i==-6:\n",
        "    print(i, end=\".  \")\n",
        "  else:\n",
        "    print(i, end=\", \")\n",
        "print()\n",
        "# b\n",
        "for i in range(-10, 21, 5):\n",
        "  if i == 20:\n",
        "    print(i, end=\".  \")\n",
        "  else:\n",
        "    print( i, end=\", \")\n",
        "print()\n",
        "#c\n",
        "for i in range(18,64,9):\n",
        "  if i==63:\n",
        "    print(i, end=\".  \")\n",
        "  else:\n",
        "    print(i, end=\", \")\n",
        "print()\n",
        "#d\n",
        "for i in range(18,64,9):\n",
        "  if i%2!=0 or i==-63:\n",
        "    i=i*(-1)\n",
        "    print(i, end=\".  \")\n",
        "  else:\n",
        "    print(i, end=\", \")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CUQYWD94UZmU"
      },
      "source": [
        "### Task 2\n",
        "Write a Python code for the following:\n",
        "\n",
        "1)\tAsk the user to enter the name of his favorite car.\\\n",
        "2)\tAsk the user to enter a Number\n",
        "\n",
        "Display the name of the user’s favorite car, the number of times specified in the second step.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 1:** If the user enters “Toyota” and 2, your program should print the name “Toyota” two times.\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "Toyota\\\n",
        "2\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "Toyota\\\n",
        "Toyota\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 2:** If the user enters “Veyron” and 5, your program should print the name “Veyron” five times.\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "Veyron\\\n",
        "5\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "Veyron\\\n",
        "Veyron\\\n",
        "Veyron\\\n",
        "Veyron\\\n",
        "Veyron"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OQVkeeK3UkD1",
        "outputId": "a5a51908-8b08-452a-d275-863d060492c4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter your favourite car's name: Veyron\n",
            "Enter a number: 5\n",
            "Veyron\n",
            "Veyron\n",
            "Veyron\n",
            "Veyron\n",
            "Veyron\n"
          ]
        }
      ],
      "source": [
        "name= input(\"Enter your favourite car's name: \")\n",
        "num= int(input(\"Enter a number: \"))\n",
        "i=1\n",
        "while i<=num:\n",
        "  print(name)\n",
        "  i=i+1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gk9erSxoUs6G"
      },
      "source": [
        "### Task 3\n",
        "Write the Python code of a program that adds all numbers that are multiples of **both 7 and 9** up to 600 (including 600) i.e. 63, 126, 189, 252, ....\n",
        "\n",
        "**The output of your program should be:** 2835\\\n",
        "since 63 + 126 + 189 + 252 + 315 + 378 + 441 + 504 + 567 = 2835"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G8gw8MejU31m",
        "outputId": "ac769f27-2229-4d06-e13c-5713a5478f3e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2835\n"
          ]
        }
      ],
      "source": [
        "counter= 1\n",
        "sum= 0\n",
        "while counter<=600:\n",
        "  if(counter%7==0 and counter%9==0):\n",
        "   sum= sum + counter\n",
        "  counter+= 1\n",
        "print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "balR8J6cU4eY"
      },
      "source": [
        "### Task 4\n",
        "Write a Python code of a program that adds all numbers that are multiples of **either 7 or 9 but not both**, up to 600 (including 600) i.e. 7, 9, 14, 18, 21..... and so on but not the numbers 63, 126, 189..... which are multiples of both 7 and 9.\n",
        "\n",
        "**The output of your program should be:** 39814"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kaBNU9Z_U8GI",
        "outputId": "d3068280-ce2a-4332-9d5a-655b3d7b74aa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "39814\n"
          ]
        }
      ],
      "source": [
        "sum=0\n",
        "for count in range (1,601):\n",
        "  if (count%7==0 and count%9==0):\n",
        "    continue\n",
        "  elif(count%7==0 or count%9==0):\n",
        "    sum+=count\n",
        "print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k1lZZ3OLVjjg"
      },
      "source": [
        "### Task 5\n",
        "Write the Python code of a program that displays all the **odd numbers** between 10 and 50 (inclusive).\n",
        "\n",
        "**Output:** 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5LpsCe7jVr0X",
        "outputId": "f22a6342-c4cd-4292-e563-a78f5eaaeef1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 "
          ]
        }
      ],
      "source": [
        "for odd in range(11,50,2):\n",
        "  print(odd, end=\" \")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJQ2OPRaV4bh"
      },
      "source": [
        "### Task 6\n",
        "Write a Python code that will calculate the **value of y if the expression** of y is as follows (n is the input):  \n",
        "\n",
        "$y = 1^2 - 2^2 +3^2 -4^2 +5^2 .........+ n^2 $\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "5\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "15\n",
        "\n",
        "**Explanation:** y = 1 - 4 + 9 - 16 + 25 = 15\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "10\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "-55\n",
        "\n",
        "**Explanation:** y = 1 - 4 + 9 - 16 + 25 - 36 + 49 - 64 + 81 - 100 = -55\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "20\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "-210\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aefdOtzcWMlY",
        "outputId": "5810464d-a673-4b1c-ddab-8bc56535027d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 20\n",
            "-210\n"
          ]
        }
      ],
      "source": [
        "s= int(input(\"Enter a number: \"))\n",
        "i=0\n",
        "sum=0\n",
        "while i<=s:\n",
        "  if i%2==0:\n",
        "    sum=sum+(-1*(i**2))\n",
        "    i=i+1\n",
        "  else:\n",
        "    sum=sum+(i**2)\n",
        "    i=i+1\n",
        "print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7WhIQhrJWVqH"
      },
      "source": [
        "### Task 7\n",
        "\n",
        "Write a Python code of a program that asks the user to enter ten numbers and then display the total and the average of **ONLY** the **odd numbers** among those ten numbers.\\\n",
        "<font color='red'>[Please do not use list for this task]</font>\n",
        "\n",
        "==========================================================\n",
        "\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "1\n",
        "\n",
        "2\n",
        "\n",
        "3\n",
        "\n",
        "4\n",
        "\n",
        "5\n",
        "\n",
        "6\n",
        "\n",
        "7\n",
        "\n",
        "8\n",
        "\n",
        "9\n",
        "\n",
        "10\n",
        "\n",
        "**Sample Output 1:**\n",
        "The total of the odd numbers is 25 and their average is 5.0\n",
        "\n",
        "\n",
        "**Explanation:** The total is 1 + 3 + 5 + 7 + 9 = 25 and the average is 25/5 = 5.0\n",
        "\n",
        "==========================================================\n",
        "\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "-20\n",
        "\n",
        "13\n",
        "\n",
        "-5\n",
        "\n",
        "40\n",
        "\n",
        "-17\n",
        "\n",
        "10\n",
        "\n",
        "20\n",
        "\n",
        "-8\n",
        "\n",
        "99\n",
        "  \n",
        "-200\n",
        "\n",
        "**Sample Output 2:**\n",
        "\n",
        "The total of the odd numbers is 90 and their average is 22.5\n",
        "\n",
        "\n",
        "**Explanation:** The total is 90 = 13 + (-5) + (-17) + 99) and their average is 90/4 = 22.5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BLcqk-njWzLt",
        "outputId": "6c602a24-2d9e-4cc2-a852-76e080f5db64"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 1\n",
            "Enter a number: 2\n",
            "Enter a number: 3\n",
            "Enter a number: 4\n",
            "Enter a number: 5\n",
            "Enter a number: 6\n",
            "Enter a number: 7\n",
            "Enter a number: 8\n",
            "Enter a number: 9\n",
            "Enter a number: 10\n",
            "The total of the odd numbers is 25 and their average is  5.0\n"
          ]
        }
      ],
      "source": [
        "sum = 0\n",
        "j= 0\n",
        "for i in range(10):\n",
        "  i= int(input(\"Enter a number: \"))\n",
        "  if i%2!=0:\n",
        "    j+=1\n",
        "    sum+=i\n",
        "print(\"The total of the odd numbers is\",sum, \"and their average is \",sum/j)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Re2dvHrMXZUs"
      },
      "source": [
        "### Task 8\n",
        "Write a Python code for the following:\n",
        "* Ask the user to enter a Number, N\n",
        "* Display the summation of multiples of 7 up to that number (**from 1 to N inclusive**)\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "50\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "196\n",
        "\n",
        "**Explanation:** The summation of multiples of 7 up to 50 is 7 + 14 + 21 + 28 + 35 + 42 + 49 = 196\n",
        "\n",
        "==========================================================\n",
        "\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "75\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "385\n",
        "\n",
        "**Explanation:** The summation of multiples of 7 up to 75 is 7 + 14 + 21 + 28 + 35 + 42 + 49 + 56 + 63 + 70 = 385\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "INhtjcprXjqO",
        "outputId": "b7120029-0f79-486a-e5fa-bcc4f791b3e3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a value for N: 50\n",
            "196\n"
          ]
        }
      ],
      "source": [
        "n = int(input(\"Enter a value for N: \"))\n",
        "sum= 0\n",
        "for number in range(0,n):\n",
        "  if( number%7==0):\n",
        "    sum+=number\n",
        "print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xj6DLV4WXptk"
      },
      "source": [
        "### Task 9\n",
        "Write a Python code that will read 5 numbers from the user. Your program should print the first number, the sum of the first 2 numbers, the sum of the first 3 numbers, and so on up to the sum of 5 numbers.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "1\\\n",
        "2\\\n",
        "3\\\n",
        "4\\\n",
        "5\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "1\\\n",
        "3\\\n",
        "6\\\n",
        "10\\\n",
        "15\n",
        "\n",
        "**Explanation:**\\\n",
        "When the user enters 1 at first, we print 1, then \\\n",
        "The user enters 2, (1 + 2) = 3, so our output is 3, then \\\n",
        "The user enters 3, (3 + 3) = 6, hence our output is 6, then \\\n",
        "The user enters 4, and we have (6 + 4) = 10, we print 10, and finally\\\n",
        "The user enters 5, the final sum is 15 which is printed as the last output.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "11\\\n",
        "-29\\\n",
        "-3\\\n",
        "47\\\n",
        "50\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "11\\\n",
        "-18\\\n",
        "-21\\\n",
        "26\\\n",
        "76\n",
        "\n",
        "**Explanation:**\\\n",
        "When the user enters 11 at first, we print 11, then \\\n",
        "The user enters -29, (11 + (-29)) = -18, so our output is -18, then \\\n",
        "The user enters -3, (-18 - 3) = -21, hence our output is -21, then \\\n",
        "The user enters 4, and we have (-21 + 47) = 26, we print 26, and finally\\\n",
        "The user enters 50, the final sum is (26 + 50) = 76 which is printed as the last output."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DZ79BbF8YHhc",
        "outputId": "662c08bf-17d8-46c2-9d09-4e60d160aef9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 11\n",
            "11\n",
            "Enter a number: -29\n",
            "-18\n",
            "Enter a number: -3\n",
            "-21\n",
            "Enter a number: 47\n",
            "26\n",
            "Enter a number: 50\n",
            "76\n"
          ]
        }
      ],
      "source": [
        "sum=0\n",
        "for i in range (1, 6):\n",
        "  u= int(input(\"Enter a number: \"))\n",
        "  sum= sum+u\n",
        "  print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-DMybJoYbJN"
      },
      "source": [
        "### Task 10\n",
        "Write a Python program which takes a number and prints the digits from the unit place, then the tenth, then hundredth, etc. <font color='red'>(Right to Left)</font>\n",
        "\n",
        "<font color='red'>[Consider the input number to be an INTEGER. You are not allowed to use String indexing for solving this task]</font>\n",
        "\n",
        "**Example:**\n",
        "\n",
        "If the user gives 32768,\n",
        "\n",
        "then print 8, 6, 7, 2, 3\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Hint (1):**  The input() function, converts the input data to String data type by default. Therefore, please type cast it to an integer before proceeding further.\n",
        "\n",
        "\n",
        "**Hint  (2):** First to get the digit from the right side, we can take the remainder of the number using modulus (%) operator i.e. mod 10 to get the rightmost digit and print it. For dropping the last digit, we can perform floor division by 10 on the number and then continue the same to print the other digits as shown below.\n",
        "\n",
        "32768 % 10 = 8\n",
        "\n",
        "32768 // 10 = 3276\n",
        "\n",
        "Then,\n",
        "\n",
        "3276 % 10 = 6\n",
        "\n",
        "3276 // 10 = 327\n",
        "\n",
        "and so on\n",
        "\n",
        "327 % 10 = 7\n",
        "\n",
        "327 // 10 = 32\n",
        "\n",
        "32 % 10 = 2\n",
        "\n",
        "32 // 10 = 3\n",
        "\n",
        "3 % 10 = 3\n",
        "\n",
        "3 // 10 = 0\n",
        "\n",
        "Done! When the number becomes 0 you can end your loop."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gGpehyb5YxHz",
        "outputId": "2782d8bc-d1e5-45f6-e12b-db2b3a5b1a0e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 32768\n",
            "8, 6, 7, 2, 3 "
          ]
        }
      ],
      "source": [
        "inp=(input(\"Enter a number: \"))\n",
        "i= int(inp)\n",
        "while i>0:\n",
        "  rem=i%10\n",
        "  if i//10==0:\n",
        "    print(rem, end=\" \")\n",
        "    i=i//10\n",
        "  else:\n",
        "    i=i//10\n",
        "    print(rem, end=\", \")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qPwcd9aFZAmO"
      },
      "source": [
        "### Task 11\n",
        "\n",
        "Write a Python program that takes a number and prints how many digits are in that number. \\\n",
        "<font color='red'>[Consider the input number to be an INTEGER.]</font>\n",
        "\n",
        "<font color='red'>[You are not allowed to use len() function]</font>\n",
        "\n",
        "**Example:**\n",
        "\n",
        "If the user gives 9876,\n",
        "\n",
        "your program should print 4.\n",
        "\n",
        "==============================================================================\n",
        "\n",
        "**Hint:** We may keep floor dividing by ten and count how many times this can be done until the number becomes 0 as illustrated below.\n",
        "\n",
        "9876 // 10 = 987, count = 1 \\\n",
        "then, 987 // 10 = 98, count = 2 \\\n",
        "98 // 10 = 9, count = 3 \\\n",
        "9 // 10 = 0, count = 4\n",
        "\n",
        "Done! When the number becomes 0 your loop can end giving you the count of digits, in this case for our input of 9876, 4 digits.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wFQbm8NCZfIA",
        "outputId": "78b29c80-5ab7-4062-8c3b-a23b89de4811"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 9876\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "n = int(input(\"Enter a number: \"))\n",
        "c = 0\n",
        "while(n!= 0):\n",
        "    n = n // 10\n",
        "    c += 1\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zLojYC5lbLm8"
      },
      "source": [
        "### Task 12\n",
        "Write a Python program that takes a number from the user and prints its digits from  <font color='red'> left to right. </font>\n",
        "\n",
        "<font color='red'>[Consider the input number to be an INTEGER. You are not allowed to use String indexing for solving this task]</font>\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Example:** if the user gives 32768, then print 3, 2, 7, 6, 8\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Hint(1):**  The input() function takes the input data as String data type by default. Please convert it to an integer before starting your code for the task.\n",
        "\n",
        "**Hint(2):**  \n",
        "\n",
        "Step 1: First, count how many digits\\\n",
        "Step 2: Then, calculate 10 to the power (number of digits - 1).\n",
        "\n",
        "Step 3 with explanation: Say, the input given by the user as in our example, 32768 has 5 digits, so calculating 10 to the power 4 gives us 10000. Then floor dividing 32768 by 10000, we can get 3.\\\n",
        "Proceeding further, the remainder of 32768 by 10000 (32768 % 10000) gives us 2768. This time to get 2 we need to floor divide 2768 by 1000 which is basically our 10000/10. Again, taking remainder of 2768 by 1000 gives us 768 which we then divide by 100 (i.e. 1000/10) and keep on doing this until there are no more digits left (zero).\n",
        "\n",
        "\n",
        "**To summarize and clarify:**\\\n",
        "Loop 1: First, we count digits like our Task 12, say 5 in this case for 32768\\\n",
        "Loop 2: Then, we calculate 10 to the power 4 (5-1), that is 10000.\\\n",
        "Loop 3: Then we keep repeating the three steps of floor dividing, modulus and dividing by 10 as demonstrated below.\n",
        "\n",
        "32768 // 10000 = 3\\\n",
        "32768 % 10000 = 2768 \\\n",
        "10000 // 10 = 1000\n",
        "\n",
        "2768 // 1000 = 2\\\n",
        "2768 % 1000 = 768\\\n",
        "1000 // 10 = 100\n",
        "\n",
        "768 // 100 = 7\\\n",
        "768 % 100 = 68 \\\n",
        "100 // 10 = 10\n",
        "\n",
        "68 // 10 = 6\\\n",
        "68 % 10 = 8 \\\n",
        "10 // 10 = 1\n",
        "\n",
        "8 // 1 = 8\\\n",
        "8 % 1 = 0 \\\n",
        "1 // 10 = 0\n",
        "\n",
        "Done. Loop ends as number has become 0."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u229tD_Ebd59",
        "outputId": "bcb7b557-7fc9-403c-c4df-30914774ca88"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 32768\n",
            "3,2,7,6,8"
          ]
        }
      ],
      "source": [
        "value=int(input(\"Enter a number: \"))\n",
        "counting=0\n",
        "store=value\n",
        "while value>0:\n",
        "    value=value//10\n",
        "    counting=counting+1\n",
        "div=10**(counting-1)\n",
        "koma=0\n",
        "while store>0:\n",
        "    koma+=1\n",
        "    temp=store//div\n",
        "    if koma<counting:\n",
        "        print(temp, end=\",\")\n",
        "    else:\n",
        "        print(temp, end=\"\")\n",
        "    store=store%div\n",
        "    div=div//10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cMbEfBV6dWPj"
      },
      "source": [
        "### Task 13\n",
        "\n",
        "Write a Python program that takes a number as input from the user and prints the divisors of that number as well as how many divisors the number has.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "6\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "1, 2, 3, 6 \\\n",
        "Total 4 divisors.\n",
        "\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "121\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "1, 11, 121 \\\n",
        "Total 3 divisors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3HVpyC7kdXrb",
        "outputId": "2bc87fc0-78bf-48a5-e8b2-4f5f9f13b739"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number: 6\n",
            "1 2 3 6 \n",
            "Total divisor is 4\n"
          ]
        }
      ],
      "source": [
        "n =int(input(\"Enter the number: \"))\n",
        "c = 0\n",
        "for i in range(1,n+1):\n",
        "    if n%i==0:\n",
        "      c+=1\n",
        "      print(i, end=\" \")\n",
        "print(\"\\nTotal divisor is\",c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KwDWyyB1dYE8"
      },
      "source": [
        "### Task 14\n",
        "Write a Python program that takes a number as input from the user and tells if it is a perfect number or not.\n",
        "\n",
        "**Perfect Number:** An integer number is said to be a perfect number if its factors, including 1 but not the number itself, sum to the number.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "6\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "6 is a perfect number\n",
        "\n",
        "**Explanation:**\\\n",
        "6 has 4 divisors: 1, 2, 3, and 6. \\\n",
        "If we add all factors except 6 itself, 1 + 2 + 3 = 6. The sum of the factors excluding the number itself sum up to the number therefore \"6 is a perfect number\" is printed.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "28\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "28 is a perfect number\n",
        "\n",
        "**Explanation:**\\\n",
        "28 has the divisors: 1, 2, 4, 7, 14, and 28. \\\n",
        "If we add all factors except itself we get 28, 1 + 2 + 4 + 7 + 14 = 28.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "33\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "33 is not a perfect number\n",
        "\n",
        "**Explanation:**\\\n",
        "33 has 4 divisors: 1, 3, 11, and 33. \\\n",
        "If we add all factors except itself, 15 = 1 + 3 + 11. The sum is not equal to the number, therefore 33 is not a perfect number.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P36W_11vddTL",
        "outputId": "1fc0baed-89a3-4d87-e7af-98c8e50fa901"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number: 28\n",
            "28 is a perfect number\n"
          ]
        }
      ],
      "source": [
        "number = int (input(\"Enter the number: \"))\n",
        "sum = 0\n",
        "for count in range(1,number+1):\n",
        "  if number%count == 0:\n",
        "    if number!=count:\n",
        "      sum+=count\n",
        "if(sum==number):\n",
        "  print(number,\"is a perfect number\")\n",
        "else:\n",
        "  print(number,\"is not a perfect\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hE7Q-g-2dduj"
      },
      "source": [
        "### Task 15\n",
        "\n",
        "Write a Python program that asks the user for one number and tells if it is a prime number or not.\n",
        "\n",
        "**Prime Number:** If a number has only two divisors, (1 and itself), then it is a prime number. If it is divisible by more numbers, then it is not a prime.\n",
        "\n",
        "**Hint:** You may use the code for counting divisors from Task 14.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "11\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "11 is a prime number\n",
        "\n",
        "**Explanation:** 11 has only 2 divisors: 1 and 11.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "6\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "6 is not a prime number\n",
        "\n",
        "**Explanation:** 6 has 4 divisors: 1, 2, 3 and 6."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yIAwgquidmhw",
        "outputId": "5483779e-6a61-46b6-acc0-6e0008cdf8b2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number: 6\n",
            "6 is not a prime number\n"
          ]
        }
      ],
      "source": [
        "number=int(input(\"Enter the number: \"))\n",
        "i = 0\n",
        "for count in range(1,number+1):\n",
        "  if number%count==0:\n",
        "    i+=1\n",
        "if(i>2):\n",
        "  print(number,\"is not a prime number\")\n",
        "else:\n",
        "  print(number,\"is a prime number\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_f1F8C1mdmtS"
      },
      "source": [
        "### Task 16\n",
        "\n",
        "Write a Python program that asks the user for a quantity, then takes that many numbers as input and prints the maximum, minimum and average of those numbers.\n",
        "\n",
        "<font color='red'>[Please note that you CANNOT use max, min built-in functions]\n",
        "\n",
        "[Also, you DO NOT need to use lists for this task]</font>\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example:** If the user enters 5 as an input for quantity and the enters the 5 numbers, 10, 4, -1, -100, and 1. \\\n",
        "The output of your program should be: “Maximum 10”, “Minimum -100”, “Average is -17.2” as shown below.\n",
        "\n",
        "**Input:**\\\n",
        "5\n",
        "10\n",
        "4\n",
        "-1\n",
        "-100\n",
        "1\n",
        "\n",
        "**Output:**\\\n",
        "Maximum 10\\\n",
        "Minimum -100\\\n",
        "Average is -17.2\n",
        "\n",
        "**Explanation:** Average calculation: (10 + 4 + (-1) + (-100) + 1)/5 = -86/5 = -17.2\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "krbOg06gdtdt",
        "outputId": "ff66b90a-7a41-4d73-a4a8-81711408d0d1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "numbers to enter: 5\n",
            "Enter the numbers: \n",
            "10\n",
            "4\n",
            "-1\n",
            "-100\n",
            "1\n",
            "Maximum 10\n",
            "Minimum -100\n",
            "Average is -17.2\n"
          ]
        }
      ],
      "source": [
        "n = int(input(\"numbers to enter: \"))\n",
        "print(\"Enter the numbers: \")\n",
        "u = int(input())\n",
        "sum = u\n",
        "maximum= u\n",
        "minimum= u\n",
        "for count in range(n - 1):\n",
        "    u = int(input())\n",
        "    sum = sum + u\n",
        "    if ( u> maximum):\n",
        "        maximum = u\n",
        "    elif (u < minimum):\n",
        "        minimum = u\n",
        "avg = sum / n\n",
        "print(\"Maximum\", maximum)\n",
        "print(\"Minimum\", minimum)\n",
        "print(\"Average is\", avg)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XoYd79V4dtx4"
      },
      "source": [
        "### Task 17\n",
        "\n",
        "Write a python program that prints a square of size N using + where N will be given as input as illustrated in the examples below.\n",
        "\n",
        "**Hint:** You may need to use nested loops to solve this problem.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\n",
        "\n",
        "5\n",
        "\n",
        "**Sample Output 1:**<br>\n",
        "+++++<br>\n",
        "+++++<br>\n",
        "+++++<br>\n",
        "+++++<br>\n",
        "+++++<br>\n",
        "\n",
        "**Explanation:** Here, we may see it as 5 rows and 5 columns, where in each horizontal row/line, 5 '+' is printed next to each other and we have a total of 5 lines.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\n",
        "\n",
        "3\n",
        "\n",
        "**Sample Output 2:**<br>\n",
        "+++<br>\n",
        "+++<br>\n",
        "+++<br>\n",
        "\n",
        "**Explanation:** If the input is 3, then there will be 3 rows and 3 columns, where in each horizontal row/line, '+' is printed 3 times, 1 in each of the 3 columns and we will have a total of 3 lines."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zEPqAY_hd8vZ",
        "outputId": "22a6809f-e342-4226-c891-d74c27262482"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the N value: 3\n",
            "+++\n",
            "+++\n",
            "+++\n"
          ]
        }
      ],
      "source": [
        "size_N =int(input(\"Enter the N value: \"))\n",
        "for row in range(1,size_N+1):\n",
        "  for column in range(1,size_N+1):\n",
        "    print(\"+\",end=\"\")\n",
        "  print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhSITerod9HZ"
      },
      "source": [
        "### Task 18\n",
        "\n",
        "Write a python program that prints a rectangle of size M (height/line numbers) and N (length/column numbers) using incrementing numbers where M and N will be given as input. Please look at the examples below for clarification.\n",
        "\n",
        "**Hint:** You may need to use nested loops and print the loop counter variable in one of the loops.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "4\\\n",
        "6\n",
        "\n",
        "**Sample Output 1:**<br>\n",
        "123456<br>\n",
        "123456<br>\n",
        "123456<br>\n",
        "123456<br>\n",
        "\n",
        "**Explanation:** The user has given 4 rows/lines and 6 columns as input. Therefore, we have 4 lines in our output here and in each line, the column number is printed from 1 through to 6 for the 6 columns.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "3\\\n",
        "2\n",
        "\n",
        "**Sample Output 2:**<br>\n",
        "12<br>\n",
        "12<br>\n",
        "12<br>\n",
        "\n",
        "**Explanation:** Our user input this time is 3 rows/lines and 2 columns. So, our output has 3 lines and in each line, the column number 1 and 2 are printed next to each other as the user only wants 2 columns here.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VOZ6-TfYeIu5",
        "outputId": "14f5bcbb-311c-44ef-dec4-857ff1965329"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4\n",
            "6\n",
            "123456\n",
            "123456\n",
            "123456\n",
            "123456\n"
          ]
        }
      ],
      "source": [
        "row =int(input())\n",
        "column =int(input())\n",
        "for row_count in range(1,row+1):\n",
        "  for column_count in range(1,column+1):\n",
        "    print(column_count, end=\"\")\n",
        "  print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bv332Ht5eI7C"
      },
      "source": [
        "### Task 19\n",
        "\n",
        "Write a python program that prints a right angled triangle of height N using incrementing numbers where N will be given as input.\n",
        "\n",
        "**Hint:** You may need to use nested loops. Try to think up to which point should the inner loop run.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "4\n",
        "\n",
        "**Sample Output 1:**<br>\n",
        "1<br>\n",
        "12<br>\n",
        "123<br>\n",
        "1234<br>\n",
        "\n",
        "**Explanation:** For an input of 4, we have 4 rows/lines where in each line, the respective column number is printed sequentially up to the line/row number. So, in line number 1, we have 1 only. In line 2, 12 is printed. In line 3, we have 123 and so on.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "5\n",
        "\n",
        "**Sample Output 2:**<br>\n",
        "1<br>\n",
        "12<br>\n",
        "123<br>\n",
        "1234<br>\n",
        "12345<br>\n",
        "\n",
        "**Explanation:** Numbers are printed sequentially up to the line number for each of the lines."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0lSl-q8CeQ9c",
        "outputId": "0c46911a-97fd-4886-cb6d-4ced215da670"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the n value: 5\n",
            "1\n",
            "12\n",
            "123\n",
            "1234\n",
            "12345\n"
          ]
        }
      ],
      "source": [
        "size = int(input(\"Enter the n value: \"))\n",
        "for row in range(1,size+1):\n",
        "  for coloum in range(1,row+1):\n",
        "    print(coloum,end='')\n",
        "  print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OqYue-MBed1F"
      },
      "source": [
        "# <font color='purple'> Task 20 to Task 24 are [ Tracing ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33nfVn4DeSbE"
      },
      "source": [
        "### Task 25\n",
        "\n",
        "Write a python program that prints all the fibonacci numbers from 0 to N where N will be given as input by the user.\n",
        "\n",
        "**A Fibonacci number is a number which is the summation of its previous two fibonacci numbers.**\n",
        "\n",
        "The first two fibonacci numbers are 0 and 1.\n",
        "\n",
        "So, the 3rd is 0 + 1 = 1,\n",
        "\n",
        "the 4th is 1 + 1 = 2,\n",
        "\n",
        "the 5th is 1 + 2 = 3,\n",
        "\n",
        "the 6th one is 2 + 3 = 5,\n",
        "\n",
        "and so on.\n",
        "\n",
        "i.e. 0, 1, 1, 2, 3, 5, 8, 13, 21.......\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 1:**<br>\n",
        "10\n",
        "\n",
        "**Sample Output 1:**<br>\n",
        "0 1 1 2 3 5 8\n",
        "\n",
        "**Explanation**: All fibonacci numbers up to the number 10 is printed separated by spaces.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input 2:**<br>\n",
        "15\n",
        "\n",
        "**Sample Output 2:**<br>\n",
        "0 1 1 2 3 5 8 13\n",
        "\n",
        "**Explanation**: All fibonacci numbers up to the number 15 is printed separated by spaces."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0qENCQ7r-kIU",
        "outputId": "5100998d-935d-4f5e-d9b5-7817a37165f8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number: 10\n",
            "0 1 1 2 3 5 8 "
          ]
        }
      ],
      "source": [
        "n =int(input(\"Enter the number: \"))\n",
        "i1= 0\n",
        "i2= 1\n",
        "sum=0\n",
        "for j in range(0,n):\n",
        "  if sum<n:\n",
        "    print(sum, end=\" \")\n",
        "    i1=i2 #i1=1,0,1,\n",
        "    i2=sum #i2=0,1,1\n",
        "    sum= i1+i2 #sum=1+0=1, 0+1=1, 1+1=2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0AEuJVP8e6jw"
      },
      "source": [
        "### Task 26\n",
        "\n",
        "Write a python program that converts a decimal integer number to a binary number.\n",
        "\n",
        "*Hint: A decimal can be converted to a binary number by keeping track of the remainders after each division of that number by 2.*\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "For example, to convert 11 to a binary number, we can try the following approach.\n",
        "\n",
        "11 // 2 = 5 (Remainder 1)\n",
        "<br>5 // 2 = 2 (Remainder 1)\n",
        "<br>2 // 2 = 1 (Remainder 0)\n",
        "<br>1 // 2 = 0 (Remainder 1)\n",
        "\n",
        "Now, taking the remainders from bottom to top gives us the binary number which is 1011. Binary of 11 is 1011.\n",
        "\n",
        "**Sample Input 1:** <br>\n",
        "11\n",
        "\n",
        "**Sample Output 1:**<br>\n",
        "1101\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Similarly, to convert 13 to a binary number:\n",
        "\n",
        "13 // 2 = 6 (Remainder 1)\n",
        "<br>6 // 2 = 3 (Remainder 0)\n",
        "<br>3 // 2 = 1 (Remainder 1)\n",
        "<br>1 // 2 = 0 (Remainder 1)\n",
        "\n",
        "Again, taking the remainders from the bottom to top, which is 1101 gives us the binary number. Binary of 13 is 1101.\n",
        "\n",
        "**Sample Input 2:** <br>\n",
        "13\n",
        "\n",
        "**Sample Output 2:**<br>\n",
        "1011"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d9G4gDi1MMTk",
        "outputId": "34830b21-c1c1-4ec1-dae2-fbf2bc9a5acd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a decimal number: 13\n",
            "1011"
          ]
        }
      ],
      "source": [
        "n=int(input(\"Enter a decimal number: \"))\n",
        "while n>0:\n",
        "  print(n%2, end=\"\")\n",
        "  n=n//2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XmQoqK1wfC17"
      },
      "source": [
        "### Task 27\n",
        "\n",
        "Write a python program that converts a binary number to a decimal integer number after taking the binary number as an input from the user.\n",
        "\n",
        "**Note: A binary number can be converted to its corresponding decimal number by multiplying each binary digit with a power of 2, where the power denotes the position of the binary digit**\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "For example, to convert 1010 to decimal, we can do this\n",
        "\n",
        "\n",
        "$2^{3}$ x 1 + $2^{2}$ x 0 + $2^{1}$ x 1 + $2^{0}$ x 0 = 10\n",
        "\n",
        "\n",
        "**Sample Input 1:** <br>\n",
        "1010\n",
        "\n",
        "**Sample Output 1:** <br>\n",
        "10\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "So, to convert 11101, we can do this\n",
        "\n",
        "\n",
        "$2^{4}$ x 1 + $2^{3}$ x 1 + $2^{2}$ x 1 + $2^{1}$ x 0 + $2^{0}$ x 1 = 29\n",
        "\n",
        "\n",
        "**Sample Input 2:** <br>\n",
        "11101\n",
        "\n",
        "**Sample Output 2:** <br>\n",
        "29"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DhwZuudiSu7N",
        "outputId": "47729561-4c9a-4689-afbc-0135dc5ddb08"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a Binary Number: 11101\n",
            "29\n"
          ]
        }
      ],
      "source": [
        "n=int(input(\"Enter a Binary Number: \"))\n",
        "d=0\n",
        "m=1\n",
        "u=len(str(n))\n",
        "for i in range(u):\n",
        "  r=n%10\n",
        "  d=d+(r*m)\n",
        "  m=m*2\n",
        "  n=int(n/10)\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "52gvgASKfMdw"
      },
      "source": [
        "### Task 28\n",
        "Write a Python program that asks the user for a range (a starting number and an ending number) and then\n",
        "**counts** how many numbers are prime numbers and how many numbers are perfect numbers between that range. It also **prints** those numbers in the format shown in the output of the example given below.\n",
        "\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Hint (1):** We may declare two strings/lists to store the prime and perfect numbers. Inside the loop, we check for prime and perfect numbers and add them to respective string/list besides counting them.\n",
        "\n",
        "**Hint (2):** We may need to convert numbers in String to integers for checking and calculations. We may again need to convert numbers to Strings for storing and printing as the outputs shown in the example below.\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Example:** If the user gives us a range of between 2 and 6, there are 3 prime numbers (2, 3, 5) and 1 perfect number (6) in that range.\n",
        "\n",
        "**Input:**\\\n",
        "2\\\n",
        "6\n",
        "\n",
        "**Output:**\\\n",
        "Between 2 and 6,\\\n",
        "Found 3 prime numbers \\\n",
        "Found 1 perfect number\\\n",
        "Prime numbers: 2,  3,  5 \\\n",
        "Perfect number: 6\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "meU_NxE_YiAb",
        "outputId": "3a689dc1-f72a-46ff-b162-5b52281a2889"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Please, Enter the Lowest Range Value: 2\n",
            "Please, Enter the Upper Range Value: 6\n",
            "The Prime Numbers in the range are: \n",
            "2\n",
            "3\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "lower_value = int(input (\"Please, Enter the Lowest Range Value: \"))\n",
        "upper_value = int(input (\"Please, Enter the Upper Range Value: \"))\n",
        "print (\"The Prime Numbers in the range are: \")\n",
        "for number in range (lower_value, upper_value + 1):\n",
        "    if number > 1:\n",
        "        for i in range (2, number):\n",
        "            if (number % i) == 0:\n",
        "                break\n",
        "        else:\n",
        "            print (number)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0pJvgyB5fW2Q"
      },
      "source": [
        "###Task 29\n",
        "\n",
        "Write a python program that asks the user for a range, a starting number(inclusive) and an ending number (inclusive). Then, take another input to for checking. If the product of all the digits of each number in the range is divisible by the third input, then print the number.\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "25\\\n",
        "30\\\n",
        "4\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "12 16 0\n",
        "\n",
        "**Explanation:** The product of all the digits of each number from 25 to 30 are 2 x 5, 2 x 6, 2 x 7, 2 x 8, 2 x 9 and 3 x 0. The final products are 10, 12, 14, 16, 18 and 0 respectively. Out of these numbers only 12, 16 and 0 are divisible by the third input 4 and therefore they are printed.\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "351\\\n",
        "356\\\n",
        "9\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "45 90\n",
        "\n",
        "**Explanation:** The product of all the digits of each number from 351 to 356 are 3x5x1, 3x5x2, 3x5x3, 3x5x4, 3x5x5 and 3x5x6. The final products are 15, 30, 45, 60, 75 and 90 respectively. Out of these numbers only 45 and 90 are divisible by 9 and therefore they are printed.\n",
        "\n",
        "========================================================================="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tSHmNCY4fep-"
      },
      "source": [
        "# #<font color='blue'>Assignment 3 (String)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bNoypiTBWqt"
      },
      "source": [
        "### Task 1\n",
        "\n",
        "Write a Python program that takes a String as an input from the user and prints that String in **reverse** order.\n",
        "\n",
        "**<font color='red'>You cannot use the built-in reverse() function for this task.**\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        " CSE110\n",
        "\n",
        "**Sample Output 1:**\\\n",
        " 011ESC\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "Python\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "nohtyP\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "1576527  \n",
        "\n",
        "**Sample Output 3:**\\\n",
        "7256751\n",
        "\n",
        "====================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lKnktPMi2dp7",
        "outputId": "aa6d34a0-a2af-4366-cb58-d7a7f2c4c2a3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a sting: Python\n",
            "nohtyP\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter a sting: \")\n",
        "print(n[::-1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zI6tmFN0i4y"
      },
      "source": [
        "### Task 2\n",
        "\n",
        "Write a python program that takes 2 inputs from the user, where the first input is a string with length greater than 1. The second input is the index of the first given string from where you have to start reversing. After reversing the first input string from that index, print the new string back to the user. See samples below for clarification.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1:**\n",
        "\n",
        "72418\n",
        "\n",
        "4\n",
        "\n",
        "**Sample Output 1:**\n",
        "\n",
        "81427\n",
        "\n",
        "\n",
        "**Explanation**: Our second input, index '4' is the last index of our first input String '72418', hence the entire string is reversed giving us '81427'.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2:**\n",
        "\n",
        "12345\n",
        "\n",
        "2\n",
        "\n",
        "**Sample Output 2:**\n",
        "\n",
        "32145\n",
        "\n",
        "**Explanation**: The second input is '2' so we have to reverse from index 2 of our first input. The 2nd index of our first input String is '3', index 1 is '2' and index 0 is '1'. Hence, if we reverse indexes 0 to 2, we get '321'. Index 3 and 4 which is '4' and '5' respectively remains unchanged hence our final output is '32145'.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 3:**\n",
        "\n",
        "aBcd1234defg\n",
        "\n",
        "5\n",
        "\n",
        "**Sample Output 3:**\n",
        "\n",
        "21dcBa34defg\n",
        "\n",
        "**Explanation**: From our first input String 'aBcd1234defg',\n",
        "\n",
        "index 0 = 'a'\n",
        "\n",
        "index 1 = 'B'\n",
        "\n",
        "index 2 = 'c'\n",
        "\n",
        "index 3 = 'd'\n",
        "\n",
        "index 4 = '1'\n",
        "\n",
        "index 5 = '2'\n",
        "\n",
        "index 6 = '3'\n",
        "\n",
        "Since our second input is 5, index 0 to index 5 is reversed and we have '21dcBa' and the rest is unchanged from indexes 6 to 11 ('34defg'). Therefore, we have '21dcBa34defg' finally.\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "go2WcY5i2n_F",
        "outputId": "f734099e-b45c-4dcf-9239-5c152b976cc3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter String: aBcd1234defg\n",
            "Enter number: 5\n",
            "21dcBa34defg\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter String: \")\n",
        "i=int(input(\"Enter number: \"))\n",
        "print(n[i::-1]+n[i+1::1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pkTyiploC6gC"
      },
      "source": [
        "### Task 3\n",
        "Write a program that takes a **string** as input and prints “Binary Number” if the string contains only 0s or 1s. Otherwise, print “Not a Binary Number”.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "01101101101\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "Binary Number\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "12344ab0\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "Not a Binary Number\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "10127490111\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "Not a Binary Number\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 4:**\\\n",
        "Binary Number\n",
        "\n",
        "**Sample Output 4:**\\\n",
        "Not a Binary Number\n",
        "\n",
        "====================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DjTV5kx5DslT",
        "outputId": "8ea72cfa-8a86-40b4-dd7a-20a4e75dabd1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: 12344ab0\n",
            "Not a Binary Number\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter a string: \")\n",
        "for i in n:\n",
        "  if i!='0' and i!='1':\n",
        "    print(\"Not a Binary Number\")\n",
        "    break\n",
        "else:\n",
        "  print(\"Binary Number\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pbdeIVcyU1yi"
      },
      "source": [
        "### Task 4\n",
        "\n",
        "Write a Python program that will ask the user to enter a  word as an input.\n",
        "\n",
        "* If the length of the input string is less than 4, then your program should print the same string as an output.\n",
        "* If the input string’s length is greater than 3, then your program should add \"er\" at the end of the input string.\n",
        "* If the input string already ends with \"er\", then add \"est\" instead, regardless of the length of the input string\n",
        "* If the input string already ends with \"est\", then your program should print the same input string as an output.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1**:\\\n",
        "strong\n",
        "\n",
        "**Sample Output 1**:\\\n",
        "stronger\n",
        "\n",
        "**Explanation**: Length of input = 6, not less than 4, greater than 3, does not end with \"er\" or \"est\", therefore \"er\" is added making \"strong\", \"stronger\".\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\\\n",
        "stronger\n",
        "\n",
        "**Sample Output 2**:\\\n",
        "strongest\n",
        "\n",
        "**Explanation**: Input string ends with \"er\", therefore \"er\" is replaced with \"est\" instead so we have \"strongest\" from \"stronger\".\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 3**:\\\n",
        "strongest\n",
        "\n",
        "**Sample Output 3**:\\\n",
        "strongest\n",
        "\n",
        "**Explanation**: Our input here already ends with \"est\" so the same input i.e. \"strongest\" is printed.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 4**:\\\n",
        "abc\n",
        "\n",
        "**Sample Output 4**:\\\n",
        "abc\n",
        "\n",
        "**Explanation**: Since length of input string is less than 4, the given input is printed as output.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 5**:\\\n",
        "ber\n",
        "\n",
        "**Sample Output 5**:\\\n",
        "best\n",
        "\n",
        "**Explanation**: Although the length of the input string is 3 which is less than 4, but it ends with er so we ignore the length and replace \"er\" with \"est\" regardless.\n",
        "\n",
        "====================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QmXzlDie3PDN",
        "outputId": "37051d06-2931-4d78-d407-1417a787dadd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: ber\n",
            "best\n"
          ]
        }
      ],
      "source": [
        "i = input(\"Enter a string: \")\n",
        "if(len(i)<4):\n",
        "    if i.endswith(\"er\"):\n",
        "        o = i[0:1] + \"est\"\n",
        "        print(o)\n",
        "    else:\n",
        "        o = i\n",
        "        print(o)\n",
        "elif(len(i)>3):\n",
        "    if not i.endswith(\"er\") and not i.endswith(\"est\"):\n",
        "        o = i+\"er\"\n",
        "        print(o)\n",
        "    if i.endswith(\"er\"):\n",
        "        o = i[0:-2]+\"est\"\n",
        "        print(o)\n",
        "    elif i.endswith(\"est\"):\n",
        "        o = i\n",
        "        print(o)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KD4EKJf6U1yQ"
      },
      "source": [
        "\n",
        "### Task 5\n",
        "\n",
        "Write a Python program that will ask the user to input a string (containing exactly one word). Then your program should print subsequent substrings of the given string as shown in the examples below.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Hints(1):** You may use \"for loop\" for this task.\n",
        "\n",
        "**Hints(2):** You may use print() function for printing newlines.\n",
        "\n",
        "For example:\\\n",
        "print(1)\\\n",
        "print(2)\n",
        "\n",
        "Output:\\\n",
        "1\\\n",
        "2\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "We can use print(end = \"\") to skip printing the additional newline.\n",
        "\n",
        "For example:\\\n",
        "print(1, end =\"\")\\\n",
        "print(2)\n",
        "\n",
        "Output:(prints the following output right next to the previous one)\\\n",
        "12\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1**:\\\n",
        "BANGLA\n",
        "\n",
        "**Sample Output 1**:\\\n",
        "B\\\n",
        "BA\\\n",
        "BAN\\\n",
        "BANG\\\n",
        "BANGL\\\n",
        "BANGLA\n",
        "\n",
        "**Explanation**: The length of the string is 6 so there are 6 lines where in each line a substring of the input string, of length equal to the line number is printed i.e. substring with only the letter \"B\" printed in the first line, substring \"BA\" of length 2 printed in the 2nd line, \"BAN\" length of which is 3 being printed in the 3rd line and so on.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\\\n",
        "DREAM\n",
        "\n",
        "**Sample Output 2**:\\\n",
        "D\\\n",
        "DR\\\n",
        "DRE\\\n",
        "DREA\\\n",
        "DREAM\n",
        "\n",
        "**Explanation**: Simply, no of lines = length of the input string and no of letters in each line = line number.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P3OTR4633brx",
        "outputId": "3f96b464-f1c2-4e4c-a8c1-bdd72dc74b22"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a String: DREAM\n",
            "D\n",
            "DR\n",
            "DRE\n",
            "DREA\n",
            "DREAM\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter a String: \")\n",
        "j=len(n)\n",
        "for row in range(j):\n",
        "  for col in range(row+1):\n",
        "    print(n[col],end=\"\")\n",
        "  print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PsBbgc4YU1yp"
      },
      "source": [
        "### Task 6\n",
        "\n",
        "Write a Python program that will ask the user to input a string (containing exactly one word). Then print the ASCII code for each character in the String using the ord() function.\n",
        "\n",
        "To check if your program is working correctly or not, you can find a list of all correct values from the following website. You may look at “Dec” and “Char” columns only and ignore the other columns for this problem.\\\n",
        "link: http://www.asciitable.com/\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1**:\\\n",
        "Programming\n",
        "\n",
        "**Sample Output 1**:\\\n",
        "P : 80\\\n",
        "r : 114\\\n",
        "o : 111\\\n",
        "g : 103\\\n",
        "r : 114\\\n",
        "a : 97\\\n",
        "m : 109\\\n",
        "m : 109\\\n",
        "i : 105\\\n",
        "n : 110\\\n",
        "g : 103\n",
        "\n",
        "**Explanation**: Each line prints a letter sequentially from the given string and its corresponding ASCII value separated by \" : \".\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\\\n",
        "hunger\n",
        "\n",
        "**Sample Output 2**:\\\n",
        "h : 104\\\n",
        "u : 117\\\n",
        "n : 110\\\n",
        "g : 103\\\n",
        "e : 101\\\n",
        "r : 114\n",
        "\n",
        "**Explanation**: Same as previous.\n",
        "\n",
        "====================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UdJ5dNsM3m2X",
        "outputId": "27e7b65f-03cc-41b7-a9c1-500fe43d136f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: Programming\n",
            "P : 80\n",
            "r : 114\n",
            "o : 111\n",
            "g : 103\n",
            "r : 114\n",
            "a : 97\n",
            "m : 109\n",
            "m : 109\n",
            "i : 105\n",
            "n : 110\n",
            "g : 103\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter a string: \")\n",
        "for i in n:\n",
        "  print(i,\":\", ord(i))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O8lIVppgU1yw"
      },
      "source": [
        "### Task 7\n",
        "\n",
        "Write a Python program that takes a string as an input from the user containing all small letters and then prints the next alphabet in sequence for each alphabet in the input.\n",
        "\n",
        "*Hint: You may need to use the functions ord() and chr(). The ASCII value of ‘a’ is 97 and ‘z’ is 122.*\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "abcd\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "bcde\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "the cow\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "uif!dpx\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "<font color='red'>[Must fulfil this criteria]</font>\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "xyzabc\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "yzabcd\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JjEDXfQF31r7",
        "outputId": "9c9e21db-676a-45c5-e502-7b3b43f9ae2d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: xyzabc\n",
            "yzabcd\n"
          ]
        }
      ],
      "source": [
        "e=input(\"Enter a string: \")\n",
        "n=\"\"\n",
        "for i in e:\n",
        "  ascii=ord(i)\n",
        "  if ascii==ord('z'):\n",
        "    n=n+'a'\n",
        "  else:\n",
        "    n=n+chr(ascii+1)\n",
        "print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZrjtT-I_U1zD"
      },
      "source": [
        "### Task 8\n",
        "\n",
        "Write a Python program that takes a String as input from the user, removes the characters at even index and prints the resulting String in uppercase without using the built-in function upper().\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1**:\n",
        "\n",
        "String\n",
        "\n",
        "**Sample Output 1**:\n",
        "\n",
        "TIG\n",
        "\n",
        "**Explanation**: The characters 'S', 'r' and 'n' are at index positions 0, 2, and 4 respectively. Hence they are removed and the remaining characters 'tig' are capitalized giving us output 'TIG'.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\n",
        "\n",
        "abcd\n",
        "\n",
        "**Sample Output 2**:\n",
        "\n",
        "BD\n",
        "\n",
        "**Explanation**: Only the characters at the odd indices, 1 and 3, 'b' and 'd' are captitalized, concatenated and printed.\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iRk5NvSu4CBc",
        "outputId": "550b8db8-1c15-4f53-ee4b-f8a32e09f464"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter any string: abcd\n",
            "BD\n"
          ]
        }
      ],
      "source": [
        "e= input(\"Enter any string: \")\n",
        "n=''\n",
        "for i in range(len(e)):\n",
        "  if i%2!=0:\n",
        "    c=chr(ord(e[i])-32)\n",
        "    n+=c\n",
        "print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AWQJrJW3U1y3"
      },
      "source": [
        "### Task 9\n",
        "Given a string, create a new string with all the **consecutive duplicates removed**.\n",
        "\n",
        "**Hint:** You may make a new string to store the result. You can check whether the current character and the next character are the same, then add that character to the new string.\n",
        "\n",
        "**Note**: Only consecutive letters are removed not all duplicate occurences of a letter. You may try doing this alternative i.e. removing all duplicate letters from a given string, for your own practice.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1**:\\\n",
        "AAABBBBCDDBBECE\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "ABCDBECE\n",
        "\n",
        "**Explanation**: From the 3 consecutive \"A\"s, 2 are removed and we have 'A' only. Then from the 4 consecutive 'B's, 3 are removed and only one is added to the new string giving us \"AB\". Since we have only one 'C' next, it is added making the resulting string \"ABC\" now and so on.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\\\n",
        "Jupyter Notebook is better. Case sensitivity check AAaaaAaaAAAa.\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "Jupyter Notebok is beter. Case sensitivity check AaAaAa.\n",
        "\n",
        "**Explanation**: Just the 2 consectutive 'o's and 't's are changed to one at first and the uppercase 'A' and lowercase 'a' are treated separately i.e. case sensitive when checking for consecutive duplicates.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xMRNPdlk4WgJ",
        "outputId": "4e0bd771-1317-4bb0-daef-d33a386cd24e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: AAABBBBCDDBBECE\n",
            "ABCDBECE\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter a string: \")\n",
        "s=\"\"\n",
        "for i in n:\n",
        "  if s==\"\" or i!=s[len(s)-1]:\n",
        "    s=s+i\n",
        "print(s)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "leVtdAsdymXM"
      },
      "source": [
        "### Task 10\n",
        "\n",
        "Write a Python program that will take one input from the user made up of two strings separated by a comma and a space (see samples below). Then create a mixed string with alternative characters from each string. Any leftover chars will be appended at the end of the resulting string.\n",
        "\n",
        "*Hint: For adding the leftover characters you may use string slicing.*\n",
        "\n",
        "**Note:** Please do not use lists for this task.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "ABCD, efgh\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "AeBfCgDh\n",
        "\n",
        "**Explanation**: At first, the two strings divided by \", \" should be separated. Then the first character of the first string 'A' is concatenated with the first character of the second string 'e' which in turn is concatenated to the second character of the first string 'B', the second character of the second string f and so on since the strings are of equal length.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2:**\\\n",
        "ABCDENDFGH, ijkl\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "AiBjCkDlENDFGH\n",
        "\n",
        "**Explanation**: Here, since the length of the first string is greater than the length of the second string, after separation, the characters are concatenated alternatively as in sample input/output 1, till the length of the second string i.e. ijkl. Since, there are no more characters in the second string after that, the remaining characters if the first string i.e. ENDFGH in this case are concatenated at the end of the final string.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "ijkl, ABCDENDFGH\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "iAjBkClDENDFGH\n",
        "\n",
        "**Explanation**: This time, the length of the second string is greater than the length of the first string therefore the first letters of the 2 strings 'i' and 'A', then the second letters 'j' and 'B' and so on are being concatenated until there are no more letters in the first shorter string following which the remaining letters i.e. ENDFGH again in this case too (this may be different for other different string inputs) are added at the end giving us the resulting output string.\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FDj8syI24j0k",
        "outputId": "82ff0ad4-da79-455c-cf13-8ea7fb0e709b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the 1st string: ABCDENDFGH\n",
            "Enter the 2nd string: ijkl\n",
            "AiBjCkDlENDFGH\n"
          ]
        }
      ],
      "source": [
        "s1=input(\"Enter the 1st string: \")\n",
        "s2=input(\"Enter the 2nd string: \")\n",
        "i=0\n",
        "j=0\n",
        "sum=\"\"\n",
        "while i<len(s1) or j<len(s2):\n",
        "  if i<len(s1):\n",
        "    sum=sum+s1[i]\n",
        "    i+=1\n",
        "  if j<len(s2):\n",
        "    sum=sum+s2[j]\n",
        "    j+=1\n",
        "print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tdc_Qdxi4tXl"
      },
      "source": [
        "# <font color='purple'> Task 11 to Task 15 are [ Tracing ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7a_1pYjfU1zI"
      },
      "source": [
        "### Task 16\n",
        "\n",
        "Write a python program that takes 2 inputs from the user. The first input is a string and the second input is a letter. The program should remove all occurences of the letter from the given string and print the output. If the letter is not found in the string and the length of string is greater than 3, then remove the first letter and last letter of the given string and print it. Otherwise print the string as it is. You can assume that all the input will be in lowercase letter.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "\n",
        "**Sample Input 1**:\\\n",
        "tanjiro kamado\\\n",
        "a\n",
        "\n",
        "**Sample output 1**:\\\n",
        "tnjiro kmdo\n",
        "\n",
        "**Explanation**: All 3 instances of the character 'a' is removed from the input String 'tanjiro kamado' to give us output 'tnjiro kmdo'.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\\\n",
        "eren yeager\\\n",
        "k\n",
        "\n",
        "\n",
        "**Sample Output 2**:\\\n",
        "ren yeage\n",
        "\n",
        "**Explanation**: The character 'k' is absent in the first input String 'eren yeager' and it's length is 11 which is greater than 3 therefore the first character 'e' and the last character 'r' is removed. Hence, the final String is 'ren yeage'.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 3:**\\\n",
        "hi\\\n",
        "a\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "hi\n",
        "\n",
        "**Explanation**: The letter 'a' is not found in our first input 'hi', the length of which is 2. Since the character is not present and the length is less than 3, we print the String 'hi' as it is.\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eVldyKxu6932",
        "outputId": "1e5e1ab0-4274-4752-8282-5d722d0feb43"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a String in lowercase letter: tanjiro kamado\n",
            "Enter a lowercase letter: a\n",
            "tnjiro kmdo\n"
          ]
        }
      ],
      "source": [
        "n = input(\"Enter a String in lowercase letter: \")\n",
        "c = input(\"Enter a lowercase letter: \")\n",
        "if(c in n):\n",
        "    print(n.replace(c,\"\"))\n",
        "else:\n",
        "    if(len(n) > 3):\n",
        "        print(n[1:-1])\n",
        "    else:\n",
        "        print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G1KGod9C87t_"
      },
      "source": [
        "### Task 17\n",
        "\n",
        "Write a python program that splits a given string on a given split character. The first input is a String and the second input is the character that will be used to split the first String.\n",
        "\n",
        "<font color='red'>[You cannot use the built-in split function for this task]</font>\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1:**<br/>\n",
        "This-is-CSE110<br/>\n",
        "-<br/>\n",
        "\n",
        "**Sample Output 1:**<br/>\n",
        "This<br/>\n",
        "is<br/>\n",
        "CSE110\n",
        "\n",
        "**Explanation**: The second input which is the character '-', is used to split or divide the first input String 'This-is-CSE110' into 'This', 'is' and 'CSE110' which are printed individually in separate lines.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\\\n",
        "tom@gmail,harry@yahoo,bob@gmail,mary@gmail\n",
        "\n",
        ",\n",
        "\n",
        "**Sample Output 2**:\n",
        "\n",
        "tom@gmail\n",
        "\n",
        "harry@yahoo\n",
        "\n",
        "bob@gmail\n",
        "\n",
        "mary@gmail\n",
        "\n",
        "====================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mueKwV817MKH",
        "outputId": "141624b9-dcd1-463e-ddfb-9ebe2f16e920"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a String: This-is-CSE110\n",
            "Enter a Character from your string: -\n",
            "This\n",
            "is\n",
            "CSE110\n"
          ]
        }
      ],
      "source": [
        "n = input(\"Enter a String: \")\n",
        "c = input(\"Enter a Character from your string: \")\n",
        "print(n.replace(c,\"\\n\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AWgZaBZCzmaM"
      },
      "source": [
        "### Task 18\n",
        "\n",
        "Write a python program that takes two inputs. The first input is a string and the second input is a number. If the number is even then concatenate the given string two times the given number and if the number is odd then concatenate the given string three times the given number.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 1**:\n",
        "\n",
        "CSE110\n",
        "\n",
        "4\n",
        "\n",
        "**Sample output 1**:\n",
        "\n",
        "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110\n",
        "\n",
        "**Explanation**: The second input which is the number 4 is even, therefore the first string input 'CSE110' is concatenated(joined together) 4*2 = 8 times.\n",
        "\n",
        "=====================================================================\n",
        "\n",
        "**Sample Input 2**:\n",
        "\n",
        "CSE110\n",
        "\n",
        "3\n",
        "\n",
        "**Sample Output 2**:\n",
        "\n",
        "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HETFfuLA5Xaa",
        "outputId": "5c64b43b-84d0-4d5e-e1fb-8ea894d1253f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a String: CSE110\n",
            "Enter a number: 3\n",
            "CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110CSE110\n"
          ]
        }
      ],
      "source": [
        "u=input(\"Enter a String: \")\n",
        "n=int(input(\"Enter a number: \"))\n",
        "if n%2==0:\n",
        "  print(u*(n*2))\n",
        "else:\n",
        "  print(u*(n*3))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nwRZ3_0tC3fq"
      },
      "source": [
        "### Task 19\n",
        "\n",
        "Write a python program that takes a string as an input from the user and then modifies the string in such a way that the string always starts with an uppercase letter and the case of each subsequent letter is the opposite of the previous letter (uppercase character followed by a lowercase character followed by an uppercase character and so on).  Finally the modified string is printed to show the user.\n",
        "*Hint:  Flags/counters can be used to manage uppercase-lowercase.*\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "Python programming is very easy\\\n",
        "**Sample Output 1:**\\\n",
        "PyThOn PrOgRaMmInG iS vErY eAsY\\\n",
        "**Sample Input 2:**\\\n",
        "I&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;     love       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Python &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Programming\\\n",
        "**Sample Output 2:**\\\n",
        "I&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;     lOvE       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;pYtHoN&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;pRoGrAmMiNg\\\n",
        "**Sample Input 3:**\\\n",
        "CSE110 Course\\\n",
        "**Sample Output 3**\\\n",
        "CsE110 cOuRsE\\\n",
        "**Sample Input 4:**\\\n",
        "c\\\n",
        "**Sample Output 4:**\\\n",
        "C\n",
        "\n",
        "=====================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ZFC1eEjFs7R",
        "outputId": "b29e27e7-2b9f-44eb-95b6-b9ae23724c79"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: I       love         Python         Programming\n",
            "I       lOvE         pYtHoN         pRoGrAmMiNg"
          ]
        }
      ],
      "source": [
        "s=input(\"Enter a string: \")\n",
        "c=0\n",
        "for i in s:\n",
        "  if not ((ord('A')<=ord(i)<=ord('Z')) or (ord('a')<=ord(i)<=ord('z'))):\n",
        "    print(i, end='')\n",
        "  else:\n",
        "    if c%2==0:\n",
        "      if ord('a')<=ord(i)<=ord('z'):\n",
        "        print(chr(ord(i)-32), end='')\n",
        "      else:\n",
        "        print(i, end='')\n",
        "    else:\n",
        "      if ord('A')<=ord(i)<=ord('Z'):\n",
        "        print(chr(ord(i)+32), end='')\n",
        "      else:\n",
        "        print(i, end='')\n",
        "    c+=1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H85y_agd8wJF"
      },
      "source": [
        "# #<font color='blue'>Assignment 4 (List)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xr3FnyvH9Nbu"
      },
      "source": [
        "### Task 1\n",
        "Write a Python program that reads 5 numbers from the user into a list. After reading each number, print all the numbers that have been entered so far in the list.\n",
        "\n",
        "**Example:**\\\n",
        "If the user enters 3, prints “Numbers in the list: [3]”\\\n",
        "If the user enters 5 next, prints “Numbers in the list: [3, 5]”\\\n",
        "If the user enters 34, prints “Numbers in the list: [3, 5, 34]”\\\n",
        "If the user then enters -11, prints “Numbers in the list: [3, 5, 34, -11]”\\\n",
        "Finally, if the user enters 0 as the last number, prints “Numbers in the list: [3, 5, 34, -11, 0]”"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YkTveq8Wec6j",
        "outputId": "2f7a3ba8-868d-4a9d-f1ae-500510bb4f16"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Ënter a number: 3\n",
            "Numbers in the list: [3]\n",
            "Ënter a number: 5\n",
            "Numbers in the list: [3, 5]\n",
            "Ënter a number: 3\n",
            "Numbers in the list: [3, 5, 3]\n",
            "Ënter a number: -11\n",
            "Numbers in the list: [3, 5, 3, -11]\n",
            "Ënter a number: 0\n",
            "Numbers in the list: [3, 5, 3, -11, 0]\n"
          ]
        }
      ],
      "source": [
        "n=[]\n",
        "for i in range(5):\n",
        "  n.append(int(input(\"Ënter a number: \")))\n",
        "  print(\"Numbers in the list:\",n)\n",
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VcoCFhB99cut"
      },
      "source": [
        "### Task 2\n",
        "\n",
        "Write a Python program that takes a list as an input from the user, then creates a new list excluding the first and last two elements of the given list and prints the new list. If there are not enough elements in the list to do the task, print \"Not possible\".\n",
        "\n",
        "**Note:** You may use list slicing.\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 1:**<br/>\n",
        "[10, 20, 24, 25, 26, 35, 70]<br/>\n",
        "\n",
        "**Sample Output 1:**<br/>\n",
        "[24, 25, 26]<br/>\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 2:**<br/>\n",
        "[10, 20, 24, 25, 26]<br/>\n",
        "\n",
        "**Sample Output 2:**<br/>\n",
        "[24]<br/>\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 3:**<br/>\n",
        "[10, 20, 24, 25]<br/>\n",
        "\n",
        "**Sample Output 3:**<br/>\n",
        "[]<br/>\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 4:**<br/>\n",
        "[10, 20, 24]<br/>\n",
        "\n",
        "**Sample Output 4:**<br/>\n",
        "Not possible<br/>\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nEplws1jeiZY",
        "outputId": "1d0532ca-fa84-420a-d909-6275ce9271e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter element's numbers: 4\n",
            "Ënter a number: 10\n",
            "Ënter a number: 24\n",
            "Ënter a number: 20\n",
            "Ënter a number: 25\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "u=[]\n",
        "l=int(input(\"Enter element's numbers: \"))\n",
        "for i in range(l):\n",
        "  u.append(int(input(\"Ënter a number: \")))\n",
        "n=[]\n",
        "if len(u)<4:\n",
        "  print(\"Not possible\")\n",
        "else:\n",
        "  for i in u[2:-2]:\n",
        "    n.append(i)\n",
        "  print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AA4tvqRT9jtj"
      },
      "source": [
        "### Task 3\n",
        "\n",
        "Write a python program that reads 5 numbers from the user into a list, and then prints them in the reverse order.\n",
        "\n",
        "*Hint: You may create a list to store the input numbers and then use loop to print them in reverse order*\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input:**\\\n",
        "5\\\n",
        "-5\\\n",
        "100\\\n",
        "1\\\n",
        "0\n",
        "\n",
        "**Sample Output:**\\\n",
        "Input data: [5, -5, 100, 1, 0]\\\n",
        "Printing values from the list in reverse order:\\\n",
        "0\\\n",
        "1\\\n",
        "100\\\n",
        "-5\\\n",
        "5\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oGunbAVJejdJ",
        "outputId": "603338f6-b86c-411b-847e-9c330aa74a7b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Ënter a number: 5\n",
            "Ënter a number: -5\n",
            "Ënter a number: 100\n",
            "Ënter a number: 1\n",
            "Ënter a number: 0\n",
            "Input data: [5, -5, 100, 1, 0]\n",
            "Printing values from the list in reverse order: \n",
            "0\n",
            "1\n",
            "100\n",
            "-5\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "n=[]\n",
        "for i in range(5):\n",
        "  n.append(int(input(\"Ënter a number: \")))\n",
        "print(\"Input data:\",n)\n",
        "n.reverse()\n",
        "print(\"Printing values from the list in reverse order: \")\n",
        "for j in n:\n",
        "  print(j)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4pBLPmvre0jv"
      },
      "source": [
        "### Task 4\n",
        "\n",
        "Write a Python program that turns every item of a list into its square. [Your program should work for any lists; make changes to the lists below and check whether your program works correctly]\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Given list 1:**\\\n",
        "[1, 2, 3, 4, 5, 6, 7]\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "[1, 4, 9, 16, 25, 36, 49]\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Given list 2:**\\\n",
        "[3, 5, 1, 6]\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "[9, 25, 1, 36]\n",
        "\n",
        "\n",
        "===================================================================\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s2KtneaAelmn",
        "outputId": "d920a717-d196-4d06-ef1e-7a4130b34ec3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter element's number: 4\n",
            "Enter a number: 3\n",
            "Enter a number: 5\n",
            "Enter a number: 1\n",
            "Enter a number: 6\n",
            "[9, 25, 1, 36]\n"
          ]
        }
      ],
      "source": [
        "n=[]\n",
        "e=int(input(\"Enter element's number: \"))\n",
        "for i in range(e):\n",
        "  n.append(int(input(\"Enter a number: \")))\n",
        "  n[i]=n[i]**2\n",
        "print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G9jPuLWOetqd"
      },
      "source": [
        "### Task 5\n",
        "\n",
        "\n",
        "Write a Python program that removes all Empty strings from a **given list** and prints the modified list. [Your program should work for any given list; make changes to the list below and check whether your program works correctly]\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Given List:**\n",
        "\n",
        "[\"hey\", \"there\", \"\", \"what's\", \"\", \"up\", \"\", \"?\"]\n",
        "\n",
        "**Sample Output:**\n",
        "\n",
        "Original List:\n",
        "['hey', 'there', '', \"what's\", '', 'up', '', '?']\n",
        "\n",
        "Modified List:\n",
        "['hey', 'there', \"what's\", 'up', '?']\n",
        "\n",
        "==========================================================================\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b7XaokGZentW",
        "outputId": "6f6195dc-3a7e-4084-f015-83a5fca2678f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Original list:  ['hey', 'there', '', \"what's\", '', 'up', '', '?']\n",
            "Modified list:  ['hey', 'there', \"what's\", 'up', '?']\n"
          ]
        }
      ],
      "source": [
        "g=[\"hey\",\"there\",\"\",\"what's\",\"\",\"up\",\"\",\"?\"]\n",
        "print(\"Original list: \",g)\n",
        "while \"\" in g:\n",
        "  g.remove(\"\")\n",
        "print(\"Modified list: \",g)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wfcSytFVU1zU"
      },
      "source": [
        "### Task 6\n",
        "\n",
        "Write a Python program that reads a string containing 7 numbers separated by commas, then makes a list of those numbers and prints the **largest number** and its location or index position in the list. <font color='red'>[You are not allowed to use the max(), sort(), sorted() function here]</font>\n",
        "\n",
        "[Your program should work for any given list; make changes to the list below and check whether your program works correctly]\n",
        "\n",
        "**Hint:** You may assume the first input to be the largest value initially and the largest value’s location to be 0.\n",
        "\n",
        "**Note:** You may need to be careful while printing the output. Depending on your code, you might need data conversion.\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input:**\\\n",
        " \"7, 13, 2, 10, 6, -11, 0\"\n",
        "\n",
        "**Sample Output:**\\\n",
        "My list: [7, 13, 2, 10, 6, -11, 0]\\\n",
        "Largest number in the list is 13 which was found at index 1.\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hgoKKL-pepZh",
        "outputId": "7af2c3c6-c51d-4f9d-a19c-103c613c7ef1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter 7 numbers integers separated by commas: 7,13,2,10,6,-11,0\n",
            "My List:  [7, 13, 2, 10, 6, -11, 0]\n",
            "Largest number in the list is 13 which was found at index 1\n"
          ]
        }
      ],
      "source": [
        "n=input(\"Enter 7 numbers integers separated by commas: \")\n",
        "l=n.split(\",\")\n",
        "j=[]\n",
        "for i in l:\n",
        "  j.append(int(i))\n",
        "print(\"My List: \",j)\n",
        "m=j[0]\n",
        "p=0\n",
        "for k in range(1,len(j)):\n",
        "  if (m<j[k]):\n",
        "    m= j[k]\n",
        "    p=k\n",
        "print(f\"Largest number in the list is {m} which was found at index {p}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjTy79X6ewce"
      },
      "source": [
        "### Task 7\n",
        "\n",
        "Suppose you have been given two lists. Write a Python program that replaces the last element of the first list with the second list. [Your program should work for any two given lists; make changes to the lists below and check whether your program works correctly]\n",
        "\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample given lists 1:**\\\n",
        "List_one : [1, 4, 7, 5]\\\n",
        "List_two : [6, 1, 3, 9]\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "[1, 4, 7, 6, 1, 3, 9]\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample given lists 2:**\\\n",
        "List_one : [1, 3, 5, 7, 9, 10]\\\n",
        "List_two : [2, 4, 6, 8]\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "[1, 3, 5, 7, 9, 2, 4, 6, 8]\n",
        "\n",
        "===================================================================\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HhuxLOgA-wK7",
        "outputId": "b9b98501-a5fa-4a5c-8933-7da42db1b5af"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 3, 5, 7, 9, 2, 4, 6, 8]\n"
          ]
        }
      ],
      "source": [
        "list_one = [1,3,5,7,9,10]\n",
        "list_two = [2,4,6,8]\n",
        "new_list =[]\n",
        "for i in list_one[:-1]:\n",
        "  new_list.append(i)\n",
        "print(new_list + list_two)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5IaV4UW4-2IC"
      },
      "source": [
        "### Task 8\n",
        "Assume, you have been given two lists. [Your program should work for any two given lists; change the following lists and check whether your program works correctly for the code you have written]\n",
        "\n",
        "list_one = [1, 2, 3, 4, 5, 6, 7, 8, 9]\\\n",
        "list_two = [10, 11, 12, -13, -14, -15, -16]\n",
        "\n",
        "Write a Python program that creates a new list with all the **even elements** of both of the given lists and prints the new list.\n",
        "\n",
        "**Hint:** You may create a third list to store the even elements of the given lists.\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Output for the above lists:** [2, 4, 6, 8, 10, 12, -14, -16]\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pR-pzCKz-Qnu",
        "outputId": "93f6dee9-c301-472b-b493-c62bf1f4f30d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Output for the above lists:  [2, 4, 6, 8, 10, 12, -14, -16]\n"
          ]
        }
      ],
      "source": [
        "list_one = [1,2,3,4,5,6,7,8,9]\n",
        "list_two = [10,11,12,-13,-14,-15,-16]\n",
        "new_list=[]\n",
        "for count in list_one:\n",
        "  if count%2==0:\n",
        "    new_list.append(count)\n",
        "for count in list_two:\n",
        "  if count%2==0:\n",
        "    new_list.append(count)\n",
        "print(\"Output for the above lists: \",new_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vyFt-Ra5erR4"
      },
      "source": [
        "### Task 9\n",
        "\n",
        "Write a Python program that reads a string as an input from the user where multiple numbers are separated by spaces. Then, make a list of numbers from the input string without using the split() function and print the list. Finally, remove all the occurences of **even numbers** from the same input list and print the modified list.\n",
        "\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "**Sample Input:**\n",
        "\n",
        "7 12 4 55 96 2 11 61 33 42\n",
        "\n",
        "**Sample Output:**\n",
        "\n",
        "Original list: [7, 12, 4, 55, 96, 2, 11, 61, 33, 42]\\\n",
        "Modified list: [7, 55, 11, 61, 33]\n",
        "\n",
        "=========================================================================\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fcPie0yUEBj6",
        "outputId": "2ee460e8-c6e3-4928-c10e-ad338efc200b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "7 12 4 55 96 2 11 61 33 42\n",
            "Original list:  [7, 12, 4, 55, 96, 2, 11, 61, 33, 42]\n",
            "MOdified list:  [7, 55, 11, 61, 33]\n"
          ]
        }
      ],
      "source": [
        "list1=[]\n",
        "str=input()\n",
        "number=\" \"\n",
        "input_list=[]\n",
        "for i in str:\n",
        "   if ord(i)!=ord(\" \"):\n",
        "     number+=i\n",
        "   else:\n",
        "     if int(number)%2!=0:\n",
        "       input_list.append(int(number))\n",
        "       list1.append(int(number))\n",
        "     else:\n",
        "        input_list.append(int(number))\n",
        "     number=\" \"\n",
        "if len(number)!=0:\n",
        "  input_list.append(int(number))\n",
        "  if int(number)%2!=0:\n",
        "        list1.append(int(number))\n",
        "print(\"Original list: \",input_list)\n",
        "print(\"MOdified list: \",list1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QaD4hLn92EKT"
      },
      "source": [
        "### Task 10\n",
        "Write a Python program that reads a string as an input from the user where multiple numbers are separated by commas. Then, make a list of numbers from the input string and print the list. Finally, remove multiple occurences of any numbers from the input list and print the modified list **without duplicate values**.\n",
        "\n",
        "*Hint: You may create a third list to store the results but you may try doing it in the same input list. You can use membership operators (in, not in) to make sure no duplicates are added.*\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 1:**<br/>\n",
        "0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4<br/>\n",
        "\n",
        "\n",
        "**Sample Output 1:**<br/>\n",
        "Input list: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]\\\n",
        "Modified list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 2:**<br/>\n",
        "7, 7, 7, 1, 0, 3, 3, 55, 9<br/>\n",
        "\n",
        "\n",
        "**Sample Output 2:**<br/>\n",
        "Input list: [7, 7, 7, 1, 0, 3, 3, 55, 9]\\\n",
        "Modified list: [7, 1, 0, 3, 55, 9]\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EUbQbz5hU1zP",
        "outputId": "bf2b082f-fcc4-4701-ad27-132caba3c95f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " 7, 7, 7, 1, 0, 3, 3, 55, 9\n",
            "input list: [7, 7, 7, 1, 0, 3, 3, 55, 9]\n",
            "Modified list: [7, 1, 0, 3, 55, 9]\n"
          ]
        }
      ],
      "source": [
        "list_1=input(\" \").split(',')\n",
        "new_list1=[]\n",
        "new_list2=[]\n",
        "for i in list_1:\n",
        "  new_list1.append(int(i))\n",
        "print(\"input list:\",new_list1)\n",
        "for j in new_list1:\n",
        "  if j not in new_list2:\n",
        "    new_list2.append(int(j))\n",
        "print(\"Modified list:\", new_list2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bvF30RQlemBW"
      },
      "source": [
        "### Task 11\n",
        "Assume, you have been given two lists: List_one and List_two. [Your program should work for any two given lists; change the following lists and check whether your program works correctly for the code you have written]\n",
        "\n",
        "Write a Python program that prints \"True\", if the given two lists have at least one common member. Otherwise, print \"False\".\n",
        "\n",
        "Note: Please use concepts of flag and break to solve this task.\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Given lists 1:**\\\n",
        "List_one : [1, 4, 3, 2, 6]\\\n",
        "List_two : [5, 6, 9, 8, 7]\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "True\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Given lists 2:**\\\n",
        "List_one : [1, 4, 3, 2, 5]\\\n",
        "List_two : [8, 7, 6, 9]\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "False\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LEnaTlyoMJdS",
        "outputId": "0d4f60cc-57bd-46b7-a51b-56db306c165b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "list_one=[1, 4, 3, 2, 5]\n",
        "list_two=[5,6,9,8,7]\n",
        "var=False\n",
        "for i in list_one:\n",
        "  if i in list_two:\n",
        "    var=True\n",
        "    print(var)\n",
        "    break\n",
        "if var==False:\n",
        "  print(var)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_2JYNnUOBAIR"
      },
      "source": [
        "# <font color='purple'> Task 12 to Task 15 are [ Tracing ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5zjB2R4hBL5V"
      },
      "source": [
        "### Task 16\n",
        "\n",
        "\n",
        "Write a Python program that reads 7 numbers into a list and prints the **second largest number** and its location or index position on the list. <font color='red'>[You are not allowed to use the max(), sort(), sorted() function here]</font>\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input:**\\\n",
        " 7, 13, 2, 10, 6, -11, 0\n",
        "\n",
        "**Sample Output:**\\\n",
        "My list: [7, 13, 2, 10, 6, -11, 0]\\\n",
        "Second largest number in the list is 10 which was found at index 3.\n",
        "\n",
        "===================================================================\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lvSiLaobU1zY"
      },
      "source": [
        "### Task 17\n",
        "\n",
        "Write a Python program that reads 5 numbers into a list and prints the smallest and largest number and their locations in the list.\\\n",
        " <font color='red'>[You are not allowed to use the max(), min(), sort(), sorted() functions here]</font>\n",
        "\n",
        "**Hint:** You may assume the first input to be the largest value initially and the largest value’s location to be 0. Similarly, you can assume the first input to be the smallest value initially and the smallest value’s location to be 0.\n",
        "\n",
        "**Note:** You may need to be careful while printing the output. Depending on your code, you might need data conversion.\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input:**\\\n",
        "7, 13, -5, 10, 6\n",
        "\n",
        "**Sample Output:**\\\n",
        "My list: [7, 13, -5, 10, 6]\\\n",
        "Smallest number in the list is -5 which was found at index 2\\\n",
        "Largest number in the list is 13 which was found at index 1\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pr00F87Z3rum"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rguDZ8SBCHD8"
      },
      "source": [
        "### Task 18\n",
        "Write a Python program that takes two lists as an input from the user. Then print a new list with the **common elements** of both the input lists.\n",
        "\n",
        "*Hint: You may need to create a third list to store the results. You can use membership operators (in, not in) to make sure similar elements are added.*\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 1:**<br/>\n",
        "A, B, C, D\n",
        "\n",
        "\n",
        "C, E, F, B\n",
        "\n",
        "\n",
        "**Sample Output 1:**<br/>\n",
        "['C', 'B']\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 2:**<br/>\n",
        "1, 3, A, H, P\n",
        "\n",
        "\n",
        "A, G, 1, P, O\n",
        "\n",
        "\n",
        "**Sample Output 2:**<br/>\n",
        "['1', 'A', 'P']\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qrEZrFgl3sQ4"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tjcE5oitCM2s"
      },
      "source": [
        "\n",
        "### Task 19\n",
        "\n",
        "Assume, you have been given two lists. [Your program should work for any two given lists; make changes to the lists below and check whether your program works correctly]\n",
        "\n",
        "list_one = [1, 2 , 2, 4, 5, 5, 7, 99, 200, 303, 70]\\\n",
        "list_two = [1, 1, 2, 3, 3, 3, 4, 5, 200, 500, -5]\n",
        "\n",
        "Write a Python program that creates a new list with all the **unique elements** of both the given lists.\n",
        "\n",
        "<font color='red'>**You need to make sure that there are no duplicates in the resulting list.**</font> \\\n",
        "Finally, print the updated list.\n",
        "\n",
        "**Hint:** You may create a third list to store the results. You can use membership operators (in, not in) to make sure no duplicates are added.\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Output for the above two lists**:\n",
        "[1, 2, 4, 5, 7, 99, 200, 303, 70, 3, 500, -5]\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9PxMLxvI3tGm"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A1GQ4lem2We7"
      },
      "source": [
        "### Task 20\n",
        "\n",
        "Write a python program to take a list as a string input from the user and print it back to the user as a list. Please look at the examples below for clarification.\n",
        "\n",
        "**<font color='red'>[Must use string split() and strip() functions]</font>**\n",
        "\n",
        "================================================================\n",
        "\n",
        "**Sample Input 1:**\\\n",
        "'1, &nbsp; &nbsp;&nbsp; &nbsp; 2  ,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3, 50, 4'\n",
        "\n",
        "**Sample Output 1:**\\\n",
        "Original data: 1, &nbsp; &nbsp;&nbsp; &nbsp; 2  ,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3, 50, 4\\\n",
        "After removing square brackets: 1, &nbsp; &nbsp;&nbsp; &nbsp; 2  ,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3, 50, 4\\\n",
        "Numbers in string format with extra white spaces: ['1', '&nbsp; &nbsp;&nbsp; &nbsp; 2'  ,'&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3', '50', '4']\\\n",
        "Final data (numbers in list format): [1, 2, 3, 50, 4]\n",
        "                \n",
        "                \n",
        "================================================================\n",
        "                \n",
        "  \n",
        "**Sample Input 2:**\n",
        "'[1,&nbsp; &nbsp;&nbsp; &nbsp;2&nbsp; &nbsp;,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3, 50, 4]'\n",
        "\n",
        "**Sample Output 2:**\\\n",
        "Original data: [1,&nbsp; &nbsp;&nbsp; &nbsp;2&nbsp; &nbsp;,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3, 50, 4]\\\n",
        "After removing square brackets: 1,&nbsp; &nbsp;&nbsp; &nbsp;2&nbsp; &nbsp;,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3, 50, 4\\\n",
        "Numbers in string format with extra white spaces: ['1', '&nbsp; &nbsp;&nbsp; &nbsp;2&nbsp; &nbsp;', '&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3', '50', '4']\\\n",
        "Final data (numbers in list format): [1, 2, 3, 50, 4]\n",
        "                \n",
        "                \n",
        "================================================================\n",
        "\n",
        "                \n",
        "  \n",
        "**Sample Input 3:**\\\n",
        "\"&nbsp; &nbsp;&nbsp; &nbsp;[1,&nbsp; &nbsp;2&nbsp; &nbsp;,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3,&nbsp; &nbsp;50,&nbsp; &nbsp;4]&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;\"\n",
        "\n",
        "**Sample Output 3:**\\\n",
        "Original data: &nbsp; &nbsp;&nbsp; &nbsp;[1,&nbsp; &nbsp;2&nbsp; &nbsp;,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3,&nbsp; &nbsp;50,&nbsp; &nbsp;4]&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;\\\n",
        "After removing square brackets: 1,&nbsp; &nbsp;2&nbsp; &nbsp;,&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3,&nbsp; &nbsp;50,&nbsp; &nbsp;4\\\n",
        "Numbers in string format with extra white spaces: [' 1', '&nbsp; &nbsp;2&nbsp; &nbsp;', '&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;3', '&nbsp; &nbsp;50', '&nbsp; &nbsp;4']\\\n",
        "Final data (numbers in list format): [1, 2, 3, 50, 4]\n",
        "\n",
        "                \n",
        "================================================================"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uYspeIBP3t4h"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ju21t8um2jiS"
      },
      "source": [
        "\n",
        "### Task 21\n",
        "Write a Python program that takes a single string as an input from the user where few numbers are separated by commas. Now, make a list with the numbers of the given string.Then your task is to remove multiple occurences of any number and then finally print the list **without any duplicate values**.\n",
        "\n",
        "*Hint (1): For obtaining the numbers from the string, use split(). For cleaning the data, use strip().*\n",
        "\n",
        "*Hint (2): You may create a third list to store the results. You can use membership operators (in, not in) to make sure no duplicates are added.*\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 1:**<br/>\n",
        "0, 0, 1, 2, 3, 4,&nbsp;&nbsp; &nbsp;&nbsp; 4, 5, 6, 6, 6,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;7, 8, 9, 4,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 4<br/>\n",
        "\n",
        "\n",
        "**Sample Output 1:**<br/>\n",
        "Given numbers in list: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]\\\n",
        "List without any dupliacte values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br/>\n",
        "\n",
        "===================================================================\n",
        "\n",
        "**Sample Input 2:**<br/>\n",
        "7, 7, 7, 1, &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0, 3, 3, &nbsp;&nbsp;55, 9<br/>\n",
        "\n",
        "\n",
        "**Sample Output 2:**<br/>\n",
        "Given numbers in list: [7, 7, 7, 1, 0, 3, 3, 55, 9]\\\n",
        "List without any dupliacte values: [7, 1, 0, 3, 55, 9]<br/>\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OKaKCkKTbfeW",
        "outputId": "ca81d015-5286-4067-d2d1-66ed43c99a8c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter numbers and separates them by numbers: 7, 7, 7, 1,           0, 3\n",
            "Given numbers in list: ['7', ' 7', ' 7', ' 1', '           0', ' 3']\n"
          ]
        }
      ],
      "source": [
        "a=input(\"Enter numbers and separates them by numbers: \")\n",
        "g=a.split(\",\")\n",
        "print(\"Given numbers in list:\",g)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JWBh5VfTCNTh"
      },
      "source": [
        "### Task 22\n",
        "\"Write a python program that will take a number as an input and check whether the number is Awesome or not. If the number is Awesome, it prints True. Otherwise False.\n",
        "\n",
        "**Awesome number**: a number where every digit is less than its immediate left digit is called an Awesome number. A single-digit number cannot be an awesome number(e.g. 5421 is an Awesome number.\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input1:**\\\n",
        "976321\\\n",
        "**Sample Output1:**\\\n",
        "True\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input2:**\\\n",
        "9766321\\\n",
        "**Sample Output2:**\\\n",
        "False\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input3:**\\\n",
        "9\\\n",
        "**Sample Output3:**\\\n",
        "False\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input4:**\\\n",
        "78\\\n",
        "**Sample Output4:**\\\n",
        "False\n",
        "\n",
        "==========================================================\n",
        "\n",
        "**Sample Input5:**\\\n",
        "87\\\n",
        "**Sample Output5:**\\\n",
        "True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r3GHWRVO3vJA"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d3hSd6zNSNqT"
      },
      "source": [
        "# Theory Mid"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qj-k08ss3TvF",
        "outputId": "4c04ebbe-8a92-4fa3-f4f1-e1db4dfecb5d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ABK\n",
            "ebh\n",
            "!&%\n",
            "Ae!\n"
          ]
        }
      ],
      "source": [
        "a= \"A!e b&B %hK\"\n",
        "upper=\"\"\n",
        "lower=\"\"\n",
        "special=\"\"\n",
        "for i in a:\n",
        "  if 65<=ord(i)<=90:\n",
        "    upper+=i\n",
        "  elif 97<=ord(i)<=122:\n",
        "    lower+=i\n",
        "  elif 33<=ord(i)<=47:\n",
        "    special+=i\n",
        "  else:\n",
        "    continue\n",
        "print(upper)\n",
        "print(lower)\n",
        "print(special)\n",
        "n= upper[0]+lower[0]+special[0]\n",
        "print(n)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3gyrWN_-SnB3"
      },
      "source": [
        "# Lab Mid"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QTv37_aEfZfU",
        "outputId": "601e5dc3-f2fb-4121-a6c8-89d80abbca8e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "###e###"
          ]
        }
      ],
      "source": [
        "s= \"racecar\"\n",
        "for i in range(len(s)):\n",
        "  if s[i] in (s[:i]+s[i+1:]):\n",
        "    print('#',end=\"\")\n",
        "  else:\n",
        "    print(s[i],end='')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oowEPusGsG4y"
      },
      "source": [
        "# #<font color='blue'>Assignment 5 (Tuples And Dictionary)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EUjOSBH9MY7v"
      },
      "source": [
        "### #<font color='blue'>Part 1: Tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Xubf9IJsVrZ"
      },
      "source": [
        "### Task 1\n",
        "Assume, you have been given a tuple.\n",
        "\n",
        "**a_tuple =** (\"The Institute\", (\"Best Mystery & Thriller\", \"The Silent Patient\", 68821), 75717, [1, 2, 3, 400, 5, 6, 7], (\"Best Fiction\", \"The Testaments\", 98291))\n",
        "\n",
        "Write one line of Python code to access and print the value 400.\\\n",
        "===================================================================\\\n",
        "Output: 400\\\n",
        "===================================================================\\"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QC-HnacBsUlL",
        "outputId": "01d7b98b-ac6d-4354-c24c-4304cf593daa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "400\n"
          ]
        }
      ],
      "source": [
        "a_tuple= (\"The Institute\", (\"Best Mystery & Thriller\", \"The Silent Patient\", 68821), 75717, [1, 2, 3, 400, 5, 6, 7], (\"Best Fiction\", \"The Testaments\", 98291))\n",
        "print(a_tuple[3][3])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zBq1f0TlgXXX"
      },
      "source": [
        "### Task 2\n",
        "\n",
        "Assume, you have been given a tuple.\n",
        "\n",
        "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",
        "*Hint: You may use tuple slicing.*\\\n",
        "===================================================================\\\n",
        "Sample Input 1:\\\n",
        "(10, 20, 24, 25, 26, 35, 70)\\\n",
        "Sample Output 1:\\\n",
        "(24, 25, 26)\\\n",
        "===================================================================\\\n",
        "Sample Input 2:\\\n",
        "(-10, 20, 30, 40)\\\n",
        "Sample Output 2:\\\n",
        "()\\\n",
        "===================================================================\\\n",
        "Sample Input 3:\\\n",
        "(-10, 20, 25, 30, 40)\\\n",
        "Sample Output 3:\\\n",
        "(25,)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LjO_YnYa_CQ9",
        "outputId": "89b827eb-61a9-4ee4-f045-d7ab9876275e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a tuple: (-10, 20, 25, 30, 40)\n",
            "a= -10, 20, 25, 30, 40\n",
            "b= ['-10', ' 20', ' 25', ' 30', ' 40']\n",
            "c= (' 25',)\n",
            "d= [25]\n",
            "(25,)\n"
          ]
        }
      ],
      "source": [
        "user_input=input(\"Enter a tuple: \")\n",
        "a= user_input[1:-1]\n",
        "print(\"a=\",a)\n",
        "b=a.split(\",\")\n",
        "print(\"b=\",b)\n",
        "c=tuple(b[2:-2])\n",
        "print(\"c=\",c)\n",
        "d=[]\n",
        "for i in c:\n",
        "  d.append(int(i))\n",
        "print(\"d=\",d)\n",
        "e=tuple(d)\n",
        "print(e)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kaf-YWKLknI9",
        "outputId": "92623604-d040-4556-800a-1099536fcc49"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a tuple: (-10, 20, 25, 30, 40)\n",
            "(25,)\n"
          ]
        }
      ],
      "source": [
        "user_input=input(\"Enter a tuple: \")\n",
        "a= user_input[1:-1]\n",
        "b=a.split(\",\")\n",
        "c=tuple(b[2:-2])\n",
        "d=[]\n",
        "for i in c:\n",
        "  d.append(int(i))\n",
        "e=tuple(d)\n",
        "print(e)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ru-0lnWPvSNo"
      },
      "source": [
        "### Task 3\n",
        "Assume, you have been given a tuple.\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",
        "**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",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HLCCS7dN7h5h",
        "outputId": "8eb55773-299b-47f2-c221-477d6e8e5291"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "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"
          ]
        }
      ],
      "source": [
        " book_info = ((\"Best Mystery & Thriller\",\"The Silent Patient\",68,821),\n",
        "(\"Best Horror\",\"The Institute\",75,717),(\"Best History & Biography\",\"The five\",31,783 ),(\"Best Fiction\",\"The Testaments\",98,291))\n",
        "size=len(book_info)\n",
        "print(\"Size of the tuple is:\",size)\n",
        "for i in book_info:\n",
        "  print(i)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvpdOLsjD6VL"
      },
      "source": [
        "### Task 4\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",
        "[Must use Tuple unpacking for printing and need to handle the quotation marks as a part of the output]\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",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BfYQluL5Fpbe",
        "outputId": "576c46e0-4586-43ad-fea2-c37b712222ab"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The Silent Patient won the Best Mystery & Thriller with 68821 votes\n",
            "The Institute won the Best Horror with 75717 votes\n",
            "The five won the Best History & Biography with 31783 votes\n",
            "The Testaments won the Best Fiction with 98291 votes\n"
          ]
        }
      ],
      "source": [
        "book_info = ((\"Best Mystery & Thriller\",\"The Silent Patient\",68821), (\"Best Horror\",\"The Institute\",75717),\n",
        "(\"Best History & Biography\",\"The five\",31783 ), (\"Best Fiction\",\"The Testaments\",98291))\n",
        "for i in book_info:\n",
        "  x,y,z=i[0],i[1],i[2]\n",
        "  print(f\"{y} won the {x} with {z} votes\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1LRC3CUcHph1"
      },
      "source": [
        "### Task 5\n",
        "\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",
        "**Example 1:**\\\n",
        "Given tuple: (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)\\\n",
        "**Sample Input 1:**\\\n",
        "8\\\n",
        "**Sample Output 1:**\\\n",
        "8 appears 4 times in the tuple\\\n",
        "===================================================================\\\n",
        "**Example 2**\\\n",
        "Given tuple: (10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)\\\n",
        "**Sample Input 2:**\\\n",
        "1\\\n",
        "Sample Output 2:\\\n",
        "1 appears 0 times in the tuple\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UHx_vbf9Ieyd",
        "outputId": "00f45671-c81f-4788-b79e-99bd2c83e8de"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 8\n",
            "8 appears 4 times in the tuple\n"
          ]
        }
      ],
      "source": [
        "u=int(input(\"Enter a number: \"))\n",
        "given_tuple=(10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2)\n",
        "c=0\n",
        "for i in given_tuple:\n",
        "  if i==u:\n",
        "    c+=1\n",
        "print(f\"{u} appears {c} times in the tuple\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vOVcDdF3JrZk"
      },
      "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",
        "**Example 1:**\n",
        "Given tuple: ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')\\\n",
        "**Output:**\\\n",
        "('h', 'g', 'f', 'e', 'd', 'c', 'b', 'a')\\\n",
        "===================================================================\\\n",
        "**Example 2:**\\\n",
        "Given tuple: (10, 20, 30, 40, 50, 60)\\\n",
        "**Output:**\\\n",
        "(60, 50, 40, 30, 20, 10)\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xqAsn1-vKN8k",
        "outputId": "1a7263fd-c023-4733-a461-81f0a1acbb96"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('h', 'g', 'f', 'e', 'd', 'c', 'b', 'a')\n"
          ]
        }
      ],
      "source": [
        "g = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')\n",
        "lis1= list(g)\n",
        "d=[]\n",
        "for i in range(len(lis1)-1,-1,-1):\n",
        "  d.append(lis1[i])\n",
        "e=tuple(d)\n",
        "print(e)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "53A8otxvL89v"
      },
      "source": [
        "### #<font color='blue'>Part 2: Dictionary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AY57b-4BMxrc"
      },
      "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",
        "**Note:** You can use dictionary functions.\\\n",
        "===================================================================\\\n",
        "**Given:**\\\n",
        "{'Harry':15, 'Draco':8, 'Nevil':19}\\\n",
        "{'Ginie':18, 'Luna': 14}\\\n",
        "**Output:**\\\n",
        "{'Harry': 15, 'Draco': 8, 'Nevil': 19, 'Ginie': 18, 'Luna': 14}\\\n",
        "===================================================================\\\n",
        "**Given:**\\\n",
        "{'A':90, 'B': 0}\\\n",
        "{'C':50}\\\n",
        "**Output:**\\\n",
        "{'A': 90, 'B': 0, 'C': 50}\\\n",
        "===================================================================\\\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZzZvEagiMsf2",
        "outputId": "a462f61d-436d-4c44-9ea5-ab60cac6fe0d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'Harry': 15, 'Draco': 8, 'Nevil': 19, 'Ginie': 18, 'Luna': 14}\n"
          ]
        }
      ],
      "source": [
        "d1={'Harry':15, 'Draco':8, 'Nevil':19}\n",
        "d2={'Ginie':18, 'Luna': 14}\n",
        "d1.update(d2)\n",
        "print(d1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8hhB_K0GPsbo"
      },
      "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",
        "[You are not allowed to use len() and sum()]\\\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",
        "\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",
        "**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",
        "**Sample Input 1:**\\\n",
        "{'Jon': 100, 'Dan':200, 'Rob':300}\\\n",
        "**Sample Output 1:**\\\n",
        "Average is 200.\\\n",
        "===================================================================\\\n",
        "**Sample Input 2:**\\\n",
        "{'Jon': 100, 'Dan':200, 'Rob':30, 'Ned':110}\\\n",
        "**Sample Output 2:**\\\n",
        "Average is 110.\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UPgGMOnx0MvX",
        "outputId": "2f20b38e-78b5-4c22-bbef-5c20ba24212e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the length of dictionary: 4\n",
            "Enter the key: Jan\n",
            "Enter the value: 100\n",
            "Enter the key: Dan\n",
            "Enter the value: 200\n",
            "Enter the key: Rob\n",
            "Enter the value: 30\n",
            "Enter the key: Nerd\n",
            "Enter the value: 110\n",
            "Average is 110\n"
          ]
        }
      ],
      "source": [
        "d={}\n",
        "u=int(input(\"Enter the length of dictionary: \"))\n",
        "for i in range(u):\n",
        "    k=input(\"Enter the key: \")\n",
        "    v=int(input(\"Enter the value: \"))\n",
        "    d[k]=v\n",
        "vs=d.values()\n",
        "sum=0\n",
        "for i in vs:\n",
        "    sum+=i\n",
        "a=int(sum/u)\n",
        "print(\"Average is\",a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJno8HFQ45ZW"
      },
      "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",
        "**Sample Input 1:**\\\n",
        "170\\\n",
        "**Sample Output 1:**\\\n",
        "{'Cierra Vega': 175, 'Alden Cantrell': 200, 'Pierre Cox': 190}\\\n",
        "===================================================================\\\n",
        "**Sample Input 2:**\\\n",
        "190\\\n",
        "**Sample Output 2:**\\\n",
        "{'Alden Cantrell': 200, 'Pierre Cox': 190}\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dpabZlO4qU2H",
        "outputId": "1bb47819-a5b1-4de4-b967-02bb005863bb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a values: 170\n",
            "{'Cierra Vega': 175, 'Alden Cantrell': 200, 'Pierre Cox': 190}\n"
          ]
        }
      ],
      "source": [
        "n=int(input(\"Enter a values: \"))\n",
        "exam_marks = {'Cierra Vega': 175, 'Alden Cantrell': 200, 'Kierra Gentry': 165, 'Pierre Cox': 190}\n",
        "d={}\n",
        "for k, v in exam_marks.items():\n",
        "  if v>=n:\n",
        "    d[k]=v\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mRLPA6WEvN51"
      },
      "source": [
        "## Task 10\n",
        "Write a Python program that finds the largest value with its key from a given dictionary.\\\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",
        "\n",
        "**Hint:** *Think of membership operators (in and not in). You can use dictionary functions to get the values.*\\\n",
        "===================================================================\\\n",
        "Sample 1:\\\n",
        "**Given:**\\\n",
        "{'sci fi': 12, 'mystery': 15, 'horror': 8, 'mythology': 10, 'young_adult': 4, 'adventure':14}\\\n",
        "**Output:**\\\n",
        "The highest selling book genre is 'mystery' and the number of books sold are 15.\\\n",
        "===================================================================\\\n",
        "Sample 2:\\\n",
        "**Given:**\\\n",
        "{'sci fi': 5, 'mystery': 3, 'horror': 14, 'young_adult': 2, 'adventure':9}\\\n",
        "**Output:**\\\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": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-OkaC00-wZYE",
        "outputId": "1fbcb879-39d8-4b56-a873-26dedd373a46"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The highest selling book genre is 'mystery' and the number of books sold are 15.\n"
          ]
        }
      ],
      "source": [
        "d={'sci fi': 12, 'mystery': 15, 'horror': 8, 'mythology': 10, 'young_adult': 4, 'adventure':14}\n",
        "b=''\n",
        "n=0\n",
        "for k, v in d.items():\n",
        "  if v>n:\n",
        "    n=v\n",
        "    b=k\n",
        "  continue\n",
        "print(f\"The highest selling book genre is '{b}' and the number of books sold are {n}.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "47tqTa7jyzLG"
      },
      "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.\n",
        "**[You are not allowed to use the count() function]**\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",
        "**Sample Input:**\\\n",
        "\"Python programming is fun\"\\\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": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5yqs_KXAzVuF",
        "outputId": "a6d0c155-831e-445d-fe56-652464c3cb6e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: 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"
          ]
        }
      ],
      "source": [
        "s=input(\"Enter a string: \")\n",
        "l=s.lower()\n",
        "r=l.replace(\" \",\"\")\n",
        "d={}\n",
        "for c in r:\n",
        "  if c in d:\n",
        "    d[c] = d[c]+1\n",
        "  else:\n",
        "    d[c] = 1\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k-Ikhhmi8Ak6"
      },
      "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",
        "Output:\\\n",
        "9\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uDYM0OTJ8_1e",
        "outputId": "02cf1b12-7298-47de-d829-d103700f5b4b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "9\n"
          ]
        }
      ],
      "source": [
        "d = {'A': [1, 2, 3], 'b': ['1', '2'], \"c\": [4, 5, 6, 7]}\n",
        "l=[]\n",
        "for k, v in d.items():\n",
        "  l.append(v)\n",
        "n=0\n",
        "for i in l:\n",
        "  for j in range(len(i)):\n",
        "    n+=1\n",
        "print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EDTMlZoYMJoF"
      },
      "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",
        "**Output:**\n",
        "\n",
        "{'a': [1, 3, 2], 'b': [2, 1], 'c': [1]}\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "53WraRYUMNhK",
        "outputId": "f8d3c5de-b9bd-4857-d0da-c427e93906a7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': 2, 'b': 1, 'c': 1}\n"
          ]
        }
      ],
      "source": [
        "list_1 = [(\"a\", 1), (\"b\", 2), (\"a\", 3), (\"b\", 1), (\"a\", 2), (\"c\", 1)]\n",
        "t=tuple(list_1)\n",
        "d=dict((i,j) for i,j in t)\n",
        "print(d)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EJlsYYXKoCHJ",
        "outputId": "dfa1b413-c3f9-4851-b259-c392607d91bb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 3, 2]\n",
            "[2, 1]\n",
            "[1]\n",
            "(('a', [1, 3, 2]), ('b', [2, 1]), ('c', [1]))\n",
            "{'a': [1, 3, 2], 'b': [2, 1], 'c': [1]}\n"
          ]
        }
      ],
      "source": [
        "l = [(\"a\", 1), (\"b\", 2), (\"a\", 3), (\"b\", 1), (\"a\", 2), (\"c\", 1)]\n",
        "p=\"a\"\n",
        "q=\"b\"\n",
        "r=\"c\"\n",
        "s=[]\n",
        "u=[]\n",
        "t=[]\n",
        "for i,j in l:\n",
        "  if i in p:\n",
        "    s.append(j)\n",
        "  elif i in q:\n",
        "    u.append(j)\n",
        "  else:\n",
        "    t.append(j)\n",
        "print(s)\n",
        "print(u)\n",
        "print(t)\n",
        "n=((p,s),(q,u),(r,t))\n",
        "print(n)\n",
        "d=dict((i,j) for i,j in n)\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vcigVk1wsDCJ",
        "outputId": "20686608-4944-42b3-f6e0-7d701749516d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': [1, 3, 2], 'b': [2, 1], 'c': [1]}\n"
          ]
        }
      ],
      "source": [
        "given_list = [(\"a\", 1), (\"b\", 2), (\"a\", 3), (\"b\", 1), (\"a\", 2), (\"c\", 1)]\n",
        "p,q,r =\"a\",\"b\",\"c\"\n",
        "s,u,t =[],[],[]\n",
        "for i,j in given_list:\n",
        "  if i in p:\n",
        "    s.append(j)\n",
        "  elif i in q:\n",
        "    u.append(j)\n",
        "  else:\n",
        "    t.append(j)\n",
        "n=((p,s),(q,u),(r,t))\n",
        "d=dict((i,j) for i,j in n)\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZdQd4v3isRy0"
      },
      "source": [
        "# <font color='purple'> Task 14 is [ Tracing ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oJYDKqv6vmx9",
        "outputId": "c5b94d0e-c3fc-4e40-8694-d88aa017032f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n",
            "a -> 17\n",
            "10\n",
            "b -> 19\n",
            "2\n",
            "c -> 5\n",
            "-7\n",
            "d -> -14\n",
            "2\n",
            "e -> 5\n"
          ]
        }
      ],
      "source": [
        "dict1 = {'a':59 , 'b':-82 , 'c':5 , 'd':-81 , 'e':53}\n",
        "for i in dict1:\n",
        "    j = 0\n",
        "    k = 22\n",
        "    while j < 5:\n",
        "        if j % 2 == 0:\n",
        "            k = dict1[i] + j - (8 + k % 6) / 3\n",
        "            dict1[i] = dict1[i]+ int(k)\n",
        "        else:\n",
        "            k = dict1[i] + j - (6 - k % 8) * 3\n",
        "            dict1[i] = dict1[i] - int(k)\n",
        "        j += 1\n",
        "    print(int(k))\n",
        "    print(i + \" -> \" + str(dict1[i]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lsM5YUGysb5h"
      },
      "source": [
        "## Task 15\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",
        "**Example 1:**\\\n",
        "Given:\\\n",
        "[(2, 3), (4, 5), (6, 7), (2, 8)]\\\n",
        "**Output:**\\\n",
        "[6, 20, 42, 16]\\\n",
        "===================================================================\\\n",
        "**Example 2:**\\\n",
        "Given:\\\n",
        "[(11, 22), (33, 55), (55, 77), (11, 44)]\\\n",
        "**Output:**\\\n",
        "[242, 1815, 4235, 484]\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mBqSX216tcC6",
        "outputId": "f7bcb075-4472-4ead-c1b9-0153dd1f1276"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[242, 1815, 4235, 484]\n"
          ]
        }
      ],
      "source": [
        "g= [(11, 22), (33, 55), (55, 77), (11, 44)]\n",
        "n=[]\n",
        "for i in g:\n",
        "  m=1\n",
        "  for j in i:\n",
        "    m*=j\n",
        "  fm = m\n",
        "  n.append(fm)\n",
        "print(n)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eBq9K7J5v1a9"
      },
      "source": [
        "## Task 16\n",
        "Assume, you have been given a tuple as below.\\\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",
        "**Sample Input 1:**\\\n",
        "abc\\\n",
        "**Sample Output 1:**\\\n",
        "([1, 2, 'abc'], [4, 5, 'abc'], [7, 8, 'abc'], [10, 11, 'abc'])\\\n",
        "===================================================================\\\n",
        "**Sample Input 1:**\\\n",
        "1000\\\n",
        "**Sample Output 1:**\\\n",
        "([1, 2, '1000'], [4, 5, '1000'], [7, 8, '1000'], [10, 11, '1000'])\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hE07lO5ZwaNT",
        "outputId": "c616eda9-a7af-47bc-ba3f-13217107cee9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter Something: 1000\n",
            "([1, 2, '1000'], [4, 5, '1000'], [7, 8, '1000'], [10, 11, '1000'])\n"
          ]
        }
      ],
      "source": [
        "a_tuple = ( [1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12])\n",
        "u= input(\"Enter Something: \")\n",
        "l=[]\n",
        "for i in a_tuple:\n",
        "  i[2]=u\n",
        "  y=i\n",
        "  l.append(y)\n",
        "t=tuple(l)\n",
        "print(t)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pVWi0Tnkwbyh"
      },
      "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",
        "**Output:**\\\n",
        "{'c1':'Red', 'c2':'Green', 'd4':'Blue'}\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gEi2VW_QwyRf",
        "outputId": "847caf54-c735-46ed-f61d-036032798ec1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'c1': 'Red', 'c2': 'Green', 'd4': 'Blue'}\n"
          ]
        }
      ],
      "source": [
        "my_dictionary = {'c1':'Red', 'c2':'Green', 'c3':None, 'd4':'Blue', 'a5':None}\n",
        "n={}\n",
        "for i,j in my_dictionary.items():\n",
        "  if j!=None:\n",
        "    n[i]=j\n",
        "print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XpuG1I4Hw0FR"
      },
      "source": [
        "## Task 18\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",
        "**Sample Input 1:**\\\n",
        "9, 12\\\n",
        "**Sample Output 1:**\\\n",
        "{'c': 9, 'e': 11}\\\n",
        "**Explanation:** Keys with values within the range of 9 and 11 are extracted.\n",
        "===================================================================\\\n",
        "**Sample Input 2:**\\\n",
        "14, 18\\\n",
        "**Sample Output 2:**\\\n",
        "{}\\\n",
        "**Explanation:** No values in range.\n",
        "\n",
        "==================================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TG6ZF-CNxncr",
        "outputId": "f76e29de-6d2e-4097-9422-ba8aaad20f65"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the lower range: 9\n",
            "Enter the upper range: 12\n",
            "{'c': 9, 'e': 11}\n"
          ]
        }
      ],
      "source": [
        "dict_1 = {'a' : 6, 'b' : 7, 'c' : 9, 'd' : 8, 'e' : 11, 'f' : 12, 'g' : 13}\n",
        "x=int(input(\"Enter the lower range: \"))\n",
        "y=int(input(\"Enter the upper range: \"))\n",
        "d={}\n",
        "for k,v in dict_1.items():\n",
        "  if v>=x and v<y:\n",
        "    d[k]=v\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZB38Ye64xpcX"
      },
      "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",
        "\n",
        "[You do not need to take tuple as input and can assume that it is given as below]\\\n",
        "===================================================================\\\n",
        "**Example 1:**\\\n",
        "Given:\\\n",
        "[(20, 80), (31, 80), (1, 22), (88, 11), (27, 11)]\\\n",
        "**Output:**\\\n",
        "{80: [(20, 80), (31, 80)],\\\n",
        "11: [(88, 11), (27, 11)],\\\n",
        "22: [(1, 22)]}\\\n",
        "===================================================================\\\n",
        "**Example 2:**\\\n",
        "Given:\\\n",
        "[(20, 'Sad'), (31, 'Sad'), (88, 'NotSad'), (27, 'NotSad')]\\\n",
        "**Output:**\\\n",
        "{'NotSad': [(88, 'NotSad'), (27, 'NotSad')],\\\n",
        "'Sad: [(20, 'Sad'), (31, 'Sad')]}\n",
        "\n",
        "===================================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qf08mk4MysGK",
        "outputId": "204a3f4b-f273-4cc1-8a66-f0d240c70b49"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{80: [(20, 80), (31, 80)], 11: [(88, 11), (27, 11)], 22: (1, 22)}\n"
          ]
        }
      ],
      "source": [
        "g= [(20, 80), (31, 80), (1, 22), (88, 11), (27, 11)]\n",
        "d= dict(g)\n",
        "s=[]\n",
        "for k,v in d.items():\n",
        "  if v not in s:\n",
        "    s.append(v)\n",
        "l1=[g[0],g[1]]\n",
        "l2=[g[3],g[4]]\n",
        "l3=g[2]\n",
        "f={}\n",
        "f[s[0]]=l1\n",
        "j={}\n",
        "j[s[2]]=l2\n",
        "h={}\n",
        "h[s[1]]=l3\n",
        "f.update(j)\n",
        "f.update(h)\n",
        "print(f)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kh9MSdxNyuCj"
      },
      "source": [
        "## Task 20\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",
        "==========================================================\n",
        "\n",
        "**The formula:**\\\n",
        "<font color='blue'>**Index value of special character list = (ASCII sum of the word) % (length of special character list)**\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",
        "\n",
        "**Explanation:** From the string 'I love Programming. Python is love.' the {key: value} pair is calculated accordingly:\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",
        "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",
        "**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:** 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",
        "|starde| 759 | 5 | 759 % 5 = 4 | '%' |\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",
        "=========================================================="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ZA_FUxC4SaZ",
        "outputId": "b4648333-c9cb-4038-d331-126f555e77a3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Words in the given String: ['The', 'secret', 'of', 'getting', 'ahead', 'is', 'getting', 'started']\n",
            "Answer: {'%': ['The', 'getting', 'ahead', 'started'], '=': ['secret'], '-': ['is']}\n"
          ]
        }
      ],
      "source": [
        "s= \"The secret of getting ahead is getting started.\"\n",
        "li_1= ['-', '=', '+', '*', '%']\n",
        "le=len(li_1)\n",
        "a=s.replace('.','')\n",
        "Word=a.split(' ')\n",
        "print(\"Words in the given String:\",Word)\n",
        "d=[]\n",
        "for i in Word:\n",
        "  ASCII_sum=0\n",
        "  for j in i:\n",
        "    ASCII_sum+= ord(j)\n",
        "  b= ASCII_sum\n",
        "  c= b % le #Index value of special character list = (ASCII sum of the word) % (length of special character list)\n",
        "  d.append((i,c))\n",
        "n0=[]\n",
        "n1=[]\n",
        "n2=[]\n",
        "n3=[]\n",
        "n4=[]\n",
        "for simi,val in d:\n",
        "  if val==(le-le) and simi not in n0:\n",
        "    n0.append(simi)\n",
        "  elif val==(le-(le-1)) and simi not in n1:\n",
        "    n1.append(simi)\n",
        "  elif val==(le-(le-2)) and simi not in n2:\n",
        "    n2.append(simi)\n",
        "  elif val==(le-(le-3)) and simi not in n3:\n",
        "    n3.append(simi)\n",
        "  elif val==(le-(le-4)) and simi not in n4:\n",
        "    n4.append(simi)\n",
        "n=((li_1[4],n4),(li_1[1],n1),(li_1[0],n0))\n",
        "d=dict((i,j) for i,j in n)\n",
        "print(\"Answer:\" ,d)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sz709yddV97K",
        "outputId": "af957570-d118-4ddf-c6bb-7cf81d94ddb1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Words in the given String: ['I', 'love', 'Programming', 'Python', 'is', 'love']\n",
            "Answer: {'$': ['I'], '&': ['love', 'Python'], '#': ['Programming'], '@': ['is']}\n"
          ]
        }
      ],
      "source": [
        "s= 'I love Programming. Python is love.'\n",
        "li_1= ['@', '$', '&', '#']\n",
        "le=len(li_1)\n",
        "a=s.replace('.','')\n",
        "Word=a.split(' ')\n",
        "print(\"Words in the given String:\",Word)\n",
        "d=[]\n",
        "for i in Word:\n",
        "  ASCII_sum=0\n",
        "  for j in i:\n",
        "    ASCII_sum+= ord(j)\n",
        "  b= ASCII_sum\n",
        "  c= b % le #Index value of special character list = (ASCII sum of the word) % (length of special character list)\n",
        "  d.append((i,c))\n",
        "n0=[]\n",
        "n1=[]\n",
        "n2=[]\n",
        "n3=[]\n",
        "for simi,val in d:\n",
        "  if val==(le-le) and simi not in n0:\n",
        "    n0.append(simi)\n",
        "  elif val==(le-(le-1)) and simi not in n1:\n",
        "    n1.append(simi)\n",
        "  elif val==(le-(le-2)) and simi not in n2:\n",
        "    n2.append(simi)\n",
        "  elif val==(le-(le-3)) and simi not in n3:\n",
        "    n3.append(simi)\n",
        "n=((li_1[1],n1),(li_1[2],n2),(li_1[3],n3),(li_1[0],n0))\n",
        "d=dict((i,j) for i,j in n)\n",
        "print(\"Answer:\" ,d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SBePYHSKblSP",
        "outputId": "9a93bb6a-548a-49c8-8f67-152ffe9d8278"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'@': [], '$': [], '&': [], '#': []}\n",
            "Words in the given String: ['I', 'love', 'Programming', 'Python', 'is', 'love']\n",
            "[('I', 1), ('love', 2), ('Programming', 3), ('Python', 2), ('is', 0), ('love', 2)]\n",
            "Answer: {'$': ['I'], '&': ['love', 'Python'], '#': ['Programming'], '@': ['is']}\n"
          ]
        }
      ],
      "source": [
        "s= 'I love Programming. Python is love.'\n",
        "li_1= ['@', '$', '&', '#']\n",
        "t={}\n",
        "for i in li_1:\n",
        "  t[i]=[]\n",
        "print(t)\n",
        "le=len(li_1)\n",
        "a=s.replace('.','')\n",
        "Word=a.split(' ')\n",
        "print(\"Words in the given String:\",Word)\n",
        "d=[]\n",
        "for i in Word:\n",
        "  ASCII_sum=0\n",
        "  for j in i:\n",
        "    ASCII_sum+= ord(j)\n",
        "  b= ASCII_sum\n",
        "  c= b % le #Index value of special character list = (ASCII sum of the word) % (length of special character list)\n",
        "  d.append((i,c))\n",
        "print(d)\n",
        "n0=[]\n",
        "n1=[]\n",
        "n2=[]\n",
        "n3=[]\n",
        "for simi,val in d:\n",
        "  if val==(le-le) and simi not in n0:\n",
        "    n0.append(simi)\n",
        "  elif val==(le-(le-1)) and simi not in n1:\n",
        "    n1.append(simi)\n",
        "  elif val==(le-(le-2)) and simi not in n2:\n",
        "    n2.append(simi)\n",
        "  elif val==(le-(le-3)) and simi not in n3:\n",
        "    n3.append(simi)\n",
        "n=((li_1[1],n1),(li_1[2],n2),(li_1[3],n3),(li_1[0],n0))\n",
        "d=dict((i,j) for i,j in n)\n",
        "print(\"Answer:\" ,d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vhDudcS8MRbC"
      },
      "outputs": [],
      "source": [
        "li_1= ['@', '$', '&', '#']\n",
        "d={}\n",
        "for i in li_1:\n",
        "  d[i]=[]\n",
        "s= 'I love Programming. Python is love.'\n",
        "le=len(li_1)\n",
        "a=s.replace('.','')\n",
        "Word=a.split(' ')\n",
        "print(\"Words in the given String:\",Word)\n",
        "for k in Word:\n",
        "  ASCII_sum=0\n",
        "  for j in k:\n",
        "    ASCII_sum+= ord(j)\n",
        "  b= ASCII_sum\n",
        "  c= b % le #Index value of special character list = (ASCII sum of the word) % (length of special character list)\n",
        "    d[i].append(c)\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pY__kd4ac3Ph"
      },
      "source": [
        "# #<font color='blue'>Assignment 6 (Function)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IotXfrTUc_ma"
      },
      "source": [
        "## Task 1\n",
        "Write a function called **even_checker** that takes a number as an argument and prints whether the number is even or odd **inside the function**.\\\n",
        "===================================================================\\\n",
        "**Example 1:**\\\n",
        "**Function Call:**\\\n",
        "even_checker(5)\\\n",
        "**Output:**\\\n",
        "Odd!!\\\n",
        "===================================================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "even_checker(2)\\\n",
        "**Output:**\\\n",
        "Even!!\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kAy2ntGv2a1H",
        "outputId": "281530fc-3031-48fb-daae-d7c769f9567a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 5\n",
            "Odd!!\n"
          ]
        }
      ],
      "source": [
        "def even_checker(n):\n",
        "  if n%2==0:\n",
        "    print(\"Even!!\")\n",
        "  else:\n",
        "    print(\"Odd!!\")\n",
        "n=int(input(\"Enter a number: \"))\n",
        "even_checker(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJltCMX9tqtO"
      },
      "source": [
        "## Task 2\n",
        "Write a python function that takes the limit as an argument of the Fibonacci series and prints till that limit.\\\n",
        "===================================================================\\\n",
        "**Function Call:**\\\n",
        "fibonacci(10)\\\n",
        "**Output:**\\\n",
        "0 1 1 2 3 5 8\\\n",
        "===================================================================\\\n",
        "**Function Call:**\\\n",
        "fibonacci(5)\\\n",
        "**Output:**\\\n",
        "0 1 1 2 3 5\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UNBgw028uB79",
        "outputId": "001c6d53-b5d5-4e2f-a0f8-921a30260d8e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 10\n",
            "0 1 1 2 3 5 8 "
          ]
        }
      ],
      "source": [
        "def fibonacci(number):\n",
        "  First_Value, Second_Value = 0, 1\n",
        "  i = 0\n",
        "  while i <= number:\n",
        "    if First_Value<=number:\n",
        "      print(First_Value, end=\" \")\n",
        "    Sum = First_Value + Second_Value\n",
        "# update values\n",
        "    First_Value = Second_Value\n",
        "    Second_Value = Sum\n",
        "    i += 1\n",
        "number=int(input(\"Enter a number: \"))\n",
        "fibonacci(number)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JxZ2fH3m4KZg"
      },
      "source": [
        "## Task 3\n",
        "Write a function called **foo_moo** that takes a number as an argument and **returns** the following statements according to the below mentioned conditions. Then, finally prints the statement in the function call.\n",
        "\n",
        " * If the number is divisible by 2, it should return \"Foo\".\n",
        " * If the number is divisible by 3, it should return \"Moo\".\n",
        " * If the number is divisible by both 2 and 3, it should return \"FooMoo\".\n",
        " * Otherwise, it returns \"Boo\".\n",
        "\n",
        "====================================================================\n",
        "\n",
        "**Example1:**\\\n",
        "**Function Call:**\\\n",
        "foo_moo(5)\\\n",
        "**Output:**\\\n",
        "Boo\\\n",
        "===================================================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "foo_moo(4)\\\n",
        "**Output:**\\\n",
        "Foo\\\n",
        "===================================================================\\\n",
        "**Example3:**\\\n",
        "**Function Call:**\\\n",
        "foo_moo(6)\\\n",
        "**Output:**\\\n",
        "FooMoo\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n_LTbHt4Msm6",
        "outputId": "d65c2ec5-8ddf-433f-b5f7-602c160e452a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 6\n",
            "FooMoo\n"
          ]
        }
      ],
      "source": [
        "def foo_moo(x):\n",
        "  if x%2==0 and x%3==0:\n",
        "    print(\"FooMoo\")\n",
        "  elif x%2==0:\n",
        "    print(\"Foo\")\n",
        "  elif x%3==0:\n",
        "    print(\"Moo\")\n",
        "  else:\n",
        "    print(\"Boo\")\n",
        "x=int(input(\"Enter a number: \"))\n",
        "foo_moo(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5JL-aamOZRF"
      },
      "source": [
        "## Task 4\n",
        "Write a python function that takes a string as an argument. Your task is to calculate the number of uppercase letters and lowercase letters and print them in the function.\\\n",
        "====================================\\\n",
        "**Function Call:**\\\n",
        "function_name('The quick Sand Man')\\\n",
        "**Output:**\\\n",
        "No. of Uppercase characters : 3\\\n",
        "No. of Lowercase Characters: 12\\\n",
        "==================================\\\n",
        "**Function Call:**\\\n",
        "function_name('HaRRy PotteR')\\\n",
        "**Output:**\\\n",
        "No. of Uppercase characters : 5\\\n",
        "No. of Lowercase Characters: 6\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxB5czTaO-3F",
        "outputId": "592c54a0-e741-4b46-d12e-3ff8f9d499b5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a string: The quick Sand Man\n",
            "No. of Uppercase characters: 3\n",
            "No. of Lowercase characters: 12\n"
          ]
        }
      ],
      "source": [
        "def function_name(n):\n",
        "    u = 0\n",
        "    l = 0\n",
        "    for i in n:\n",
        "        for j in i:\n",
        "            if \"A\" <= i <= \"Z\":\n",
        "                u += 1\n",
        "            elif \"a\" <= i <= \"z\":\n",
        "                l += 1\n",
        "    print (\"No. of Uppercase characters:\", u)\n",
        "    print (\"No. of Lowercase characters:\", l)\n",
        "n=input(\"Enter a string: \")\n",
        "function_name(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qMf8z5Gsa2Mb"
      },
      "source": [
        "## Task 5\n",
        "Write a function called **calculate_tax** that takes 3 arguments: your age, salary, and current job designation.\n",
        "\n",
        "Your first task is to take these arguments as user input and pass these values to the function.\n",
        "\n",
        "Your second task is to implement the function and calculate the tax as the following conditions:\n",
        "\n",
        "* **NO TAX IF YOU ARE LESS THAN 18 YEARS OLD.**\n",
        "* **NO TAX IF YOU ARE THE PRESIDENT OF THE COMPANY**\n",
        "* No tax if you get paid less than 10,000\n",
        "* 5% tax if you get paid between 10K and 20K\n",
        "* 10% tax if you get paid more than 20K\n",
        "\n",
        "Finally return this tax value. Then print the returned value in the function call.\\\n",
        "===================================\\\n",
        "**Hints:**\\\n",
        "Here the job designation is a string, so it can be written in both uppercase and lower cases. So, you need to check the value ignoring the case.\\\n",
        "===================================\\\n",
        "**Example1:**\\\n",
        "**Input:**\\\n",
        "16\\\n",
        "20000\\\n",
        "Student\\\n",
        "**Function Call:**\\\n",
        "calculate_tax(16, 20000, 'Student')\\\n",
        "**Output:**\\\n",
        "0\\\n",
        "===================================\\\n",
        "**Example2:**\\\n",
        "**Input:**\\\n",
        "20\\\n",
        "18000\\\n",
        "assistant manager\\\n",
        "**Function Call:**\\\n",
        "calculate_tax(20, 18000, 'assistant manager')\\\n",
        "**Output:**\\\n",
        "900.0\\\n",
        "===================================\\\n",
        "**Example3:**\\\n",
        "**Input:**\\\n",
        "20\\\n",
        "22000\\\n",
        "assistant manager\\\n",
        "**Function Call:**\\\n",
        "calculate_tax(20, 22000, 'Assistant manager')\\\n",
        "**Output:**\n",
        "2200.0\\\n",
        "===================================\\\n",
        "**Example4:**\\\n",
        "**Input:**\\\n",
        "20\\\n",
        "122000\\\n",
        "president\\\n",
        "**Function Call:**\\\n",
        "calculate_tax(20, 122000, 'president')\\\n",
        "**Output:**\\\n",
        "0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Sfzu-1JzvJM",
        "outputId": "a8f45428-bec9-48a0-f4c7-f8bd6bf7fbc2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter your age: 20\n",
            "Enter your salary: 22000\n",
            "Enter your job designation: assistant manager\n",
            "2200.0\n"
          ]
        }
      ],
      "source": [
        "def calculate_tax(a,s,d):\n",
        "  tax=0\n",
        "  if a<18 or d==\"president\" or d==\"President\" or s<10000:\n",
        "    print(tax)\n",
        "  elif 10000<=s<=20000 :\n",
        "    tax= s*(5/100)\n",
        "    print(tax)\n",
        "  else:\n",
        "    tax= s*(10/100)\n",
        "    print(tax)\n",
        "calculate_tax(a=int(input(\"Enter your age: \")),s=int(input(\"Enter your salary: \")),d=input(\"Enter your job designation: \"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h3a_CBMBeEb4",
        "outputId": "471ca0fa-5776-4376-e825-06459dc6cf14"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter your age: 20\n",
            "Enter your salary: 22000\n",
            "Enter your job designation: assistant manager\n",
            "2200.0\n"
          ]
        }
      ],
      "source": [
        "def calculate_tax(a,s,d):\n",
        "  tax=0\n",
        "  if a<18 or d==\"president\" or d==\"President\" or s<10000:\n",
        "    print(tax)\n",
        "  elif 10000<=s<=20000 :\n",
        "    tax= s*(5/100)\n",
        "    print(tax)\n",
        "  else:\n",
        "    tax= s*(10/100)\n",
        "    print(tax)\n",
        "a=int(input(\"Enter your age: \"))\n",
        "s=int(input(\"Enter your salary: \"))\n",
        "d=input(\"Enter your job designation: \")\n",
        "calculate_tax(a,s,d)\n",
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkCjjX5VC5ln"
      },
      "source": [
        "## Task 6\n",
        "Write a function which will take 1 argument, number of days.\n",
        "\n",
        "Your first task is to take the number of days as user input and pass the value to the function.\n",
        "\n",
        "Your second task is to implement the function and calculate the total number of years, number of months, and the remaining number of days as output. No need to return any value, print inside the function.\n",
        "\n",
        "**Note:** Assume, each year to be 365 days and month to be 30 days.\\\n",
        "=====================================================\\\n",
        "**Hint(1):** Divide and mod the main input to get the desired output.\\\n",
        "**Hint(2):** This task’s calculation is similar to Assignment-1’s seconds to hours, minutes conversion.\\\n",
        "=====================================================\\\n",
        "**Example01**\\\n",
        "**Input:**\\\n",
        "4330\\\n",
        "**Function Call:**\\\n",
        "function_name(4330)\\\n",
        "**Output:**\\\n",
        "11 years, 10 months and 15 days\\\n",
        "=====================================================\\\n",
        "**Example02**\\\n",
        "**Input:**\\\n",
        "2250\\\n",
        "**Function Call:**\\\n",
        "function_name(2250)\\\n",
        "**Output:**\\\n",
        "6 years, 2 months and 0 days"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_mPHR90vC8i4",
        "outputId": "40c02d04-ff62-4b53-af6c-8421bfd9a2e9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the number of days: 2250\n",
            "6 years, 2 months and 0 days\n"
          ]
        }
      ],
      "source": [
        "def y_m_d(u):\n",
        "  if u>=365 :\n",
        "    years = u // 365\n",
        "    m = u % 365\n",
        "    months = m // 30\n",
        "    days = m % 30\n",
        "    print(f\"{years} years, {months} months and {days} days\")\n",
        "  else:\n",
        "    years = 0\n",
        "    months = u // 30\n",
        "    days = u % 30\n",
        "    print(f\"{years} years, {months} months and {days} days\")\n",
        "u= int(input(\"Enter the number of days: \"))\n",
        "y_m_d(u)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WkOb00s34iiV"
      },
      "source": [
        "## Task 7\n",
        "Write a function called **show_palindrome** that takes a number as an argument and then returns a palindrome string. Finally, prints the returned value in the function call.\\\n",
        "=====================================================\\\n",
        "**Example1:**\\\n",
        "**Function Call:**\\\n",
        "show_palindrome(5)\\\n",
        "**Output:**\\\n",
        "123454321\\\n",
        "===================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "show_palindrome(3)\\\n",
        "**Output:**\\\n",
        "12321\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hd9loemJ9DSc",
        "outputId": "df4792e6-f59a-4c76-9474-c9112e5cf0e5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 5\n",
            "123454321"
          ]
        }
      ],
      "source": [
        "def show_palindrome(n):\n",
        "  for i in range(1, n):\n",
        "    print(str(i),end=\"\")\n",
        "  for i in range(n, 0, -1):\n",
        "    print(str(i),end=\"\")\n",
        "show_palindrome(n=int(input(\"Enter a number: \")))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O1sH1VZu9dR1"
      },
      "source": [
        "## Task 8\n",
        "Write a function called **show_palindromic_triangle** that takes a number as an argument and prints a Palindromic Triangle in the function.\\\n",
        "**[Must reuse the show_palindrome() function of the previous task]**\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Hints:**\\\n",
        "Need to use both print() and print( , end = \" \") functions\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example1:**\n",
        "**Function Call:**\n",
        "show_palindromic_triangle(5)\n",
        "**Output:**\n",
        "                \n",
        "....................1\\\n",
        "...............1...2...1\\\n",
        "..........1...2...3...2...1\\\n",
        ".....1...2...3...4...3...2...1\\\n",
        "1...2...3...4...5...4...3...2...1\\\n",
        "=============================================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "show_palindromic_triangle(3)\\\n",
        "**Output:**\\\n",
        "....................1\\\n",
        "...............1...2...1\\\n",
        "..........1...2...3...2...1\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oyLmElSjCl9t",
        "outputId": "007ddaee-dfec-44c4-abe9-77368985fc47"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a number: 5\n",
            "            \n",
            "          1 \n",
            "        1 2 1 \n",
            "      1 2 3 2 1 \n",
            "    1 2 3 4 3 2 1 \n",
            "  1 2 3 4 5 4 3 2 1 \n"
          ]
        }
      ],
      "source": [
        "def show_palindromic_triangle(n):\n",
        "  for i in range(0,n+1):\n",
        "    for j in range(i,n+1): #For printing spaces\n",
        "      print(\" \",end=\" \")\n",
        "    for j in range(1,i+1): # For increasing\n",
        "      print(j,end=\" \")\n",
        "    for j in range(i-1,0,-1): #For decresing\n",
        "      print(j,end=\" \")\n",
        "    print() #For new line\n",
        "n=int(input(\"Enter a number: \"))\n",
        "show_palindromic_triangle(n)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-F6iBE0LUjBQ"
      },
      "source": [
        "## Task 9\n",
        "Write a function called **area_circumference_generator** that takes a radius of a circle as a function parameter and calculates its circumference and area. Then returns these two results as a **tuple** and prints the results using tuple unpacking in the function call according to the given format.\n",
        "\n",
        "**[Must use tuple packing & unpacking]**\n",
        "=====================================================\\\n",
        "**Example1:**\\\n",
        "Function Call:\\\n",
        "area_circumference_generator(1)\\\n",
        "**Output:**\\\n",
        "(3.141592653589793, 6.283185307179586)\\\n",
        "Area of the circle is 3.141592653589793 and circumference is 6.283185307179586\\\n",
        "====================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "area_circumference_generator(1.5)\\\n",
        "**Output:**\\\n",
        "(7.0685834705770345, 9.42477796076938)\\\n",
        "Area of the circle is 7.0685834705770345 and circumference is 9.42477796076938\\\n",
        "====================================\\\n",
        "**Example3:**\\\n",
        "**Function Call:**\\\n",
        "area_circumference_generator(2.5)\\\n",
        "**Output:**\\\n",
        "(19.634954084936208, 15.707963267948966)\\\n",
        "Area of the circle is 19.634954084936208 and circumference is 15.707963267948966\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_6UhHw8CXo7M",
        "outputId": "25d3374a-bd6f-472a-e5e7-b6d17c3d5c21"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a radius: 1\n",
            "(3.141592653589793, 6.283185307179586)\n",
            "Area of the circle is 3.141592653589793 and circumference is 6.283185307179586\n"
          ]
        }
      ],
      "source": [
        "def area_circumference_generator(r):\n",
        "  import math\n",
        "  area=math.pi*(r**2)\n",
        "  circumference=2*math.pi*r\n",
        "  t=(area,circumference)\n",
        "  print(t)\n",
        "  x,y=t\n",
        "  print(f\"Area of the circle is {x} and circumference is {y}\")\n",
        "area_circumference_generator(r=float(input(\"Enter a radius: \")))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1hmQnnl5l9Kw"
      },
      "source": [
        "## Task 10\n",
        "Write a function called **make_square** that takes a tuple in the parameter as a range of numbers (starting point and ending point (included)). The function should **return a dictionary** with the numbers as keys and its squares as values.\\\n",
        "=====================================================\\\n",
        "**Hints:**\\\n",
        "You need to declare a dictionary to store the result. You should use the range function to run the “for loop”.\\\n",
        "=====================================================\\\n",
        "**Example1:**\\\n",
        "**Function Call:**\\\n",
        "make_square((1,3))\\\n",
        "**Output:**\\\n",
        "{1: 1, 2: 4, 3: 9}\\\n",
        "====================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "make_square((5,9))\\\n",
        "**Output:**\\\n",
        "{5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tX_AIsazotxc",
        "outputId": "f624419a-0192-4bb5-e560-d6f6a19ab93e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{5: 25, 6: 36, 7: 49, 8: 64, 9: 81}"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def make_square(u):\n",
        "  d={}\n",
        "  t=(5,9)\n",
        "  for i in range(t[0],t[1]+1,1):\n",
        "    a= i*i\n",
        "    d[i]=a\n",
        "  return d\n",
        "make_square((5,9))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J40AXgnyHO1A"
      },
      "source": [
        "## Task 11\n",
        "Write a function called rem_duplicate that takes a tuple in the parameter and return a tuple removing all the duplicate values. Then print the returned tuple in the function call.\\\n",
        "**[Cannot use remove() or removed() for this task]**\\\n",
        "=====================================================\\\n",
        "**Hints:**\\\n",
        "Unlike lists, tuples are immutable, so the tuple taken as an argument cannot be modified. But the list can be modified and lastly for returning the result use type conversion. You need to use membership operators (in, not in) for preventing adding any duplicates values.\\\n",
        "=====================================================\\\n",
        "**Example1:**\\\n",
        "**Function Call:**\\\n",
        "rem_duplicate((1,1,1,2,3,4,5,6,6,6,6,4,0,0,0))\\\n",
        "**Output:**\\\n",
        "(1, 2, 3, 4, 5, 6, 0)\\\n",
        "=====================================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "rem_duplicate((\"Hi\", 1, 2, 3, 3, \"Hi\",'a', 'a', [1,2]))\\\n",
        "**Output:**\\\n",
        "('Hi', 1, 2, 3, 'a', [1, 2])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oIE4yjRjH_Wn",
        "outputId": "c68880f6-0ee3-4396-8be3-5d14c90c7016"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a tuple: (\"Hi\", 1, 2, 3, 3, \"Hi\",'a', 'a', [1,2])\n",
            "('Hi', 1, 2, 3, 'a', [1, 2])\n"
          ]
        }
      ],
      "source": [
        "u=tuple(eval(input(\"Enter a tuple: \"))) #eval can read input's data type\n",
        "def rem_duplicate(u):\n",
        "  l=[]\n",
        "  for i in u:\n",
        "    if i not in l:\n",
        "      l.append(i)\n",
        "  t=tuple(l)\n",
        "  print(t)\n",
        "rem_duplicate(u)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xO6S6IIdcIx5"
      },
      "source": [
        "## Task 12\n",
        "Write a python function that takes a list as an argument. Your task is to create a new list where each element can be present at max 2 times. Inside the function, print the number of elements removed from the given list. Finally, return the new list and print the result\\.\n",
        "=====================================================\\\n",
        "Hint: You may use list_name.count(element) to count the total number of times an element is in a list. list_name is your new list for this problem.\\\n",
        "=====================================================\\\n",
        "Function Call:\\\n",
        "function_name([1, 2, 3, 3, 3, 3, 4, 5, 8, 8])\\\n",
        "Output:\\\n",
        "Removed: 2\\\n",
        "[1, 2, 3, 3, 4, 5, 8, 8]\\\n",
        "================================\\\n",
        "Function Call:\\\n",
        "function_name([10, 10, 15, 15, 20])\\\n",
        "Output:\\\n",
        "Removed: 0\\\n",
        "[10, 10, 15, 15, 20]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lBTgN7DSv10y",
        "outputId": "7382e628-8924-4583-c55d-fee6f4373db1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter element's numbers of the list: 5\n",
            "Ënter a number: 10\n",
            "Ënter a number: 10\n",
            "Ënter a number: 15\n",
            "Ënter a number: 15\n",
            "Ënter a number: 20\n",
            "0\n",
            "[10, 10, 15, 15, 20]\n"
          ]
        }
      ],
      "source": [
        "def function_name(l):\n",
        "  n=[]\n",
        "  for i in l:\n",
        "    if n.count(i)<2:\n",
        "      n.append(i)\n",
        "  r= len(l)-len(n)\n",
        "  print(r)\n",
        "  print(n)\n",
        "l=[]\n",
        "\n",
        "u=int(input(\"Enter element's numbers of the list: \"))\n",
        "for i in range(u):\n",
        "  l.append(int(input(\"Ënter a number: \")))\n",
        "function_name(l)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kp01yBR3inMQ"
      },
      "source": [
        "## Task 13\n",
        "Write a python function that will perform the basic calculation (addition, subtraction, multiplication and division) based on 3 arguments. They are:\n",
        "* Operator ('+', '-', '/', '*')\n",
        "* First Operand (any number)\n",
        "* Second Operand (any number)\n",
        "\n",
        "Your first task is to take these arguments as user input and pass the values to the function parameters.\n",
        "\n",
        "Your second task is to write a function and perform the calculation based on the given operator. Then, finally return the result in the function call and print the result.\\\n",
        "=====================================================\\\n",
        "**Input:**\\\n",
        "\"+\"\\\n",
        "10\\\n",
        "20\\\n",
        "**Function Call:**\\\n",
        "function_name(\"+\", 10, 20)\\\n",
        "**Output:**\\\n",
        "30.0\\\n",
        "=====================================================\\\n",
        "**Input:**\\\n",
        "\"*\"\\\n",
        "5.5\\\n",
        "2.5\\\n",
        "**Function Call:**\\\n",
        "function_name(\"*\", 5.5, 2.5)\\\n",
        "**Output:**\\\n",
        "13.75\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "deXa2TCFjTlG",
        "outputId": "23eabc5f-82be-4b2f-9bba-e122339f744a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter a operator: +\n",
            "Enter first operand: 10\n",
            "Enter second operand: 20\n",
            "30.0\n"
          ]
        }
      ],
      "source": [
        "def function_name(a,b,c):\n",
        "  if a==\"+\":\n",
        "    ad=b+c\n",
        "    print(ad)\n",
        "  elif a==\"-\":\n",
        "    sub=b-c\n",
        "    print(sub)\n",
        "  elif a==\"*\":\n",
        "    multi=b*c\n",
        "    print(multi)\n",
        "  else:\n",
        "    div=b/c\n",
        "    print(div)\n",
        "function_name(a=input(\"Enter a operator: \"),b=float(input(\"Enter first operand: \")),c=float(input(\"Enter second operand: \")))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvhSPcBnqeWm"
      },
      "source": [
        "## Task 14\n",
        "Write a function which will take 2 arguments. They are:\n",
        "* Sentence\n",
        "* Position\n",
        "\n",
        "Your first task is to take these arguments as user input and pass these values to the function parameters.\n",
        "\n",
        "Your second task is to implement the function and remove the characters at the index number which is divisible by the position **(Avoid the index number 0 as it will always be divisible by the position, so no need to remove the index 0 character)**. Finally, add the removed characters at the end of the new string.\n",
        "\n",
        "Return the value and then finally, print the new string at the function call.\n",
        "\n",
        "**[Cannot use remove() or removed() for this task]**\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Input:**\\\n",
        "\"I love programming.\"\\\n",
        "3\\\n",
        "**Function call:**\\\n",
        "function_name(\"I love programming.\", 3)\\\n",
        "**Output:**\\\n",
        "I lveprgrmmngo oai.\n",
        "\n",
        "==============================================\n",
        "\n",
        "**Input:**\\\n",
        "\"Python is easy to learn. I love python.\"\\\n",
        "6\\\n",
        "**Function call:**\\\n",
        "function_name(\"Python is easy to learn. I love python.\", 6)\\\n",
        "**Output:**\\\n",
        "Pythonis eay to earn.I lov pythn. sl eo\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0wzyAQ82QdSu",
        "outputId": "b1ee4d43-0a56-4813-cadb-448327d8d940"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter sentences: Python is easy to learn. I love python.\n",
            "Enter a number: 6\n",
            "Pythonis eay to earn.I lov pythn. sl eo\n"
          ]
        }
      ],
      "source": [
        "def function_name(a,b):\n",
        "  r=\"\"\n",
        "  n=\"\"\n",
        "  for i in range(len(a)):\n",
        "    if i==0 or i%b!=0:\n",
        "      r+=a[i]\n",
        "    else:\n",
        "      n+=a[i]\n",
        "  print(r+n)\n",
        "function_name(a=input(\"Enter sentences: \"),b=int(input(\"Enter a number: \")))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "emhhDUgpU4MJ"
      },
      "source": [
        "## Task 15\n",
        "You have been hired as an app developer for the company. The company plans to make an app for a grocery store where the user can order groceries and see the total amount to be paid in the cart section.\n",
        "\n",
        "To build this feature, you have to write a function that takes 2 arguments. They are:\n",
        "\n",
        "* order_items (must be a list)\n",
        "* location (default value should be set to \"Dhanmondi\")\n",
        "\n",
        "Your first task is to take a list of items from the user. Pass the list into the function parameter along with the optional location (Use default argument technique). (Also, no need to take location as input, pass this any value you want.)\n",
        "\n",
        "Your second task is to implement the function. In the function, create a dictionary for the items shown in the table. Calculate the total price of the items passed as a list to the function. Additionally, add a delivery fee of 30 taka if the location is Dhanmondi. Otherwise, add a delivery fee of 70 taka. Finally, return the value and print it.\n",
        "\n",
        "\n",
        "| Item    | Price(Tk)\n",
        "| ---     | ---  \n",
        "| Rice    | 105\n",
        "|         |   \n",
        "| Potato  | 20\n",
        "|         |   \n",
        "| Chicken | 250\n",
        "|         |   \n",
        "| Beef    | 510\n",
        "|         |   \n",
        "| Oil     | 85\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Hint:** The keys are the items and values are the corresponding price. Iterate the items in the list and check if the items in the list are available in the dictionary keys or not. If it is available, add the price.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example1:**\\\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"], \"Mohakhali\")\n",
        "\n",
        "total = 105 + 510 + 105 = 720 (Take the price of each item and add them.)\\\n",
        "total = 720 + 70 = 790 (Finally, add the delivery fee based on the location.)\n",
        "\n",
        "**Input:**\\\n",
        "[\"Rice\", \"Beef\", \"Rice\"]\\\n",
        "**Function Call:**\\\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"], \"Mohakhali\")\\\n",
        "**Output:**\\\n",
        "790\n",
        "\n",
        "==============================================\n",
        "\n",
        "**Example2:**\\\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"])\n",
        "\n",
        "total = 105 + 510 + 105 = 720 (Take the price of each item and add them.)\n",
        "total = 720 + 30 = 750 (Since no location is passed in the parameter, it will use the default location-\"Dhanmondi\". For Dhanmondi, delivery fee of 30 taka)\n",
        "\n",
        "**Input:**\\\n",
        "[\"Rice\", \"Beef\", \"Rice\"]\\\n",
        "**Function Call:**\\\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"])\\\n",
        "**Output:**\\\n",
        "750\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bkCbe5UmhrX9",
        "outputId": "1a6b61f3-fb32-4520-db57-83a0473ad849"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "How many items do you want to buy: 3\n",
            "Ënter the name of items: Rice\n",
            "Ënter the name of items: Beef\n",
            "Ënter the name of items: Rice\n",
            "790\n"
          ]
        }
      ],
      "source": [
        "d={'Rice':105,'Potato':20,'Chicken':250,'Beef':510,'Oil':85}\n",
        "def function_name(a,b=\"Dhanmondi\"):\n",
        "  sum=0\n",
        "  for i in l:\n",
        "    for k,v in d.items():\n",
        "      if i==k:\n",
        "        sum+=v\n",
        "      else:\n",
        "        continue\n",
        "  if b == \"Dhanmondi\":\n",
        "    sum+=30\n",
        "  else:\n",
        "    sum+=70\n",
        "  print(sum)\n",
        "l=[]\n",
        "u=int(input(\"How many items do you want to buy: \"))\n",
        "for i in range(u):\n",
        "  l.append(input(\"Ënter the name of items: \"))\n",
        "function_name(l,b=\"Mohakhali\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XIt36u3Qsk8C",
        "outputId": "65d6bfff-cad9-4893-e215-a74f475ea283"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "How many items do you want to buy: 3\n",
            "Ënter the name of items: Rice\n",
            "Ënter the name of items: Beef\n",
            "Ënter the name of items: Rice\n",
            "750\n"
          ]
        }
      ],
      "source": [
        "d={'Rice':105,'Potato':20,'Chicken':250,'Beef':510,'Oil':85}\n",
        "def function_name(a,b=\"Dhanmondi\"):\n",
        "  sum=0\n",
        "  for i in l:\n",
        "    for k,v in d.items():\n",
        "      if i==k:\n",
        "        sum+=v\n",
        "      else:\n",
        "        continue\n",
        "  if b == \"Dhanmondi\":\n",
        "    sum+=30\n",
        "  else:\n",
        "    sum+=70\n",
        "  print(sum)\n",
        "l=[]\n",
        "u=int(input(\"How many items do you want to buy: \"))\n",
        "for i in range(u):\n",
        "  l.append(input(\"Ënter the name of items: \"))\n",
        "function_name(l)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMQaJXixYych"
      },
      "source": [
        "# <font color='purple'> Ungraded starts\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "83gGA6GHXvEo"
      },
      "source": [
        "## Task 16\n",
        "Write a function called **splitting_money** that takes an “amount” of money as an argument.\\\n",
        "Your first task is to take the “amount” of money as user input and pass the value to the function parameter.\\\n",
        "Your second task is to implement the function and calculate how that money can be split into 500, 100, 50, 20, 10, 5, 2, and 1 taka notes.\n",
        "Then print the returned value in the function call.\\\n",
        "=====================================================\\\n",
        "**Hints:**\\\n",
        "This task’s calculation is similar to Assignment-1’s seconds to hours, minutes conversion. To return the result containing multiple strings, you need to store it in a variable and return it at the end of the function.\\\n",
        "=====================================================\\\n",
        "**Example1:**\n",
        "If the money is 1234, then the function should return\\\n",
        "\"500 Taka: 2 note(s)\\\n",
        "100 Taka: 2 note(s)\\\n",
        "20 Taka: 1 note(s)\\\n",
        "10 Taka: 1 note(s)\\\n",
        "2 Taka: 2 note(s)\"\\\n",
        "=====================================================\\\n",
        "**Example2:**\\\n",
        "If the money is 151, then the function should return\\\n",
        "\"100 Taka: 1 note(s)\\\n",
        "50 Taka: 1 note(s)\\\n",
        "1 Taka: 1 note(s)\"\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vXBQmVTHYRtx"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "In3tiTGAYhQq"
      },
      "source": [
        "## Task 17\n",
        "Write a function called **remove_odd** that takes a list of numbers that have both even and odd numbers mixed.\\\n",
        "Your function should remove all the odd numbers and **return a compact** list which only contains the even numbers.\\\n",
        "**[Cannot use remove() or removed() for this task]**\\\n",
        "=====================================================\\\n",
        "**Example1:**\\\n",
        "**Function Call:**\\\n",
        "remove_odd ([21, 33, 44, 66, 11, 1, 88, 45, 10, 9])\\\n",
        "**Output:**\\\n",
        "[44, 66, 88, 10]\\\n",
        "====================================\\\n",
        "**Example2:**\\\n",
        "**Function Call:**\\\n",
        "remove_odd ([11,2,3,4,5,2,0,5,3])\\\n",
        "**Output:**\\\n",
        "[2, 4, 2, 0]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l04dk4l_W-XP"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jf6--_CpW_-A"
      },
      "source": [
        "## Task 18\n",
        "Write a function which will take 4 arguments. They are:\n",
        "\n",
        "* starting value(inclusive)\n",
        "* ending value(exclusive)\n",
        "* first divisor\n",
        "* second divisor\n",
        "\n",
        "Your first task is to take these arguments as user input and pass these values to the function.\n",
        "\n",
        "Your second task is to implement the function and find all the numbers that are divisible by the **first divisor or second divisor but not both** from the starting value(inclusive) and ending value(exclusive). Add all the numbers that are divisible and finally return this value. Print the returned value in the function call.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Input:**\\\n",
        "10\\\n",
        "40\\\n",
        "4\\\n",
        "7\\\n",
        "**Function Call:**\\\n",
        "function_name(10, 40, 4, 7)\\\n",
        "**Output:**\\\n",
        "210\n",
        "\n",
        "================================\n",
        "\n",
        "**Input:**\\\n",
        "5\\\n",
        "100\\\n",
        "3\\\n",
        "4\\\n",
        "**Function Call:**\\\n",
        "function_name(5, 100, 3, 4)\\\n",
        "**Output:**\\\n",
        "2012\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AlfxCWyDXv_x"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hjoA1GiNaePL"
      },
      "source": [
        "## Task 19\n",
        "Write a python function which will take a string as an argument.\n",
        "\n",
        "Your first task is to take a string as user input and pass the value to the function.\n",
        "\n",
        "Your second task is to implement a function which will check whether all the alphabets from a to j (convert all the alphabets to lowercase) have appeared at least once in the given string or not.\n",
        "\n",
        "* If all of these alphabets (a to j) appear at least once, then the result will be 5.\n",
        "* If any one of the alphabets (a to j) is not in the given string, then the result will be 6.\n",
        "\n",
        "Return this result and print the statement, \"PSG will win the Champions League this season\" that many times.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example01:** \"A black jackal is hunting a full grown deer\"\n",
        "\n",
        "Here all the alphabets from A to J are present at least once. So, the function will return 5 and will print the statement 5 times.\n",
        "\n",
        "**Input:**\\\n",
        "\"A black jackal is hunting a full grown deer\"\\\n",
        "**Function Call:**\\\n",
        "function_name(\"A black jackal is hunting a full grown deer\")\\\n",
        "**Output:**\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\n",
        "\n",
        "==================================================\n",
        "\n",
        "**Example02:**\n",
        "\n",
        "**Input:**\\\n",
        "\"ABBCDEFEFGHI\"\\\n",
        "**Function Call:**\\\n",
        "function_name(\"ABBCDEFEFGHI\")\\\n",
        "**Output:**\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\\\n",
        "PSG will win the Champions League this season\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WRxeMDEjbfIi"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U-ipfKjZAnGA"
      },
      "source": [
        "## Task 20\n",
        "Write a function called individul_bonus_calculation which will take 4 arguments. They are:\\\n",
        "The player name\\\n",
        "Yearly earning of that player\\\n",
        "The total goal scored this season by that player\\\n",
        "Bonus percent per goal.\\\n",
        "Your task is to implement the above-mentioned function that will calculate the total bonus on the yearly earnings of a player for the total goals he has scored.\\\n",
        "Additionally,\\\n",
        "If the goal scored is above 30, add a (additional) bonus of 10000 taka.\n",
        "If it is between 20 and 30 inclusive, add an extra 5000 taka.\\\n",
        "[ For this task, there is no need to take any input from the user. Call the functions and print the values inside the function. ]\\\n",
        "=====================================================\\\n",
        "Example1:\\\n",
        "individul_bonus_calculation(\"Neymar\", 1200000, 35, 5)\\\n",
        "bonus = 35 * (5 / 100 * 1200000) + 10000 = 2110000\\\n",
        "Function call:\\\n",
        "individul_bonus_calculation(\"Neymar\", 1200000, 35, 5)\\\n",
        "Output:\\\n",
        "Neymar earned a bonus of 2110000 Taka for 35 goals.\\\n",
        "=====================================================\\\n",
        "Example2:\\\n",
        "individul_bonus_calculation('Jamal', 700000, 19, 8)\\\n",
        "bonus = 19 * (8 / 100 * 700000) + 0 = 1064000\\\n",
        "Function call:\\\n",
        "individul_bonus_calculation('Jamal', 700000, 19, 8)\\\n",
        "Output:\\\n",
        "Jamal earned a bonus of 1064000 Taka for 19 goals.\\\n",
        "=====================================================\\\n",
        "Example3:\\\n",
        "individul_bonus_calculation('Luis', 80000, 25, 10)\\\n",
        "bonus = 25 * (10 / 100 * 80000) + 5000 = 205000\\\n",
        "Function call:\\\n",
        "individul_bonus_calculation('Luis', 80000, 25, 10)\\\n",
        "Output:\\\n",
        "Luis earned a bonus of 205000 Taka for 25 goals.\n",
        "\n",
        "=====================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k5Ug8IMkwHnv",
        "outputId": "ee75abf8-090b-440c-8aca-0d4613e9a6b3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Neymar earned a bonus of 2110000 Taka for 35 goals\n",
            "Jamal earned a bonus of 1064000 Taka for 19 goals\n",
            "Luis earned a bonus of 205000 Taka for 25 goals\n"
          ]
        }
      ],
      "source": [
        "def individul_bonus_calculation(player, earnings, goals, bonus):\n",
        "  if goals>30:\n",
        "    bonus=int(goals*(bonus/100*earnings)+10000)\n",
        "  elif 20<=goals<=30:\n",
        "    bonus=int(goals*(bonus/100*earnings)+5000)\n",
        "  else:\n",
        "    bonus=int(goals*(bonus/100*earnings)+0)\n",
        "  print(player,\"earned a bonus of\",bonus,\"Taka for\",goals,\"goals\")\n",
        "individul_bonus_calculation(\"Neymar\", 1200000, 35, 5)\n",
        "individul_bonus_calculation('Jamal', 700000, 19, 8)\n",
        "individul_bonus_calculation('Luis', 80000, 25, 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bV2HRd0Sbhc7"
      },
      "source": [
        "## Task 21\n",
        "You have been hired by the Abahani football club to write a function that will calculate the total bonus on the yearly earnings of each player for the total goals they have scored.\n",
        "\n",
        "Since the number of players will vary, you decide to use the \"*args\" technique that you learned in your CSE110 class.\n",
        "\n",
        "For each player: pass the name, yearly earning, the total goal scored this season, bonus percent per goal.\n",
        "\n",
        "Additionally,\n",
        "\n",
        "* If the goal scored is above 30, add an extra bonus of 10000 taka.\n",
        "* If it is between 20 and 30 inclusive, add an extra 5000 taka.\n",
        "\n",
        "[ For this task, there is no need to take any input from the user. Call the functions and print the values inside the function. ]\n",
        "\n",
        "**[Must reuse the individul_bonus_calculation() function of the previous task]**\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example1:**\\\n",
        "cal_bonus(\"Neymar\", 1200000, 35, 5)\\\n",
        "bonus = 35 * (5 / 100 * 1200000) + 10000 = 2110000\\\n",
        "**Function call:**\\\n",
        "cal_bonus(\"Neymar\", 1200000, 35, 5)\\\n",
        "**Output:**\\\n",
        "Neymar earned a bonus of 2110000 Taka for 35 goals.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example2:**\n",
        "\n",
        "**Function call:**\\\n",
        "function_name(\"Neymar\", 1200000, 30, 10, \"Jamal\", 700000, 19, 5)\\\n",
        "**Output:**\\\n",
        "Neymar earned a bonus of 3605000 Taka for 30 goals.\\\n",
        "Jamal earned a bonus of 665000 Taka for 19 goals.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Example3:**\n",
        "\n",
        "**Function call:**\\\n",
        "function_name(\"Neymar\", 1200000, 35, 5, 'Jamal', 700000, 19, 8, 'Luis', 80000, 25, 10))\\\n",
        "**Output:**\\\n",
        "Neymar earned a bonus of 2110000 Taka for 35 goals.\\\n",
        "Jamal earned a bonus of 1064000 Taka for 19 goals.\\\n",
        "Luis earned a bonus of 205000 Taka for 25 goals.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vBKkBhwWXdZ_"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HJR5nDv-Gh0S"
      },
      "source": [
        "# #<font color='blue'>Assignment 7 (Searching-Sorting)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MyuVDRoaF1Ex"
      },
      "source": [
        "# #<font color='blue'>Class Task\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 1\n",
        "Suppose you have a list named my_list as given below.\\\n",
        "my_list = [10, 1, 20, 3, 6, 2, 5, 11, 15, 2, 12, 14, 17, 18, 29]\\\n",
        "Now use **bubble sort** to sort my_list into ascending order.\\\n",
        "===============================================================\\\n",
        "**Output:**\n",
        "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]\n",
        "\n"
      ],
      "metadata": {
        "id": "WlFyXw1cNe7p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [10, 1, 20, 3, 6, 2, 5, 11, 15, 2, 12, 14, 17, 18, 29]\n",
        "for i in range(len(my_list)):\n",
        "  for j in range(i+1, len(my_list)):\n",
        "    if my_list[i]>my_list[j]:\n",
        "      my_list[i],my_list[j]=my_list[j],my_list[i]\n",
        "print(my_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y8qNQrfeNm_t",
        "outputId": "5a1d874f-6c6a-4ca8-b85d-4277ab4fc05b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A9g4vptFF5Pm"
      },
      "source": [
        "## Task 2\n",
        "Suppose you have a list named my_list as given below\\\n",
        "my_list= [10, 1, 20, 3, 6, 2, 5, 11, 15, 2, 12, 14, 17, 18, 29]\\\n",
        "Now use **selection sort** to sort my_list into ascending order.\\\n",
        "===============================================================\\\n",
        "**Output:**\\\n",
        "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0VhLBBLnGY8Z",
        "outputId": "f9c242ff-41f4-4796-89b4-5c40a1a26e9a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 2, 3, 5, 6, 10, 11, 12, 14, 15, 17, 18, 20, 29]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "def selection_sort(l):\n",
        "  for i in range(len(l)):\n",
        "    min = l[i]\n",
        "    min_idx = i\n",
        "    for j in range(i+1, len(l)):\n",
        "      if l[j]< min:\n",
        "        min = l[j]\n",
        "        min_idx= j\n",
        "    temp = l[min_idx]\n",
        "    l[min_idx]= l[i]\n",
        "    l[i] = temp\n",
        "  return l\n",
        "my_list= [10, 1, 20, 3, 6, 2, 5, 11, 15, 2, 12, 14, 17, 18, 29]\n",
        "selection_sort(my_list)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jMVxuqdRJM_q"
      },
      "source": [
        "## Task 3\n",
        "Suppose you have a list named my_list as given below.\\\n",
        "my_list = [10, 1, 20, 3, 6, 2, 5, 11, 15, 2, 12, 14, 17, 18, 29]\\\n",
        "Now use any of the two sorting techniques you have used above to sort the list in descending order.\\\n",
        "===============================================================\\\n",
        "**Output:**\\\n",
        "[29, 20, 18, 17, 15, 14, 12, 11, 10, 6, 5, 3, 2, 2, 1]\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Solved by using Bubble Sorting\n",
        "my_list = [10, 1, 20, 3, 6, 2, 5, 11, 15, 2, 12, 14, 17, 18, 29]\n",
        "for i in range(len(my_list)):\n",
        "  for j in range(i+1, len(my_list)):\n",
        "    if my_list[i]<my_list[j]:\n",
        "      my_list[i],my_list[j]=my_list[j],my_list[i]\n",
        "print(my_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0sg_vc_rKj4s",
        "outputId": "9023969a-ee5a-4a99-e788-db71a9257400"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[29, 20, 18, 17, 15, 14, 12, 11, 10, 6, 5, 3, 2, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 4\n",
        "Suppose you have a sitting arrangement of the students who will give the final exam in a list. The list contains the last two digits of their student ID as given below\n",
        "\n",
        "sitting_list = [10,30,20,70,11,15,22,16,58,100,12,56,70,80]\n",
        "\n",
        "Now you want to organize the sitting arrangement of the students in your own way. You decide to sort all the students in the even indices of the list in ascending order and all the students in the odd indices of the list in descending order.\n",
        "\n",
        "So, write a python program that organizes the list for you in this way.\n",
        "\n",
        "===============================================================\n",
        "\n",
        "**Output:**\\\n",
        "[10, 100, 11, 80, 12, 70, 20, 56, 22, 30, 58, 16, 70, 15]\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "MkCnynoYLtk1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sitting_list = [10,30,20,70,11,15,22,16,58,100,12,56,70,80]\n",
        "e=[]\n",
        "o=[]\n",
        "for i in range(len(sitting_list)):\n",
        "  if i%2==0:\n",
        "    e.append(sitting_list[i])\n",
        "  else:\n",
        "    o.append(sitting_list[i])\n",
        "m= sorted(e)\n",
        "l= len(m)\n",
        "n= sorted(o, reverse= True)\n",
        "new= []\n",
        "for i in range(l):\n",
        "  new.append(m[i])\n",
        "  new.append(n[i])\n",
        "print(new)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-GFQgJCZTqdk",
        "outputId": "6eebde13-fa83-426b-d481-26d856c3773f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 100, 11, 80, 12, 70, 20, 56, 22, 30, 58, 16, 70, 15]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 5\n",
        "Suppose a list contains marks earned in the courses CSE110, PHY111, and MAT110 of each student consecutively in a nested list form. Your task is to take a course name as input from the user and sort the list based on the marks obtained in that course to finally print the names of the students in descending order of marks obtained i.e. from the student who earned the highest marks to the student who earned the lowest.\n",
        "\n",
        "For example, the list may look like\n",
        "\n",
        "lst = [ [\"Alan\", 95, 87, 91], [\"Turing\", 92, 90, 83], [\"Elon\", 87, 92, 80], [\"Musk\", 85, 94, 90] ]\n",
        "\n",
        "where for each nested list, 1st index holds the name of the student, 2nd index is total marks earned in the CSE110 course, 3rd index is PHY111 marks and 4th index is MAT110 marks.\n",
        "\n",
        "===============================================================\n",
        "\n",
        "**Hint:**\n",
        "\n",
        "You may create a function for sorting, then call it whenever needed instead of rewriting the code.\n",
        "\n",
        "You may get the data in the individual lists from the given nested list.\n",
        "\n",
        "===============================================================\n",
        "\n",
        "**Sample Input 1**\\\n",
        "MAT110\\\n",
        "**Sample Output 1**\\\n",
        "Alan\\\n",
        "Musk\\\n",
        "Turing\\\n",
        "Elon\n",
        "\n",
        "**Explanation:**\n",
        "\n",
        "Here the user gives us \"MAT110\" as the course name. Now, the students Alan, Turing, Elon, and Musk earned 91, 83, 80, and 90 marks respectively in this course. If we sort it, Alan got the highest marks of 91 followed by Musk with 90 marks and Turing with 83 marks. Among these 4 students, Elon obtained the lowest marks in the MAT110 course with 80 marks. All of these have been illustrated in our sample output.\n",
        "\n",
        "===============================================================\n",
        "\n",
        "**Sample Input 2**\\\n",
        "PHY111\\\n",
        "**Sample Output 2**\\\n",
        "Musk\\\n",
        "Elon\\\n",
        "Turing\\\n",
        "Alan\n"
      ],
      "metadata": {
        "id": "7CS_zA4eB8ol"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def g(lst,idx):\n",
        "  for i in range(0,len(lst)-1):\n",
        "    for j in range(0,len(lst)-i-1):\n",
        "      if lst[j][idx]<lst[j+1][idx]:\n",
        "        lst[j],lst[j+1]=lst[j+1],lst[j]\n",
        "  for i in range(0,len(lst)):\n",
        "    print(lst[i][0])\n",
        "\n",
        "lst = [ [\"Alan\", 95, 87, 91], [\"Turing\", 92, 90, 83], [\"Elon\", 87, 92, 80], [\"Musk\", 85, 94, 90]]\n",
        "n= input(\"Please enter a course name: \")\n",
        "if n==\"CSE110\":\n",
        "  idx=1\n",
        "elif n==\"PHY111\":\n",
        "  idx=2\n",
        "elif n==\"MAT110\":\n",
        "  idx=3\n",
        "g(lst, idx)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xlqZ3SyqqcUN",
        "outputId": "e73afabc-d3d2-463f-a9ee-59cfd0bbe0b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter a course name: PHY111\n",
            "Musk\n",
            "Elon\n",
            "Turing\n",
            "Alan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 6\n",
        "Suppose you have a list named my_list as given below. Your task is to sort the list in ascending order and print the count of numbers that have changed their positions in the process of sorting.\n",
        "\n",
        "my_list = [4, 2, 3, 1, 6, 5]\n",
        "\n",
        "The sorted list would be [1, 2, 3, 4, 5, 6] where 4 numbers (4, 1, 6, and 5) have changed their positions. Therefore our sample output here would be 4. Please check if your code is working correctly by changing the above list and using the knowledge given here to verify whether your code gives the correct output for all different lists.\n",
        "\n",
        "**Sample Output for the above list**\\\n",
        "4\n"
      ],
      "metadata": {
        "id": "A8Jt0H9ACkFd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [4, 2, 3, 1, 6, 5]\n",
        "new= sorted(my_list)\n",
        "c=0\n",
        "for i in range(len(my_list)):\n",
        "  if my_list[i]==new[i]:\n",
        "    continue\n",
        "  else:\n",
        "    c+=1\n",
        "print(c)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4hcdL9jlCsLN",
        "outputId": "cc28f627-7dbe-48c5-833e-67b7c664d002"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 7\n",
        "Write a python program that takes two lists from the user, merges the two lists, sorts the resulting list, and then finds the median of the elements in the two lists.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input 1**\\\n",
        "list_one = [1, 2, 1, 4]\\\n",
        "list_two = [5, 4, 1]\\\n",
        "**Sample Output 1**\\\n",
        "Sorted list = [1, 1, 1, 2, 4, 4, 5]\\\n",
        "Median = 2\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input 2**\\\n",
        "list_one = [1, 7, 9, 10]\\\n",
        "list_two = [2, 7, 6, 5]\\\n",
        "**Sample Output 2**\\\n",
        "Sorted list = [1, 2, 5, 6, 7, 7, 9, 10]\\\n",
        "Median = 6.5"
      ],
      "metadata": {
        "id": "2zlw1VhqCuEM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l1 = [1, 2, 1, 4]\n",
        "l2 = [5, 4, 1]\n",
        "l1.extend(l2)\n",
        "new= sorted(l1)\n",
        "print(\"Sorted list =\" ,new)\n",
        "l=len(new)\n",
        "m = l // 2\n",
        "if l%2==0:\n",
        "  n= (new[m-1]+new[m])/2\n",
        "  print(n)\n",
        "else:\n",
        "  n= new[m]\n",
        "  print(\"Median =\" ,n)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7nwpkPLODKJT",
        "outputId": "f2c2499d-13b0-4f6c-f545-499e7fe5f556"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted list = [1, 1, 1, 2, 4, 4, 5]\n",
            "Median = 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "l1 = [1, 7, 9, 10]\n",
        "l2 = [2, 7, 6, 5]\n",
        "l1.extend(l2)\n",
        "new= sorted(l1)\n",
        "print(\"Sorted list =\" ,new)\n",
        "l=len(new)\n",
        "m = l // 2\n",
        "if l%2==0:\n",
        "  n= (new[m-1]+new[m])/2\n",
        "  print(n)\n",
        "else:\n",
        "  n= new[m]\n",
        "  print(\"Median =\" ,n)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BG7EriTqgLxv",
        "outputId": "dc1393a8-3e95-4715-9819-bc351494616b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted list = [1, 2, 5, 6, 7, 7, 9, 10]\n",
            "6.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 8\n",
        "Write a python program that takes a list from a user containing both positive and negative numbers. The program then finds two pairs of values whose summation is closest to zero.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input 1**\\\n",
        "list_one = [-10, 15, 2, 4, -4, 7, -8]\\\n",
        "**Sample Output 1**\\\n",
        "Two pairs which have the smallest sum = 4 and -4\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input 2**\\\n",
        "list_one = [1, -8, 4, -7, -20, 26, 70, -85]\\\n",
        "**Sample Output 2**\\\n",
        "Two pairs which have the smallest sum = 4 and -7\n"
      ],
      "metadata": {
        "id": "KNqkQqazCuFp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n=input(\"Enter some numbers: \")\n",
        "a=n.strip(\"[]\").split(\",\")\n",
        "w=list(map(int,a))\n",
        "x=w[0]\n",
        "y=w[1]\n",
        "min=x+y\n",
        "if min<0:\n",
        "  min=-min\n",
        "for i in range(len(w)-1):\n",
        "  for j in range(i+1,len(w)):\n",
        "    sum= w[i]+w[j]\n",
        "    if sum<0:\n",
        "      sum=-sum\n",
        "    if sum<min:\n",
        "      x=w[i]\n",
        "      y=w[j]\n",
        "      min=sum\n",
        "print(f\"Two pairs which have the smallest sum = {x} and {y}\")"
      ],
      "metadata": {
        "id": "olJICNPgDamX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7fb9077e-3d04-4038-9b5f-a8bec6b3a282"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter some numbers: -10, 15, 2, 4, -4, 7, -8\n",
            "Two pairs which have the smallest sum = 4 and -4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n =\n",
        "print(n)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kvtTESFs2kQn",
        "outputId": "7216288a-48b3-4f62-87c3-96bdae3f1a9a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter some numbers : 3 4 5 6 7 8\n",
            "['3', ' ', '4', ' ', '5', ' ', '6', ' ', '7', ' ', '8']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 9\n",
        "You will be given a list of tuples where each tuple indicates a point i.e. (x, y) in a 2-dimensional coordinate system.\n",
        "\n",
        "You need to write a python program to find the minimum distance and the point that is closest to the origin i.e. (0,0)\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Hint:**\\\n",
        "The formula of distance = √((Δx)2+(Δy)2)\n",
        "As you are calculating the distance from the origin (0,0), you can simply use\n",
        "distance = √(x2+y2)\n",
        "\n",
        "You can create a list of distances from each point and sort that list using your personal favorite sorting algorithm.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input 1**\\\n",
        "points = [(5,3), (2,9), (-2,7), (-3,-4), (0,6), (7,-2)]\\\n",
        "**Sample Output 1**\\\n",
        "Minimum distance = 5.0\\\n",
        "Here the closest point is (-3,-4) which has a distance of 5.0 from the origin.\n",
        "\n",
        "=====================================================\n",
        "\n",
        "**Sample Input 1**\\\n",
        "points = [(1,7), (4,5), (-1,7), (-2,0), (1,1), (5,-1)]\\\n",
        "**Sample Output 1**\\\n",
        "Minimum distance = 1.4142135623730951\\\n",
        "Here the closest point is (1,1) which has a distance of 1.4142135623730951 from the origin.\n"
      ],
      "metadata": {
        "id": "EF-hNPsXDbKv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "points=[(1,7), (4,5), (-1,7), (-2,0), (1,1), (5,-1)]\n",
        "origin=(0,0)\n",
        "c = math.sqrt((origin[0]-points[0][0])**2 + (origin[1]- points[0][1])**2)\n",
        "for i in points:\n",
        "  distance =math.sqrt((origin[0]- i[0])**2 + (origin[1] - i[1])**2)\n",
        "  if distance<c:\n",
        "    c = distance\n",
        "    closest_points=i\n",
        "print(f\"Minimum distance = {c}\")\n",
        "print(f\"Here the closest point is {closest_points} which has a distance of {c} from the origin.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XRN03l8Tx35M",
        "outputId": "5a1d883a-fdd9-48b6-fda7-ca4b4ec9a4c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Minimum distance = 1.4142135623730951\n",
            "Here the closest point is (1, 1) which has a distance of 1.4142135623730951 from the origin.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J_S44wJ1Tlpt"
      },
      "source": [
        "# #<font color='blue'>Practice Problems for final\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 1\n",
        "You are given a list of courses like the following:\\\n",
        "**courses=** ['CSE110','CSE111','MAT620','CS520','EEE361','CSE650','MAT5100','CSEE25','MAT3210']\n",
        "\n",
        "**Sample Input**\\\n",
        "No need to take input\\\n",
        "**Sample Output**\\\n",
        "{'CSE': ['CSE110', 'CSE111', 'CSE650'], 'EEE': ['EEE361'], 'MAT': ['MAT620'], 'Invalid': ['CS520', 'MAT5100', 'CSEE25', 'MAT3210']}"
      ],
      "metadata": {
        "id": "zTgHoxZDTlOS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "c= ['CSE110','CSE111','MAT620','CS520','EEE361','CSE650','MAT5100','CSEE25','MAT3210']\n",
        "inv=[]\n",
        "cse=[]\n",
        "eee=[]\n",
        "mat=[]\n",
        "d={}\n",
        "for i in c:\n",
        "    if len(i)==6:\n",
        "        if 'CSEE' in i:\n",
        "            inv.append(i)\n",
        "        elif 'CSE' in i:\n",
        "            cse.append(i)\n",
        "        elif 'MAT' in i:\n",
        "            mat.append(i)\n",
        "        elif 'EEE' in i:\n",
        "            eee.append(i)\n",
        "    else:\n",
        "        inv.append(i)\n",
        "d['CSE']=cse\n",
        "d['EEE']=eee\n",
        "d['MAT']=mat\n",
        "d['Invalid']=inv\n",
        "print(d)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "79OJpf7MUjbY",
        "outputId": "8c87ba0b-4cda-4800-bcb5-1b03cfa31bd0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'CSE': ['CSE110', 'CSE111', 'CSE650'], 'EEE': ['EEE361'], 'MAT': ['MAT620'], 'Invalid': ['CS520', 'MAT5100', 'CSEE25', 'MAT3210']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tracing 1"
      ],
      "metadata": {
        "id": "bek5tzoWp_lB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t1 = (0,2,3,4,1,5)\n",
        "L2 = [43,65,23,65,10,23,12,75]\n",
        "i=1\n",
        "while i<=3:\n",
        "    L1=L2\n",
        "    j=t1[i]\n",
        "    k=i+j\n",
        "    while j<=4:\n",
        "        L1[i+j] = t1[i]+L2[t1[j]]\n",
        "        print(L2)\n",
        "        j+=1\n",
        "    print(L2[k])\n",
        "    i+=1\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_hI3lyosp78v",
        "outputId": "7e31791d-d000-4ebd-821f-528877fe85c0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[43, 65, 23, 67, 10, 23, 12, 75]\n",
            "[43, 65, 23, 67, 12, 23, 12, 75]\n",
            "[43, 65, 23, 67, 12, 67, 12, 75]\n",
            "67\n",
            "[43, 65, 23, 67, 12, 15, 12, 75]\n",
            "[43, 65, 23, 67, 12, 15, 68, 75]\n",
            "15\n",
            "[43, 65, 23, 67, 12, 15, 68, 69]\n",
            "69\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tracing 2"
      ],
      "metadata": {
        "id": "Iy9WZGioqG37"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "L1= [2,1,0]\n",
        "L2=[-1,-2,-3]\n",
        "for i in range(len(L1)):\n",
        "  x=0\n",
        "  y=0\n",
        "  for j in range(len(L2)):\n",
        "    if i-j>0:\n",
        "      x+=L1[L2[j]]-L2[L1[L2[i]]]\n",
        "    else:\n",
        "      y+=L1[L2[L1[j]]]-L2[L1[i]]\n",
        "    print(\"x,y=\",x,y)\n",
        "    print(x+y)\n",
        "\n",
        "\n",
        "print(\"x\",x)\n",
        "print(\"y\",y)\n",
        "print(y//x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dwd697w9rAbC",
        "outputId": "da34ac19-5da2-4c2d-d18c-697237c35d9a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x,y= 0 5\n",
            "5\n",
            "x,y= 0 9\n",
            "9\n",
            "x,y= 0 12\n",
            "12\n",
            "x,y= 2 0\n",
            "2\n",
            "x,y= 2 3\n",
            "5\n",
            "x,y= 2 5\n",
            "7\n",
            "x,y= 3 0\n",
            "3\n",
            "x,y= 7 0\n",
            "7\n",
            "x,y= 7 1\n",
            "8\n",
            "x 7\n",
            "y 1\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 2\n",
        "Assume, a list is given containing email addresses. Now, implement a function that takes a list as a parameter.\n",
        "\n",
        "In the function, your task is to separate the ids and the domain names from the given emails in the list and create a dictionary.\n",
        "\n",
        "The key of the dictionary will be domain and value will be a tuple of two elements. The first element of the tuple is a list that contains ids of the corresponding domain and the second element is the number of elements in that list. Finally return the dictionary.\n",
        "\n",
        "**Sample Input**\n",
        "\n",
        "print(fucntion_is_fun(['mymail1@bracu.com', 'urmail@nsu.com', 'theirmail2@buet.com', 'mymail2@bracu.com', 'theirmail1@buet.com', 'theirmail3@buet.com']))\n",
        "\n",
        "**Sample Output**\n",
        "{‘bracu’ : ([‘mymail1’,‘mymail2’] , 2),\\\n",
        "‘nsu’ : ([‘urmail’], 1),\\\n",
        "‘buet’ :’ ([‘theirmail2’, ‘theirmail1’,‘theirmail3’’] , 3)}"
      ],
      "metadata": {
        "id": "rgsOVhwLvBiz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myList= [10,20,30,40,50,40,30,20,10]\n",
        "p=5\n",
        "q=0\n",
        "r=0\n",
        "new= myList\n",
        "while q<9:\n",
        "  #print(\"p,q,r=\" , p,q,r)\n",
        "  r= (p+q-r)%9\n",
        "  #print(\"r1\" ,r)\n",
        "  while r<q:\n",
        "    p=p+r\n",
        "    myList[q]= myList[q]-new[r]- int(str(p)+\"5\")\n",
        "    #print(\"p1\",p)\n",
        "    r+=1\n",
        "  print(myList[q])\n",
        "    #print(\"r2\",r)\n",
        "    #print(\"**Done**\")\n",
        "  p=p-q\n",
        "  q+= 17%8\n",
        "print(len(myList)==q)\n",
        "  #print(\"p3\",p)\n",
        "  #print(\"#q\",q)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1YrJDd89FtFR",
        "outputId": "05c8f06b-c63a-42a6-d8b2-10ed85a5e114"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "20\n",
            "30\n",
            "-135\n",
            "130\n",
            "-190\n",
            "30\n",
            "-390\n",
            "-185\n",
            "True\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}