Assignment7(Functions).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/azaynul10/Assignments-Of-Programming-Language-1/blob/main/Assignment7(Functions).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 1\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "even_checker(5)\n",
        "\n",
        "Output:\n",
        "\n",
        "Odd!!\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "even_checker(2)\n",
        "\n",
        "Output:\n",
        "\n",
        "Even!!\n"
      ],
      "metadata": {
        "id": "JV2g7D39TTwc"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sItXZQ44wsmN",
        "outputId": "4785ab04-728e-42b3-d971-c014eec9fed2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Odd!!\n"
          ]
        }
      ],
      "source": [
        "#Task1\n",
        "def even_checker(num):\n",
        "  if num%2==0:\n",
        "    print(\"Even!!\")\n",
        "  else:\n",
        "    print(\"Odd!!\")\n",
        "even_checker(5)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "board = [[1,2,3],[4,5,6],[7,8,9]]\n",
        "flag=False\n",
        "for i in range(len(board)):\n",
        "  for j in range(i):\n",
        "            if (board[j][i]=='X') or (board[j][i]=='O'):\n",
        "                flag=True\n",
        "                break\n",
        "print(flag)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2F85dMJPJyp9",
        "outputId": "85f1f111-7455-4b7f-e8df-65728658950b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(3):\n",
        "\n",
        "                flag=True\n",
        "                break"
      ],
      "metadata": {
        "id": "3UepDkiL8dBB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# 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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Function Call:\n",
        "\n",
        "fibonacci(10)\n",
        "\n",
        "Output:\n",
        "\n",
        "0 1 1 2 3 5 8\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Function Call:\n",
        "\n",
        "fibonacci(5)\n",
        "\n",
        "Output:\n",
        "\n",
        "0 1 1 2 3 5\n"
      ],
      "metadata": {
        "id": "riw8d8-jTjV2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-4f2g0myHn7",
        "outputId": "72c98057-fb45-4c47-bb88-7e360be73799"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 1 1 2 3 5 "
          ]
        }
      ],
      "source": [
        "#Task2\n",
        "def fibonacci(num):\n",
        "  var1=0\n",
        "  var2=1\n",
        "  sum=0\n",
        "  count=0\n",
        "  while var1<=num:\n",
        "    if sum<=num:\n",
        "      print(sum,end=\" \")\n",
        "      var1=var2\n",
        "      var2=sum\n",
        "      sum =var1 + var2\n",
        "  count+=1\n",
        "fibonacci(5)"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "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",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "foo_moo(5)\n",
        "Output:\n",
        "\n",
        "Boo\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "foo_moo(4)\n",
        "\n",
        "Output:\n",
        "\n",
        "Foo\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example3:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "foo_moo(6)\n",
        "\n",
        "Output:\n",
        "\n",
        "FooMoo\n"
      ],
      "metadata": {
        "id": "YN9JZ_1qTw-I"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8eelc3qP446e",
        "outputId": "3faff161-0186-4e96-b0ed-59c0df26f5f6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Moo\n"
          ]
        }
      ],
      "source": [
        "#Task3\n",
        "def foo_moo(str1):\n",
        "  if str1%2==0 and str1%3==0:\n",
        "    return \"FooMoo\"\n",
        "  elif str1%2==0 and str1%3!=0:\n",
        "    return \"Foo\"\n",
        "  elif str1%2!=0 and str1%3==0:\n",
        "    return \"Moo\"\n",
        "  else:\n",
        "    return \"Boo\"\n",
        "print(foo_moo(15))"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name('The quick Sand Man')\n",
        "\n",
        "Output:\n",
        "\n",
        "No. of Uppercase characters : 3\n",
        "No. of Lowercase Characters: 12\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name('HaRRy PotteR')\n",
        "\n",
        "Output:\n",
        "\n",
        "No. of Uppercase characters : 5\n",
        "\n",
        "No. of Lowercase Characters: 6\n"
      ],
      "metadata": {
        "id": "dgPA811aUiYU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KQWhHKjEIASZ",
        "outputId": "73c8aeb1-e141-47f5-ddfd-67d871847216"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "No. of Uppercase characters : 7\n",
            "No. of Lowercase Characters: 3\n"
          ]
        }
      ],
      "source": [
        "#Task4\n",
        "def function_name(str1):\n",
        "  upper=0\n",
        "  lower=0\n",
        "  for i in str1:\n",
        "    if 65<=ord(i)<=90:\n",
        "      upper+=1\n",
        "    elif 97<=ord(i)<=122:\n",
        "      lower+=1\n",
        "  print(f'No. of Uppercase characters : {upper}')\n",
        "  print(f'No. of Lowercase Characters: {lower}')\n",
        "function_name('BaRRy ALLEn')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 5\n",
        "Write a function called calculate_tax that takes 3 arguments: your age, salary, and current job designation.\n",
        "Your first task is to take these arguments as user input and pass these values to the function.\n",
        "Your second task is to implement the function and calculate the tax as the following conditions:\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",
        "Finally return this tax value. Then print the returned value in the function call.\n",
        "\n",
        "\n",
        "---\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Input:\n",
        "\n",
        "16\n",
        "\n",
        "20000\n",
        "\n",
        "Student\n",
        "\n",
        "Function Call:\n",
        "\n",
        "calculate_tax(16, 20000, 'Student')\n",
        "\n",
        "Output:\n",
        "0\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Input:\n",
        "\n",
        "20\n",
        "\n",
        "18000\n",
        "\n",
        "assistant manager\n",
        "\n",
        "Function Call:\n",
        "\n",
        "calculate_tax(20, 18000, 'assistant manager')\n",
        "\n",
        "Output:\n",
        "\n",
        "900.0\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example3:\n",
        "\n",
        "Input:\n",
        "\n",
        "20\n",
        "\n",
        "22000\n",
        "\n",
        "assistant manager\n",
        "\n",
        "Function Call:\n",
        "\n",
        "calculate_tax(20, 22000, 'Assistant manager')\n",
        "\n",
        "Output:\n",
        "\n",
        "2200.0\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example4:\n",
        "\n",
        "Input:\n",
        "\n",
        "20\n",
        "\n",
        "122000\n",
        "\n",
        "president\n",
        "\n",
        "Function Call:\n",
        "\n",
        "calculate_tax(20, 122000, 'president')\n",
        "\n",
        "Output:\n",
        "\n",
        "0\n"
      ],
      "metadata": {
        "id": "1_yba0_TUwhl"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EIloh91yeaWg",
        "outputId": "89e0fa1d-e4d0-4c44-a167-c15d365519c3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "20\n",
            "20000\n",
            "student\n",
            "1000.0\n"
          ]
        }
      ],
      "source": [
        "#Task5\n",
        "def calculate_tax(age,salary,job):\n",
        "    if age>=18 and salary>=10000 and job!=\"president\":\n",
        "        if salary>=10000 or salary<=20000:\n",
        "          return salary*0.05\n",
        "        elif salary>20000:\n",
        "          return salary*0.10\n",
        "    else:\n",
        "        return 0\n",
        "age=int(input())\n",
        "salary=int(input())\n",
        "job=input().lower()\n",
        "print(calculate_tax(age,salary,job))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 6\n",
        "Write a function which will take 1 argument, number of days.\n",
        "Your first task is to take the number of days as user input and pass the value to the function.\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",
        "Note: Assume, each year to be 365 days and month to be 30 days.\n",
        "\n",
        "\n",
        "---\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "Example01\n",
        "\n",
        "Input:\n",
        "\n",
        "4330\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(4330)\n",
        "\n",
        "Output:\n",
        "\n",
        "11 years, 10 months and 15 days\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example02\n",
        "\n",
        "Input:\n",
        "\n",
        "2250\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(2250)\n",
        "\n",
        "Output:\n",
        "\n",
        "6 years, 2 months and 0 days\n"
      ],
      "metadata": {
        "id": "2nmG0VhvWRiA"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hHzBq99hRK9Y",
        "outputId": "0d1db464-7e38-4b8e-94ab-8a30c438a26a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "365\n",
            "1 years, 0 months and 0 days\n"
          ]
        }
      ],
      "source": [
        "#Task6\n",
        "def num_of_days(days):\n",
        "    years=days//365\n",
        "    rem_year = days%365\n",
        "    month=rem_year//30\n",
        "    rem_days=rem_year%30\n",
        "    print(f'{years} years, {month} months and {rem_days} days')\n",
        "days=int(input())\n",
        "num_of_days(days)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# 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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "show_palindrome(5)\n",
        "\n",
        "Output:\n",
        "\n",
        "123454321\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "show_palindrome(3)\n",
        "\n",
        "Output:\n",
        "\n",
        "12321\n"
      ],
      "metadata": {
        "id": "v7P6zOZQWDz_"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ou9C_y5rEepM",
        "outputId": "d52a611f-cc48-4e7c-be99-c25c6958ecea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "123454321\n"
          ]
        }
      ],
      "source": [
        "#Task7\n",
        "def show_palindrome(num1):\n",
        "  str1=\"\"\n",
        "  for i in range(1,num1+1):\n",
        "     str1+=str(i)\n",
        "  for i in range(num1-1,0,-1):\n",
        "     str1+=str(i)\n",
        "  return str1\n",
        "print(show_palindrome(5))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Task 8\n",
        "\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",
        "\n",
        "\n",
        "Hints(1):\n",
        "Need to use both print() and print( , end = \" \") functions\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "show_palindromic_triangle(5)\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "show_palindromic_triangle(3)\n",
        "\n",
        "Output:\n",
        "\n",
        "    1\n",
        "  1   2   1\n",
        "1   2   3   2   1\n"
      ],
      "metadata": {
        "id": "m0c7EosLXUwh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aHSyhl7Ag5Ku",
        "outputId": "58ebd4a7-c631-4e27-b8cb-9678d3330f7b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "        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": [
        "#Task8\n",
        "def show_palindromic_triangle(num):\n",
        "  for row in range(1,num+1):\n",
        "    for space in range((num-row)*2):\n",
        "       print(\" \",end=\"\")\n",
        "    str1=\"\"\n",
        "    for i in range(1,row+1):\n",
        "      str1+=str(i)+\" \"\n",
        "    for i in range(row-1,0,-1):\n",
        "      str1+=str(i)+\" \"\n",
        "    print(str1)\n",
        "show_palindromic_triangle(5)"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "[Must use tuple packing & unpacking]\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "area_circumference_generator(1)\n",
        "\n",
        "Output:\n",
        "\n",
        "(3.141592653589793, 6.283185307179586)\n",
        "\n",
        "Area of the circle is 3.141592653589793 and circumference is 6.283185307179586\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "area_circumference_generator(1.5)\n",
        "\n",
        "Output:\n",
        "\n",
        "(7.0685834705770345, 9.42477796076938)\n",
        "\n",
        "Area of the circle is 7.0685834705770345 and circumference is 9.42477796076938\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example3:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "area_circumference_generator(2.5)\n",
        "\n",
        "Output:\n",
        "\n",
        "(19.634954084936208, 15.707963267948966)\n",
        "\n",
        "Area of the circle is 19.634954084936208 and circumference is 15.707963267948966\n",
        "\n"
      ],
      "metadata": {
        "id": "TTGGG56yXviu"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gFVihcFkEyW0",
        "outputId": "8f3aa322-58ac-4d0f-ce87-dfe1a87db9e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(7.0685834705770345, 9.42477796076938)\n"
          ]
        }
      ],
      "source": [
        "#Task9\n",
        "import math\n",
        "def area_circumference_generator(radius):\n",
        "    circle= (math.pi*(radius**2), 2*math.pi*radius)\n",
        "    radius, circumference = circle\n",
        "    return (radius, circumference)\n",
        "print(area_circumference_generator(1.5))"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "---\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "make_square((1,3))\n",
        "\n",
        "Output:\n",
        "\n",
        "{1: 1, 2: 4, 3: 9}\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "make_square((5,9))\n",
        "\n",
        "Output:\n",
        "\n",
        "{5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
      ],
      "metadata": {
        "id": "zEcCLvPGYCvU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3sDv-pdJLevk",
        "outputId": "69afb893-9306-44b4-a956-2c59b1c39e58"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{1: 1, 2: 4, 3: 9}\n"
          ]
        }
      ],
      "source": [
        "#Task10\n",
        "def make_square(tup):\n",
        "    a,b=tup\n",
        "    dict1={}\n",
        "    for i in range(a,b+1):\n",
        "      dict1[i]=i**2\n",
        "    print(dict1)\n",
        "make_square((1,3))"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "---\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "rem_duplicate((1,1,1,2,3,4,5,6,6,6,6,4,0,0,0))\n",
        "\n",
        "Output:\n",
        "\n",
        "(1, 2, 3, 4, 5, 6, 0)\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "rem_duplicate((\"Hi\", 1, 2, 3, 3, \"Hi\",'a', 'a', [1,2]))\n",
        "\n",
        "Output:\n",
        "\n",
        "('Hi', 1, 2, 3, 'a', [1, 2])\n"
      ],
      "metadata": {
        "id": "WoRMFVBxYVfF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tx4z2JCyRVT7",
        "outputId": "cf1d4cc6-f629-4ea1-8005-b7ffe1db80d3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "('Hi', 1, 2, 3, 'a', [1, 2])\n"
          ]
        }
      ],
      "source": [
        "#Task11\n",
        "def rem_duplicate(tup):\n",
        "  list1=[]\n",
        "  list2=[]\n",
        "  for i in tup:\n",
        "    if i not in list1:\n",
        "      list1.append(i)\n",
        "  return tuple(list1)\n",
        "print(rem_duplicate((\"Hi\", 1, 2, 3, 3, \"Hi\",'a', 'a', [1,2])))"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "---\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name([1, 2, 3, 3, 3, 3, 4, 5, 8, 8])\n",
        "\n",
        "Output:\n",
        "\n",
        "Removed: 2\n",
        "\n",
        "[1, 2, 3, 3, 4, 5, 8, 8]\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name([10, 10, 15, 15, 20])\n",
        "\n",
        "Output:\n",
        "\n",
        "Removed: 0\n",
        "\n",
        "[10, 10, 15, 15, 20]\n"
      ],
      "metadata": {
        "id": "juPFNxUFYj1f"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZP03a1O-nwVz",
        "outputId": "2f1126a5-023e-4119-b753-c44e790cd637"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[8]\n"
          ]
        }
      ],
      "source": [
        "#Task12\n",
        "def function_name(list1):\n",
        "    rem=0\n",
        "    list2=[]\n",
        "    for i in range(len(list1)):\n",
        "      count=0\n",
        "      for j in range(len(list1)):\n",
        "        if i==j:\n",
        "          count+=1\n",
        "    if count<=1:\n",
        "        list2.append(list1[i])\n",
        "    else:\n",
        "        rem+=1\n",
        "    print(list2)\n",
        "function_name([1, 2, 3, 3, 3, 3, 4, 5, 8, 8])"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\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",
        "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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Input:\n",
        "\n",
        "\"+\"\n",
        "\n",
        "10\n",
        "\n",
        "20\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(\"+\", 10, 20)\n",
        "\n",
        "Output:\n",
        "\n",
        "30.0\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Input:\n",
        "\n",
        "\"*\"\n",
        "\n",
        "5.5\n",
        "\n",
        "2.5\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(\"*\", 5.5, 2.5)\n",
        "\n",
        "Output:\n",
        "\n",
        "13.75\n"
      ],
      "metadata": {
        "id": "aJfYhEXUYjzi"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QqE50bbAzaRd",
        "outputId": "2bf85a82-aee7-4917-9b89-693ccbdaeccf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "*\n",
            "0.1\n",
            "0.9\n",
            "0.09000000000000001\n"
          ]
        }
      ],
      "source": [
        "#Task13\n",
        "operator=input()\n",
        "operand1=float(input())\n",
        "operand2=float(input())\n",
        "def function_name(operator,operand1,operand2):\n",
        "  if operator==\"+\":\n",
        "    print(operand1+operand2)\n",
        "  elif operator==\"-\":\n",
        "    print(operand1-operand2)\n",
        "  elif operator==\"/\":\n",
        "    print(operand1/operand2)\n",
        "  if operator==\"*\":\n",
        "    print(operand1*operand2)\n",
        "function_name(operator,operand1,operand2)"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "Return the value and then finally, print the new string at the function call.\n",
        "[Cannot use remove() or removed() for this task]\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Input:\n",
        "\n",
        "\"I love programming.\"\n",
        "\n",
        "3\n",
        "\n",
        "Function call:\n",
        "\n",
        "function_name(\"I love programming.\", 3)\n",
        "\n",
        "Output:\n",
        "\n",
        "I lveprgrmmngo oai.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Input:\n",
        "\n",
        "\"Python is easy to learn. I love python.\"\n",
        "\n",
        "6\n",
        "\n",
        "Function call:\n",
        "\n",
        "function_name(\"Python is easy to learn. I love python.\", 6)\n",
        "\n",
        "Output:\n",
        "\n",
        "Pythonis eay to earn.I lov pythn. sl eo\n"
      ],
      "metadata": {
        "id": "9k1XW5f3b5Ec"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XkQokbTL2cJj",
        "outputId": "93115dce-afa9-49a7-cabf-6989101dd283"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "I love programming.\n",
            "3\n",
            "I lveprgrmmngo oai.\n"
          ]
        }
      ],
      "source": [
        "#Task14\n",
        "sentence=input()\n",
        "position=int(input())\n",
        "def function_name(sen,pos):\n",
        "    rem=\"\"\n",
        "    str1=sen[0]\n",
        "    for i in range(1,len(sen)):\n",
        "      if i%pos==0:\n",
        "        rem+=sen[i]\n",
        "      else:\n",
        "        str1+=sen[i]\n",
        "    print(str1+rem)\n",
        "function_name(sentence,position)"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\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",
        "Item\n",
        "\n",
        "Price(Tk)\n",
        "\n",
        "Rice\n",
        "\n",
        "105\n",
        "\n",
        "Potato\n",
        "\n",
        "20\n",
        "\n",
        "Chicken\n",
        "\n",
        "250\n",
        "\n",
        "Beef\n",
        "\n",
        "510\n",
        "\n",
        "Oil\n",
        "\n",
        "85\n",
        "\n",
        "\n",
        "\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",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"], \"Mohakhali\")\n",
        "\n",
        "total = 105 + 510 + 105 = 720 (Take the price of each item and add them.)\n",
        "\n",
        "total = 720 + 70 = 790 (Finally, add the delivery fee based on the location.)\n",
        "\n",
        "Input:\n",
        "\n",
        "[\"Rice\", \"Beef\", \"Rice\"]\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"], \"Mohakhali\")\n",
        "\n",
        "Output:\n",
        "\n",
        "790\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"])\n",
        "\n",
        "total = 105 + 510 + 105 = 720 (Take the price of each item and add them.)\n",
        "\n",
        "total = 720 + 30 = 750 (Since no location is passed in the parameter, it will\n",
        "use the default location-\"Dhanmondi\". For Dhanmondi, delivery fee of 30 taka)\n",
        "\n",
        "Input:\n",
        "\n",
        "[\"Rice\", \"Beef\", \"Rice\"]\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"])\n",
        "\n",
        "Output:\n",
        "\n",
        "750\n"
      ],
      "metadata": {
        "id": "tKE1GEvLcN4W"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w63Wq-CHnK1e",
        "outputId": "ec6de556-9102-4cdc-ce87-b7281a75401a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "750\n"
          ]
        }
      ],
      "source": [
        "#Task15\n",
        "def function_name(list1,loc=\"Dhanmondi\"):\n",
        "    dict1={ \"Rice\":105, \"Potato\": 20, \"Chicken\": 250, \"Beef\": 510, \"Oil\": 85}\n",
        "    sum=0\n",
        "    for key in list1:\n",
        "      if key in dict1:\n",
        "        sum+=dict1[k]\n",
        "    if loc==\"Dhanmondi\":\n",
        "      sum+=30\n",
        "    else:\n",
        "      sum+=70\n",
        "    print(sum)\n",
        "function_name([\"Rice\", \"Beef\", \"Rice\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Optional Tasks (16 -21) [Ungraded]\n",
        "# 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",
        "\n",
        "---\n",
        "\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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "If the money is 1234, then the function should return\n",
        "\n",
        "\"500 Taka: 2 note(s)\n",
        "\n",
        "100 Taka: 2 note(s)\n",
        "\n",
        "20 Taka: 1 note(s)\n",
        "\n",
        "10 Taka: 1 note(s)\n",
        "\n",
        "2 Taka: 2 note(s)\"\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "If the money is 151, then the function should return\n",
        "\n",
        "\"100 Taka: 1 note(s)\n",
        "\n",
        "50 Taka: 1 note(s)\n",
        "\n",
        "1 Taka: 1 note(s)\"\n"
      ],
      "metadata": {
        "id": "6qX1J4Jsc9Ke"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1RV5glAw9osA",
        "outputId": "126602f9-8617-45e9-af11-d39e76c940cd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "134\n",
            "100 Taka: 1 note(s)\n"
          ]
        }
      ],
      "source": [
        "#Task16\n",
        "def splitting_money(taka):\n",
        "  taka500=taka//500\n",
        "  rem_taka=taka%500\n",
        "  taka100=rem_taka//100\n",
        "  rem_taka1=rem_taka%100\n",
        "  taka20=rem_taka1//20\n",
        "  rem_taka2=rem_taka1%20\n",
        "  taka10=rem_taka2//10\n",
        "  rem_taka3=rem_taka2%10\n",
        "  taka2=rem_taka3//2\n",
        "  for i in range(taka):\n",
        "\n",
        "taka=int(input())\n",
        "print(splitting_money(taka))"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "remove_odd ([21, 33, 44, 66, 11, 1, 88, 45, 10, 9])\n",
        "\n",
        "Output:\n",
        "\n",
        "[44, 66, 88, 10]\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function Call:\n",
        "\n",
        "remove_odd ([11,2,3,4,5,2,0,5,3])\n",
        "\n",
        "Output:\n",
        "\n",
        "[2, 4, 2, 0]\n"
      ],
      "metadata": {
        "id": "Ng0zg_pKdUjs"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nkLEACUaCrMj",
        "outputId": "61c3f4e5-67a5-42d1-f0e4-6141bb864866"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2, 4, 2, 0]\n"
          ]
        }
      ],
      "source": [
        "def remove_odd(num_list):\n",
        "  list1=[]\n",
        "  for i in num_list:\n",
        "    if i%2==0:\n",
        "      list1.append(i)\n",
        "  return list1\n",
        "print(remove_odd([11,2,3,4,5,2,0,5,3]))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task 18\n",
        "\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",
        "Your first task is to take these arguments as user input and pass these values to the function.\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",
        "\n",
        "\n",
        "Input:\n",
        "\n",
        "10\n",
        "\n",
        "40\n",
        "\n",
        "4\n",
        "\n",
        "7\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(10, 40, 4, 7)\n",
        "\n",
        "Output:\n",
        "\n",
        "210\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Input:\n",
        "\n",
        "5\n",
        "\n",
        "100\n",
        "\n",
        "3\n",
        "\n",
        "4\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(5, 100, 3, 4)\n",
        "\n",
        "Output:\n",
        "\n",
        "2012\n"
      ],
      "metadata": {
        "id": "XEJm6FWPdjh8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "74knpdr7Wa6Y",
        "outputId": "fa1150d8-d89d-471f-8300-3d3b835be576"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "100\n",
            "3\n",
            "4\n",
            "2012\n"
          ]
        }
      ],
      "source": [
        "def function_name(start,end,div1,div2):\n",
        "  sum=0\n",
        "  for i in range(start,end):\n",
        "    if i%div1==0 or i%div2==0:\n",
        "      if i%div1==0 and i%div2==0:\n",
        "        continue\n",
        "      else:\n",
        "        sum+=i\n",
        "  return sum\n",
        "start=int(input())\n",
        "end=int(input())\n",
        "div1=int(input())\n",
        "div2=int(input())\n",
        "print(function_name(start,end,div1,div2))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Task 19\n",
        "Write a python function which will take a string as an argument.\n",
        "Your first task is to take a string as user input and pass the value to the function.\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",
        "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",
        "Return this result and print the statement, \"PSG will win the Champions League this season\" that many times.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example01: \"A black jackal is hunting a full grown deer\"\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",
        "\n",
        "\"A black jackal is hunting a full grown deer\"\n",
        "\n",
        "Function Call:\n",
        "\n",
        "function_name(\"A black jackal is hunting a full grown deer\")\n",
        "\n",
        "Output:\n",
        "\n",
        "PSG will win the Champions League this season\n",
        "\n",
        "PSG will win the Champions League this season\n",
        "\n",
        "PSG will win the Champions League this season\n",
        "\n",
        "PSG will win the Champions League this season\n",
        "\n",
        "PSG will win the Champions League this season\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example02:\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"
      ],
      "metadata": {
        "id": "KmtMblGEmy07"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sGl-0lSBPsRl",
        "outputId": "9d596753-b9a9-4838-9f3b-64623259a8c3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\"ABBCDEFEFGHI\"\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",
            "\n"
          ]
        }
      ],
      "source": [
        "def function_name(str1):\n",
        "  count=0\n",
        "  str2=str1.lower()\n",
        "  for i in range(ord('a'),ord('j')+1):\n",
        "    if chr(i) not in str2:\n",
        "        count=1\n",
        "        break\n",
        "  if count==0:\n",
        "    print(\"PSG will win the Champions League this season\\n\"*5)\n",
        "  else:\n",
        "    print(\"PSG will win the Champions League this season\\n\"*6)\n",
        "str1=input()\n",
        "function_name(str1)"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example1:\n",
        "\n",
        "individul_bonus_calculation(\"Neymar\", 1200000, 35, 5)\n",
        "\n",
        "bonus = 35 * (5 / 100 * 1200000) + 10000 = 2110000\n",
        "\n",
        "Function call:\n",
        "\n",
        "individul_bonus_calculation(\"Neymar\", 1200000, 35, 5)\n",
        "\n",
        "Output:\n",
        "\n",
        "Neymar earned a bonus of 2110000 Taka for 35 goals.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "individul_bonus_calculation('Jamal', 700000, 19, 8)\n",
        "\n",
        "bonus = 19 * (8 / 100 * 700000) + 0 = 1064000\n",
        "\n",
        "Function call:\n",
        "\n",
        "individul_bonus_calculation('Jamal', 700000, 19, 8)\n",
        "\n",
        "Output:\n",
        "\n",
        "Jamal earned a bonus of 1064000 Taka for 19 goals.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example3:\n",
        "\n",
        "individul_bonus_calculation('Luis', 80000, 25, 10)\n",
        "bonus = 25 * (10 / 100 * 80000) + 5000 = 205000\n",
        "\n",
        "Function call:\n",
        "individul_bonus_calculation('Luis', 80000, 25, 10)\n",
        "\n",
        "Output:\n",
        "Luis earned a bonus of 205000 Taka for 25 goals.\n",
        "\n"
      ],
      "metadata": {
        "id": "Hu3iwN21pAq5"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GMkj2AF_VCgS",
        "outputId": "8acbc991-8af8-40e0-9406-9b6f2744bc24"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Neymar earned a bonus of 2110000 Taka for 35 goals.\n"
          ]
        }
      ],
      "source": [
        "def individul_bonus_calculation(player,year,goal,bonus_per_goal):\n",
        "    bonus=goal * (bonus_per_goal / 100) * (year)\n",
        "    if goal>30:\n",
        "      bonus+=10000\n",
        "    elif 30>=goal>=20:\n",
        "      bonus+=5000\n",
        "    print(f'{player} earned a bonus of {int(bonus)} Taka for {goal} goals.')\n",
        "individul_bonus_calculation(\"Neymar\", 1200000, 35, 5)"
      ]
    },
    {
      "cell_type": "markdown",
      "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",
        "Since the number of players will vary, you decide to use the \"*args\" technique that you learned in your CSE110 class.\n",
        "For each player: pass the name, yearly earning, the total goal scored this season, bonus percent per goal.\n",
        "Additionally,\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",
        "[ 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",
        "[Must reuse the individul_bonus_calculation() function of the previous task]\n",
        "\n",
        "\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",
        "\n",
        "\n",
        "Example2:\n",
        "\n",
        "Function call:\n",
        "\n",
        "function_name(\"Neymar\", 1200000, 30, 10, \"Jamal\", 700000, 19, 5)\n",
        "\n",
        "Output:\n",
        "\n",
        "Neymar earned a bonus of 3605000 Taka for 30 goals.\n",
        "\n",
        "Jamal earned a bonus of 665000 Taka for 19 goals.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Example3:\n",
        "\n",
        "Function call:\n",
        "\n",
        "function_name(\"Neymar\", 1200000, 35, 5, 'Jamal', 700000, 19, 8, 'Luis', 80000,\n",
        "25, 10))\n",
        "\n",
        "Output:\n",
        "\n",
        "Neymar earned a bonus of 2110000 Taka for 35 goals.\n",
        "\n",
        "Jamal earned a bonus of 1064000 Taka for 19 goals.\n",
        "\n",
        "Luis earned a bonus of 205000 Taka for 25 goals.\n"
      ],
      "metadata": {
        "id": "yHbeGJ4aptzu"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pXUDvj93d0pl",
        "outputId": "d19f31c9-d4dc-4bbb-df12-a10e882abcf9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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 cal_bonus(*arg):\n",
        "    for i in range(0,len(arg),4):\n",
        "        individul_bonus_calculation(arg[i],arg[i+1],arg[i+2],arg[i+3])\n",
        "cal_bonus(\"Neymar\", 1200000, 35, 5, 'Jamal', 700000, 19, 8, 'Luis', 80000, 25, 10)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO0DjfkruAbErMul2oRp0zl",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}