LAB1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "STRING"
      ],
      "metadata": {
        "id": "9W_i-lWGi4NQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.From a given string, print the string in all uppercase if the number ofuppercase\n",
        "letters is more than lowercase letters. Otherwise, if lowercase is greater or equal\n",
        "to uppercase letters, print all lowercase. The inputs will contain letters (A-Z, a-z)\n",
        "only.\n"
      ],
      "metadata": {
        "id": "Zza2CvOPu9M0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uu_2F7rJcnos",
        "outputId": "639009b1-e467-44eb-88a5-b8e8d403a461"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "HOusE\n",
            "HOUSE\n"
          ]
        }
      ],
      "source": [
        "#1\n",
        "a=str(input())\n",
        "count1=0   #upper\n",
        "count2=0   #lower\n",
        "for i in a:\n",
        "  if 65<=ord(i)<=90:    #upper\n",
        "    count1 += 1\n",
        "  elif 97<=ord(i)<=122: #lower\n",
        "    count2 += 1\n",
        "\n",
        "if count1>count2:\n",
        "    print(a.upper())\n",
        "elif count2>=count1:\n",
        "    print(a.lower())"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=str(input())\n",
        "up=0\n",
        "lo=0\n",
        "for i in a:\n",
        "  if 65<= ord(i)<=90:\n",
        "    up+=1\n",
        "  else:\n",
        "    lo+=1\n",
        "if up>lo:\n",
        "  print(a.upper())\n",
        "elif lo>=up:\n",
        "  print(a.lower())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gM4Z_px0yLx_",
        "outputId": "ac4dfdad-2335-46f7-b3d0-ba34f4698aae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BaNaNa\n",
            "banana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2\n",
        "def string1(s):\n",
        "  mixed=0\n",
        "  number=0\n",
        "  word=0\n",
        "  for i in s:\n",
        "    if 48<=ord(i)<=57: #number\n",
        "      number+=1\n",
        "    elif  65<=ord(i)<=90 or  97<=ord(i)<=122: #word\n",
        "      word+=1\n",
        "  if number>0 and word>0:\n",
        "    print(\"Mixed\")\n",
        "  elif number>0:\n",
        "    print(\"Number\")\n",
        "  else:\n",
        "    print(\"word\")\n",
        "string1('213213')\n",
        "string1('jhg231j213')\n",
        "string1('Hello')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZY8QKN-KpEmv",
        "outputId": "6f7c4802-6b50-408d-d51b-44a67777d0d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number\n",
            "Mixed\n",
            "word\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#3\n",
        "s=input()\n",
        " #coDIng\n",
        "   #2                5\n",
        "for i in range(0,len(s)):\n",
        "  if s[i].isupper():\n",
        "       #2\n",
        "    b=int(i)#2\n",
        "    break\n",
        "    #2          2,5\n",
        "for i in range(b,len(s)):\n",
        "  if s[i].isupper():\n",
        "       #2\n",
        "    c=int(i)#2\n",
        "if (c-b)>1:\n",
        "  print(s[b+1:c])\n",
        "else:\n",
        "  print('Blank')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z2jszhxm7m2M",
        "outputId": "d083d82d-7f63-4331-dba6-2f7ed439bb18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "baNgladEsh\n",
            "glad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 3\n",
        "x = input('Enter: ')\n",
        "n = 0\n",
        "f = 0\n",
        "\n",
        "for i in range(0,len(x)):\n",
        "  if x[i].isupper():\n",
        "    n = int(i)\n",
        "    break\n",
        "\n",
        "for i in range(n,len(x)):\n",
        "    if x[i].isupper():\n",
        "      f = int(i)\n",
        "if (f-n) > 1:\n",
        "    print(x[n+1:f])\n",
        "else:\n",
        "    print('BLANK')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kC2TChBy1Eij",
        "outputId": "1a127d3b-66a7-4adb-c991-d2c294ab68b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter: baNgladEsh\n",
            "glad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#approach 2\n",
        "def lower_substr(string):\n",
        "    \"\"\"\n",
        "    Given a string with two uppercase characters, prints the lowercase characters\n",
        "    between the two uppercase characters.\n",
        "    \"\"\"\n",
        "    upper_count = sum(map(str.isupper, string))\n",
        "    if upper_count == 2:\n",
        "        for i in string:\n",
        "            if i.isupper():\n",
        "                start = string.find(i)\n",
        "                new_str = string.replace(i, i.lower())\n",
        "                break\n",
        "\n",
        "        for i in new_str:\n",
        "            if i.isupper():\n",
        "                end = new_str.find(i)\n",
        "                break\n",
        "\n",
        "        var = string[start + 1 : end]\n",
        "        if var != \"\":\n",
        "            print(var)\n",
        "        else:\n",
        "            print(\"BLANK\")\n",
        "\n",
        "    else:\n",
        "        print(\"More than 2 uppercase chracters\")\n",
        "\n",
        "\n",
        "user_input = input()\n",
        "lower_substr(user_input)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z3aCLCijghTc",
        "outputId": "7bb462cd-136b-4291-bb5a-efd120ecd78d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "baNgladEsh\n",
            "glad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4\n",
        "s1=input()\n",
        "s2=input()\n",
        "s=\"\"\n",
        "for i in s1:\n",
        "  if i in s2:\n",
        "    s+=i\n",
        "for j in s2:\n",
        "  if j in s1:\n",
        "    s+=j\n",
        "if s=='':\n",
        "  print(\"nothing common\")\n",
        "else:\n",
        "  print(s)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZhWDMbyzuUdu",
        "outputId": "29db295d-93d9-4186-f7db-7574412312d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "harry\n",
            "hermione\n",
            "hrrhr\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#5\n",
        "s=input()\n",
        "a=0 #upper\n",
        "b=0 #lower\n",
        "c=0  #number\n",
        "d=0 #special char\n",
        "\n",
        "for i in s:\n",
        "   if 65<=ord(i)<=90:#upper\n",
        "     a+=1\n",
        "   elif 97<=ord(i)<=122:#lower\n",
        "     b+=1\n",
        "   elif 48<=ord(i)<=57:#number\n",
        "     c+=1\n",
        "   elif (i=='_' or i == '$' or i=='#' or i=='@'):\n",
        "     d+=1\n",
        "#print(a)\n",
        "#print(b)\n",
        "#print(c)\n",
        "#print(d)\n",
        "if a==0:\n",
        "  print(\"Uppercase character missing,\")\n",
        "elif b==0:\n",
        "  print(\"Lowercase character missing,\")\n",
        "elif c==0:\n",
        "  print(\"Digit missing\")\n",
        "elif d==0:\n",
        "  print(\"special char missing\")\n",
        "elif d!=0 and a!=0 and b!=0 and c!=0:\n",
        "  print(\"OK\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dmthY5ZfxHye",
        "outputId": "1457757e-a4e3-4dc9-9a55-7d2d4c67de6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OhMyBR@CU20\n",
            "OK\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**list**"
      ],
      "metadata": {
        "id": "IHFewRQV5TSn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#1\n",
        "l1=[]\n",
        "l2=[]\n",
        "while True:\n",
        "  n=input()\n",
        "  if n == 'STOP':\n",
        "    break\n",
        "  else:\n",
        "    l1.append(int(n))\n",
        "\n",
        "for i in l1:\n",
        "  if i not in l2:\n",
        "    l2.append(i)\n",
        "\n",
        "for j in l2:\n",
        "  c=0\n",
        "  for i in l1:\n",
        "    if j == i:\n",
        "      c+=1\n",
        "  print(j,'-',c,'times')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zkTFohocq4TR",
        "outputId": "0b8b8aae-06c0-4a0f-9381-74f8fe73df4f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "20\n",
            "20\n",
            "30\n",
            "10\n",
            "50\n",
            "90\n",
            "STOP\n",
            "10 - 2 times\n",
            "20 - 2 times\n",
            "30 - 1 times\n",
            "50 - 1 times\n",
            "90 - 1 times\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#1\n",
        "#APPROACH 1\n",
        "def universal_list(number):\n",
        "    \"\"\"\n",
        "    Given number as string input, this function convert the string\n",
        "    into an integer and add the integer to the List named \"ref_list\".\n",
        "    \"\"\"\n",
        "    global ref_list\n",
        "    temp = [int(number)]\n",
        "    ref_list += temp\n",
        "\n",
        "\n",
        "user_input = input()\n",
        "ref_list = []\n",
        "while user_input != \"STOP\":\n",
        "    universal_list(user_input)\n",
        "    user_input = input()\n",
        "\n",
        "\n",
        "frequency = [[num, ref_list.count(num)] for num in ref_list]\n",
        "frequency = sorted(\n",
        "    frequency, key=lambda x: x[0]\n",
        ")  # Sorting the frequency list by the first element (number) the of the sublist\n",
        "\n",
        "sorted_frequency = []\n",
        "[\n",
        "    sorted_frequency.append(item) for item in frequency if item not in sorted_frequency\n",
        "]  # Creating a list with unique items\n",
        "\n",
        "for inpt, outpt in sorted_frequency:\n",
        "    print(f\"{inpt} - {outpt} times\")"
      ],
      "metadata": {
        "id": "YWDqwddc5VNP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46eeb7cf-7996-4255-d40b-6e3d43db2a0a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "20\n",
            "10\n",
            "20\n",
            "STOP\n",
            "10 - 2 times\n",
            "20 - 2 times\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#APPROACH 2\n",
        "user=input()\n",
        "count=0\n",
        "while user !='STOP':\n",
        "    user1=list(user)\n",
        "    #if user1 in a:\n",
        ""
      ],
      "metadata": {
        "id": "kr7_eGf-jdR2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#2\n",
        "def sum_list(lst):\n",
        "\n",
        "    global max_sum, max_lst\n",
        "    lst_sum = sum(lst)\n",
        "    if lst_sum > max_sum:\n",
        "        max_sum = lst_sum\n",
        "        max_lst = lst\n",
        "\n",
        "\n",
        "N = int(input())\n",
        "max_sum = 0\n",
        "max_list = []\n",
        "for i in range(N):\n",
        "    lst = [int(num) for num in input().split()]\n",
        "    sum_list(lst)\n",
        "\n",
        "print(max_sum)\n",
        "print(max_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pq-fIolUNFLn",
        "outputId": "efb39fa2-52c7-4795-8062-e1338c3c6b96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "1 2 3\n",
            "4 5 6\n",
            "10 11 12\n",
            "7 8 9\n",
            "33\n",
            "[10, 11, 12]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "s = 0\n",
        "summ = 0\n",
        "for i in range(n):\n",
        "  l = [int(j)for j in input().split(' ')]\n",
        "  for k in l:\n",
        "    summ += k\n",
        "  if s < summ:\n",
        "    s = summ\n",
        "  summ = 0\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8cF0H2_Kvtp6",
        "outputId": "65c752fb-3fec-40bc-a164-593144e5bf13"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "1 2 3\n",
            "4 5 6\n",
            "10 11 12\n",
            "7 8 9\n",
            "33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#3\n",
        "def UB_Jupmer(List):\n",
        "    \"\"\"\n",
        "    Given a list as input, this function returns True if the input\n",
        "    list is a UB Jumper or return False otherwise.\n",
        "    \"\"\"\n",
        "    ref_list = [num for num in range(1, len(List))]\n",
        "    abs_diff = []\n",
        "\n",
        "    for i in range(len(List) - 1):\n",
        "        elem = List[i] - List[i + 1]\n",
        "        elem = abs(elem)\n",
        "        abs_diff.append(elem)\n",
        "\n",
        "    if sorted(ref_list) == sorted(abs_diff):\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "\n",
        "user_input = input()\n",
        "result = []\n",
        "while user_input != \"STOP\":\n",
        "    List = [int(num) for num in user_input.split()]\n",
        "\n",
        "    if UB_Jupmer(List):\n",
        "        result.append(\"UB Jumper\")\n",
        "    else:\n",
        "        result.append(\"Not UB Jumper\")\n",
        "\n",
        "    user_input = input()\n",
        "\n",
        "for output in result:\n",
        "    print(output)"
      ],
      "metadata": {
        "id": "5J_ZngK-OYzA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#task 3\n",
        "b = input('Enter:')\n",
        "while b != 'STOP':\n",
        "   s = 0\n",
        "   l1 = []\n",
        "   l = [int(i)for i in input().split(' ')]\n",
        "   for j in range(len(l)-1):\n",
        "      s = abs(l[j+1] - l[j])\n",
        "      if s <= (len(l)-1):\n",
        "        l1.append(s)\n",
        "      s = 0\n",
        "   if len(l1) == (len(l) - 1):\n",
        "     print('UB Jumper')\n",
        "   else:\n",
        "     print('Not UB Jumper')\n",
        "   b = input('Enter:')"
      ],
      "metadata": {
        "id": "mO7ahB1S7yaG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#task 4\n",
        "l1 = []\n",
        "l2 = []\n",
        "n = int(input('Number of students:'))\n",
        "for i in range(1,n+1):\n",
        "  y = int(input(f'Number of times no-{i} student have already participated:'))\n",
        "  if y <= 5:\n",
        "    l1.append(y)\n",
        "  l1.sort()\n",
        "k = int(input('Number of times the team can play:'))\n",
        "for i in l1:\n",
        "  if i +k<=5:\n",
        "    l2.append(i)\n",
        "c = len(l2)//3\n",
        "print(c,'team is possible')"
      ],
      "metadata": {
        "id": "o5pW-98sv4nl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**DICTIONARY AND TUPLE**"
      ],
      "metadata": {
        "id": "eud3pRAaVGT4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#1\n",
        "d1 = {'a': 100, 'b': 100, 'c':200, 'd':300}\n",
        "\n",
        "d2 = {'a': 300, 'b': 200, 'd':400, 'e':200}\n",
        "\n",
        "d3=dict(d1)\n",
        "\n",
        "d3.update(d2)\n",
        "print(d3)\n",
        "for i, j in d1.items():\n",
        "\n",
        "    for x, y in d2.items():\n",
        "\n",
        "        if i == x:\n",
        "\n",
        "            d3[i]=(j+y)\n",
        "print(d3)\n",
        "\n",
        "t=[]\n",
        "for a in d3.values():\n",
        "   if a  in t:\n",
        "     pass\n",
        "   else:\n",
        "     t.append(a)\n",
        "print(tuple(sorted(t)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "emm5EFbLVO8N",
        "outputId": "187e2afb-675e-4130-dd63-686817f3f3d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'a': 300, 'b': 200, 'c': 200, 'd': 400, 'e': 200}\n",
            "{'a': 400, 'b': 300, 'c': 200, 'd': 700, 'e': 200}\n",
            "(200, 300, 400, 700)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 2\n",
        "l = []\n",
        "i = input()\n",
        "while i != 'STOP':\n",
        "  l.append(int(i))\n",
        "  i = input()\n",
        "d = {}\n",
        "for i in l:\n",
        "  if i not in d:\n",
        "    d.update({i:1})\n",
        "  else:\n",
        "    d.update({i:d[i]+1})\n",
        "print(d)\n",
        "for i in d.items():\n",
        "   print(i[0],'-',i[1],'times')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xicw9dTVbn4s",
        "outputId": "bff84607-4a64-4368-94fc-e569a821ba6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "20\n",
            "10\n",
            "30\n",
            "40\n",
            "50\n",
            "STOP\n",
            "{10: 2, 20: 1, 30: 1, 40: 1, 50: 1}\n",
            "10 - 2 times\n",
            "20 - 1 times\n",
            "30 - 1 times\n",
            "40 - 1 times\n",
            "50 - 1 times\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#3\n",
        "dict1 ={\"key1\" : \"value1\", \"key2\" : \"value2\", \"key3\" : \"value1\"}\n",
        "dict2 = {}\n",
        "for k, v in dict1.items():\n",
        "    dict2[v] = dict2.get(v, []) + [k]\n",
        "\n",
        "print(dict2)\n"
      ],
      "metadata": {
        "id": "R-08Y1oKSZzj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f6b8f26-97b4-4121-eff1-7b4e01ee17cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'value1': ['key1', 'key3'], 'value2': ['key2']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 3\n",
        "n = int(input('Number:'))\n",
        "dic = {}\n",
        "for i in range(n):\n",
        "  key = input('Key: ')\n",
        "  value = (input('Value: '))\n",
        "  dic.update({key:value})\n",
        "print(dic)\n",
        "d = {}\n",
        "for key,value in dic.items():\n",
        "  if value not in d.keys():\n",
        "    d.update({value:[key]})\n",
        "  else:\n",
        "    d.update({value:d[value]+[key]})\n",
        "print(d)"
      ],
      "metadata": {
        "id": "-XQz5TXxwCNC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#task 4\n",
        "n = input()\n",
        "x = n.upper()\n",
        "y = 0\n",
        "d = {1:'.,?!:', 2:'ABC', 3:'DEF', 4:'GHI',5:'JKL',6:'MNO',7:'PQRS',8:'TUV',9:'WXYZ',0:' '}\n",
        "for i in x:\n",
        "  for j in d.items():\n",
        "    if i in j[1]:\n",
        "        for k in j[1]:\n",
        "          if i == k:\n",
        "            print(j[0],end='')\n",
        "            break\n",
        "          else:\n",
        "            print(j[0],end='')\n",
        "            y += 1\n",
        "  y = 0"
      ],
      "metadata": {
        "id": "mREyiQRvwAKF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#4\n",
        "def text_to_Key (string) :\n",
        "  key_pad = {\n",
        "    '1' : ['.', ',', '?', '!', ':'],\n",
        "    '2' : ['A', 'B', 'C'],\n",
        "    '3' : ['D', 'E', 'F'],\n",
        "    '4' : ['G', 'H', 'I'],\n",
        "    '5' : ['J', 'K', 'L'],\n",
        "    '6' : ['M', 'N', 'O'],\n",
        "    '7' : ['P', 'Q', 'R', 'S'],\n",
        "    '8' : ['T', 'U', 'V'],\n",
        "    '9' : ['W', 'X', 'Y', 'Z'],\n",
        "    '0' : [' ']\n",
        "  }\n",
        "\n",
        "  txt = string.upper()\n",
        "\n",
        "  result = \"\"\n",
        "  keys = list(key_pad.items())\n",
        "\n",
        "  for i in range(len(txt)):\n",
        "    for j in range(len(keys)):\n",
        "        for k in range(len(keys[j][1])):\n",
        "            if txt[i] == keys[j][1][k]:\n",
        "                result+=((k+1)*keys[j][0])\n",
        "  return result\n",
        "print(text_to_Key(\"Hello, World!\"))"
      ],
      "metadata": {
        "id": "GxFfzT3raG49",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9a3ca207-d8e4-41f8-d15f-01dc3f036a75"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4433555555666110966677755531111\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**FUNCTION**"
      ],
      "metadata": {
        "id": "gSgNwEYln6KJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#1\n",
        "def bmi(height,weight):\n",
        "\n",
        "  person_bmi=weight/(height/100)**2\n",
        "  print(person_bmi)\n",
        "\n",
        "  if person_bmi < 18.5:\n",
        "    return ('you are underweight')\n",
        "  elif 18.5< person_bmi < 24.9:\n",
        "    print('you are normal')\n",
        "  elif 25< person_bmi<30 :\n",
        "    print('you are overweight')\n",
        "  elif person_bmi>30:\n",
        "    return ('you are obese')\n",
        "bmi(175,96)\n",
        "bmi(152,48)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J9Xc93omoAff",
        "outputId": "a1f67352-1c17-4ed7-e76f-8db8539b6c90"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "31.346938775510203\n",
            "20.775623268698062\n",
            "you are normal\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 1\n",
        "def BMI(h, w):\n",
        "  hi = h/100\n",
        "  b = w/(hi**2)\n",
        "  if b < 18.5:\n",
        "    print(f'Score is {b:.1f}. You are Underweight')\n",
        "  elif 18.5 <= b <= 24.9:\n",
        "    print(f'Score is {b:.1f}. You are Normal')\n",
        "  elif 25 <= b <= 30:\n",
        "    print(f'Score is {b:.1f}. You are Overweight')\n",
        "  else:\n",
        "    print(f'Score is {b:.1f}. You are Obese')\n",
        "BMI(int(input()),int(input()))"
      ],
      "metadata": {
        "id": "y34yf6qMwMkE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#2\n",
        "#approach 1\n",
        "def myfun(min, max, div):\n",
        "\n",
        " sum = 0\n",
        " #sum=0+0+2+4+6+8=20\n",
        "#                0   10\n",
        " for i in range(min, max):\n",
        "\n",
        "  if i%div == 0:\n",
        "#       2\n",
        "    sum += i\n",
        "\n",
        " print(sum)\n",
        "myfun(0,10,2)\n",
        "myfun(3,16,3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FqRgz9GgxoXo",
        "outputId": "2c158462-82f9-472e-9c71-a3b5a3d9d861"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n",
            "45\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2\n",
        "#approach2\n",
        "min=int(input()) #0\n",
        "max=int(input()) #10\n",
        "div=int(input()) #2\n",
        "s=0\n",
        "#s=0+2+4+6+8=20\n",
        "#   0             0   10\n",
        "for i in range (min, max):\n",
        "   if i%div == 0:\n",
        "#      0%2\n",
        "     s += i\n",
        "print(s)"
      ],
      "metadata": {
        "id": "gNtIK2_XpDN3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26c20796-92ef-4cb1-c492-237c57ddd18c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "10\n",
            "2\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 2\n",
        "def divisor(max, min, div):\n",
        "  sum = 0\n",
        "  for i in range(max,min):\n",
        "    if i%div == 0:\n",
        "      sum += i\n",
        "  return sum\n",
        "m = int(input())\n",
        "mi = int(input())\n",
        "di = int(input())\n",
        "v = divisor(m,mi,di)\n",
        "print(v)"
      ],
      "metadata": {
        "id": "D4Ws4gnrPZ1F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#3\n",
        "#approach 1\n",
        "def foodpanda_order(meal,place='Mohakhali'):\n",
        "   place.lower()\n",
        "   if place == 'Mohakhali':\n",
        "    delivery_charge=40\n",
        "    #print(delivery_charge)\n",
        "   else:\n",
        "    delivery_charge=60\n",
        "    #print(delivery_charge)\n",
        "\n",
        "   if meal == 'BBQ Chicken Cheese Burger':\n",
        "     return 250+delivery_charge+(.08*250)\n",
        "     #print (meal_cost)\n",
        "   elif meal == 'Beef Burger':\n",
        "     return 170+delivery_charge+(.08*170)\n",
        "    #print(meal_cost)\n",
        "   elif meal == 'Naga Drums':\n",
        "     return 200+delivery_charge+(.08*200)\n",
        "    #print(meal_cost)\n",
        "\n",
        "print(foodpanda_order('Beef Burger','Dhanmondi'))\n",
        "print(foodpanda_order('Beef Burger'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BYrWQ5Lr1Cwc",
        "outputId": "4b78d17b-da79-4704-c4cb-5d7e03125a31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "243.6\n",
            "223.6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 3\n",
        "def total_cost(x,l = 'Mohakhali'):\n",
        "  d = {'BBQ Chicken Cheese Burger':250, 'Beef Burger':170, 'Naga Drums':200}\n",
        "  s = 0\n",
        "  for i in d.items():\n",
        "    if i[0] == x:\n",
        "      l =  i[1] + (i[1]*.08)\n",
        "  if  l != 'Mohakhali' and l != '':\n",
        "    l += 40\n",
        "  else:\n",
        "    l += 60\n",
        "  return l\n",
        "item = input()\n",
        "location = input()\n",
        "now = total_cost(item,location)\n",
        "print(now)"
      ],
      "metadata": {
        "id": "nkBhNOzswdq6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#task 4\n",
        "def replace_domain(x, y, z = 'kaaj.com'):\n",
        "  new = ''\n",
        "  for i in x:\n",
        "    if i == '@':\n",
        "      break\n",
        "    new += i\n",
        "\n",
        "  if y not in x:\n",
        "    new += '@'+ y\n",
        "    return f'Changed: {new}'\n",
        "  else:\n",
        "     new += '@' + y\n",
        "     return f'Unchanged: {new}'\n",
        "email = input()\n",
        "new = input()\n",
        "old = input()\n",
        "neww = replace_domain(email, new, old)\n",
        "print(neww)\n"
      ],
      "metadata": {
        "id": "ZYFIlgaZ7LLR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac624f7d-9439-40a9-b1e5-7fbd30434c2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "bob@sheba.xyz\n",
            "sheba.xyz\n",
            "kaaj.com\n",
            "Unchanged: bob@sheba.xyz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#5\n",
        "def palindrome(word):\n",
        "   s=word.replace(' ','')\n",
        "   #print(s)\n",
        "   x=s[::-1]\n",
        "   #print(x)\n",
        "   if x==s:\n",
        "     print('palindrome')\n",
        "   else:\n",
        "     print(\"not a palindrome\")\n",
        "palindrome('madam')\n",
        "palindrome('hello')\n",
        "palindrome('nurses run')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "izu_1K3IRkBO",
        "outputId": "35947873-8612-4fb5-bfed-e76acd8484fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "palindrome\n",
            "not a palindrome\n",
            "palindrome\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x=\"nurses run\"\n",
        "s=x.replace(' ','')\n",
        "\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6yYMJs8bVlJY",
        "outputId": "e3cc0e93-b94d-4be6-dc77-b4e2f8c8aede"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nursesrun\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def remove(s):\n",
        "  s=s.replace(' ','')\n",
        "  return s\n",
        "print(remove(\"nurses run\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KmIC0h4DWVAb",
        "outputId": "e0202c14-d19b-4a76-9ed1-628096a46397"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nursesrun\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#6\n",
        "def capitalize(s):\n",
        "  s1=s[0].upper()\n",
        "  for i in range(1,len(s)):\n",
        "    if s[i]=='i'and s[i-1]==' ' and s[i+1]==' ':\n",
        "       s1+=s[i].upper()\n",
        "    elif s[i].islower() and s[i-1]==' ' and s[i-2] in '!.?':\n",
        "      s1+=s[i].upper()\n",
        "    else:\n",
        "      s1+=s[i]\n",
        "  print(s1)\n",
        "capitalize('''my favourite animal is a dog. a dog has sharp teeth so that it can eat flesh very easily. do you know my pet dog’s name? i love my pet very much.''')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ivWRv8MWLXNk",
        "outputId": "5290767f-e18c-4e09-e532-6a091558d0b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My favourite animal is a dog. A dog has sharp teeth so that it can eat flesh very easily. Do you know my pet dog’s name? I love my pet very much.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#task 6\n",
        "def cap(x):\n",
        "  new = x[0].upper()\n",
        "  for i in range(1,len(x)):\n",
        "    if x[i] == 'i' and x[i-1] == ' ' and x[i+1] == ' ':\n",
        "      new += x[i].upper()\n",
        "    elif x[i].islower() and x[i-1] == ' ' and x[i-2] in '?!.':\n",
        "      new += x[i].upper()\n",
        "    else:\n",
        "      new += x[i]\n",
        "  return new\n",
        "v = cap(input('Enter'))\n",
        "print(v)"
      ],
      "metadata": {
        "id": "A7D3H4cZLa56"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}