python_practice_extra.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ChetanKnowIt/Python_Class/blob/main/python_practice_extra.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Python practice\n"
      ],
      "metadata": {
        "id": "5ltHj5TjGh9A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program that contains a function that has one parameter, n, representing an integer\n",
        "greater than 0. The function should return n! (n factorial). Then write a main function that calls this\n",
        "function with the values 1 through 20, one at a time, printing the returned results. This is what your\n",
        "output should look like:\n",
        "\n",
        "1 1\n",
        "\n",
        "2 2\n",
        "\n",
        "3 6\n",
        "\n",
        "4 24\n",
        "\n",
        "5 120\n",
        "\n",
        "6 720\n",
        "\n",
        "7 5040\n",
        "\n",
        "8 40320\n",
        "\n",
        "9 362880"
      ],
      "metadata": {
        "id": "pEyv9xJmJdU2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fact(n):\n",
        "  f = 1\n",
        "  for i in range(1,n+1):\n",
        "    f = f*i\n",
        "  return f\n",
        "\n",
        "if __name__==\"__main__\":\n",
        "  for i in range(1,21):\n",
        "    print(i,fact(i))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QWU14zmJGmZQ",
        "outputId": "31dc0898-6412-4198-afc7-92f6cf5729a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 1\n",
            "2 2\n",
            "3 6\n",
            "4 24\n",
            "5 120\n",
            "6 720\n",
            "7 5040\n",
            "8 40320\n",
            "9 362880\n",
            "10 3628800\n",
            "11 39916800\n",
            "12 479001600\n",
            "13 6227020800\n",
            "14 87178291200\n",
            "15 1307674368000\n",
            "16 20922789888000\n",
            "17 355687428096000\n",
            "18 6402373705728000\n",
            "19 121645100408832000\n",
            "20 2432902008176640000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python Program to get Maximum product of elements of list in a 2D list\n",
        "Input :  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
        "Output : 504\n",
        "Explanation:1*2*3 = 6, 4*5*6 = 120, 7*8*9 = 504\n",
        "Since maximum is 504.\n"
      ],
      "metadata": {
        "id": "XTAzgqMQJSeH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getmax(l):\n",
        "  sublst = []\n",
        "  result = []\n",
        "  for i in range(0, len(l)):\n",
        "    sublst = l[i]\n",
        "    #print(sublst)\n",
        "    p=1\n",
        "    for j in sublst:\n",
        "      p = p*j\n",
        "    result.append(p)\n",
        "  #print(result)\n",
        "  return max(result)\n",
        "\n",
        "if __name__==\"__main__\":\n",
        "  lst =  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
        "  print(getmax(lst))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EJr_h9g9JXle",
        "outputId": "99e36567-6772-4039-e03a-e5353e625b96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "504\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sum of number digits in List\n",
        "The original list is : [12, 67, 98, 34]\n",
        "List Integer Summation : [3, 13, 17, 7]\n"
      ],
      "metadata": {
        "id": "LI5BVO7u7Nqp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l=[12,67,98,34]\n",
        "new_lst=[]\n",
        "for i in l:\n",
        "  sum = 0\n",
        "  while i!=0:\n",
        "    sum = sum + i%10\n",
        "    i=i//10  \n",
        "  new_lst.append(sum)\n",
        "print(new_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OTlUTshx0dOD",
        "outputId": "bdb751ab-832d-4b43-c9a4-f90bd11cb8ae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 13, 17, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GRsJ4J0RH1e3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Program to print duplicates from a list of integers\n",
        "\n",
        "Input :  list = [-1, 1, -1, 8]\n",
        "Output : output_list = [-1]\n",
        "\n",
        "Input : list = [10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20]\n",
        "Output : output_list = [20, 30, -20, 60]\n"
      ],
      "metadata": {
        "id": "mTDHQ9--HYGy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p =  [10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20] \n",
        "s=[]\n",
        "for i in p:\n",
        "  if p.count(i)>1:\n",
        "    s.append(i)\n",
        "\n",
        "e=list(set(s))\n",
        "print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4epIrxLGDeL",
        "outputId": "07fc3b1f-2ee7-4295-8de0-2807baa12edf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[20, -20, 30, 60]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "------------------------------------------------------------------\n",
        "Uncommon elements in Lists of List\n",
        "The original list 1 : [[1, 2], [3, 4], [5, 6]]\n",
        "The original list 2 : [[3, 4], [5, 7], [1, 2]]\n",
        "The uncommon of two lists is : [[5, 6], [5, 7]]\n",
        "\n",
        "------------------------------------------------------------------"
      ],
      "metadata": {
        "id": "7PJ-xdJtKqmB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l1 = [[1,2], [3,4], [5,6]]\n",
        "l2 = [[3,4], [5,7], [1,2]]\n",
        "l3 = []\n",
        "l4 = []\n",
        "\n",
        "for i in l1:\n",
        "  if i not in l2:\n",
        "    l4.append(i)\n",
        "    \n",
        "for i in l2:\n",
        "  if i not in l1:\n",
        "    l4.append(i)\n",
        "\n",
        "\n",
        "print(l4)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nP8bQbMsF2Ft",
        "outputId": "4763905e-6256-4c9e-c858-da9561cd24d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[5, 6], [5, 7]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8g_mWTywSwYz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n=8888218321\n",
        "sum = 0\n",
        "\n",
        "while n!=0:\n",
        "    temp=n%10\n",
        "    sum = sum + temp\n",
        "    n=n//10\n",
        "    \n",
        "print(sum)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X1zySqqM0Xkz",
        "outputId": "59daae92-e49d-4bac-d202-069d89f8fbe9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "49\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.random.randint(1,100,20)\n",
        "print(\"input numpy array: \", a)\n",
        "\n",
        "\n",
        "def primeno(n):\n",
        "  flag = False\n",
        "  for i in range(2,n):\n",
        "    if (n % i) == 0:\n",
        "            # if factor is found, set flag to True\n",
        "            flag = True\n",
        "            # break out of loop\n",
        "            break\n",
        "  if not flag:\n",
        "    return n\n",
        "\n",
        "lst = []\n",
        "for i in a:\n",
        "  lst.append(primeno(i))\n",
        "new_list = [i for i in lst if i is not None]\n",
        "#print(new_list)\n",
        "a1 = np.array(new_list)\n",
        "print(\"output prime array: \", a1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jOlKDNH2rfIB",
        "outputId": "4e613ce3-c219-4507-d880-af51a6a8ea18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input numpy array:  [ 7 50 10 56 99 21 90  9 91 60 57 35 51 69 18  9 24  6 35 57]\n",
            "output prime array:  [7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Reverse Row sort in Lists of List The original list is : [[4, 1, 6], [7, 8], [4, 10, 8]] The reverse sorted Matrix is : [[6, 4, 1], [8, 7], [10, 8, 4]]"
      ],
      "metadata": {
        "id": "LEMUZgUCfc4r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l =  [[4, 1, 6], [7, 8], [4, 10, 8]]\n",
        "for i in range(len(l)):\n",
        "  l[i].sort(reverse=True)\n",
        "print(l)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wgrjhy7JfV5g",
        "outputId": "171d055c-366a-4e03-cabd-c3dd683846f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[6, 4, 1], [8, 7], [10, 8, 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Python program to find the sum of a Sublist\n",
        "The original list is : [[4, 1, 6], [7, 8], [4, 10, 8]]\n",
        "result is [11,15,22]\n"
      ],
      "metadata": {
        "id": "4fi3g7_r6KTb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l =  [[4, 1, 6], [7, 8], [4, 10, 8]]\n",
        "newlst = []\n",
        "for i in range(len(l)):\n",
        "  temp = sum(l[i])\n",
        "  newlst.append(temp)\n",
        "\n",
        "  \n",
        "print(newlst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PsyMD5ko6Lbi",
        "outputId": "28ac6375-dcd9-4a4d-cf8f-6349899cda03"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[11, 15, 22]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "------------------------------------------------------------------\n",
        "Python Program to Square Each Odd Number in a List using List Comprehension\n",
        "data=[1,2,3,4,5,6,7]\n",
        "[1, 9, 25, 49]       "
      ],
      "metadata": {
        "id": "IYeLDtig62RJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l= [1,2,3,4,5,6,7]\n",
        "lst = [ x**2 for x in l if x%2==1]\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PNzaN2DP64Ug",
        "outputId": "9bf072c7-9d22-4316-cf05-95e2d88555d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 9, 25, 49]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "---------------------------------------------------------------\n",
        "Python program to print even length words in a string\n",
        "Input: s = \"This is a python language\"\n",
        "Output: This is python language"
      ],
      "metadata": {
        "id": "M0mD0xvj71R_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"This is a python language\" \n",
        "s1 = s.split(\" \")\n",
        "s2 = [x for x in s1 if len(x)%2==0]\n",
        "f = \" \".join(s2)\n",
        "print(f)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gq-v_Bo-73X9",
        "outputId": "2a0e7bb8-30e7-4c10-9465-9661e61f332a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is python language\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python program to capitalize the first and last character of each word in a string\n",
        "Given the string, the task is to capitalise the first and last character of each word in a string. Examples:\n",
        "\n",
        "Input: hello world \n",
        "Output: HellO WorlD"
      ],
      "metadata": {
        "id": "B3-sqYad9hIQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string = \"hello world\"\n",
        "\n",
        "#method 1\n",
        "s1 = string.split(\" \")\n",
        "lst = []\n",
        "one = []\n",
        "for i in range(0,len(s1)):\n",
        "  lst.append(s1[i][1:-1])\n",
        "  temp = s1[i][0].upper()+lst[i]+s1[i][-1].upper()\n",
        "  one.append(temp)\n",
        "\n",
        "f = \" \".join(one)\n",
        "print(f)\n",
        "\n",
        "#method 2\n",
        "print(string[0:][0].upper()+string[1:4]+string[4].upper()+\" \"+string[6].upper()+string[7:-1]+string[-1].upper())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0FJ7Stcc9jNn",
        "outputId": "9dfacb76-d3be-4029-9fad-d9618e646afa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "HellO WorlD\n",
            "HellO WorlD\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------------------------------------------------------\n",
        "\n",
        "Python program to check if a string has at least one letter and one number\n",
        "Given a string in Python. The task is to check whether the string has at least one letter(character) and one number. Return “True” if the given string full fill above condition else return “False” (without quotes).\n",
        "Examples: \n",
        "\n",
        "Input: welcome2ourcountry34\n",
        "Output: True\n",
        "\n",
        "Input: stringwithoutnum\n",
        "Output: False\n",
        "\n",
        "----------------------------------------------------------------------"
      ],
      "metadata": {
        "id": "jLoBUdPfOMGU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string = \"stringwithoutnum\"\n",
        "\n",
        "a = 0\n",
        "b = 0\n",
        "for i in string:\n",
        "  if i.isdigit():\n",
        "    a = 1\n",
        "    continue\n",
        "  elif i.isalpha():\n",
        "    b = 1\n",
        "    continue\n",
        "\n",
        "c = a and b\n",
        "if c:\n",
        "  print(\"True\")\n",
        "else:\n",
        "  print(\"False\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k48mZ9PTOTpj",
        "outputId": "7399c10e-597f-43ad-f7b0-c41ee8722459"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "----------------------------------------------------\n",
        "returns a list of Least Frequent Character in String\n",
        "string=\"welcometoknowit\"\n",
        "least frequency char :[ 'l', 'c', 'o', 'm', 'k', 'n', 'i']\n",
        "\n",
        "----------------------------------------------------\n"
      ],
      "metadata": {
        "id": "WwUbrTKLV1jT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string = \"welcometoknowit\"\n",
        "\n",
        "lst = []\n",
        "for i in string:\n",
        "  if string.count(i)%2==1:\n",
        "    lst.append(i)\n",
        "\n",
        "new = list(set(lst))\n",
        "print(new)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XOW6b5BDV77i",
        "outputId": "596b93d8-fdbf-4eff-cfbe-0a33e818fa87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['n', 'm', 'c', 'o', 'k', 'l', 'i']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---------------------------------------------------\n",
        "\n",
        "Given a String list, extract frequency of specific characters in the whole strings list.\n",
        "\n",
        "Input : test_list = [“geeksforgeeks is best for geeks”], chr_list = [‘e’, ‘b’, ‘g’, ‘f’] \n",
        "\n",
        "Output : {‘g’: 3, ‘e’: 7, ‘b’: 1, ‘f’ : 2} \n",
        "\n",
        "---------------------------------------------------------"
      ],
      "metadata": {
        "id": "m2c83x9tWmiB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_list = [\"geeksforgeeks is best for geeks\"]\n",
        "\n",
        "a = 0\n",
        "b = 0\n",
        "c = 0\n",
        "d = 0\n",
        "for i in test_list[0]:\n",
        "  if i == 'e':\n",
        "    a+=1\n",
        "  elif i == 'b':\n",
        "    b+=1\n",
        "  elif i == 'g':\n",
        "    c+=1\n",
        "  elif i == 'f':\n",
        "    d+=1\n",
        "\n",
        "chr_list = ['e', 'b', 'g', 'f']\n",
        "dictionary = dict(zip(chr_list, [a,b,c,d]))\n",
        "print(dictionary)\n",
        "\n",
        "string = \"ebgf\"\n",
        "# method 2\n",
        "#d = { chr_list[i]:i for i in test_list[0] if i in chr_list}\n",
        "#print(d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hMAJP84_WsF4",
        "outputId": "5839480f-f053-464c-dac2-17a5e4d36a5a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'e': 7, 'b': 1, 'g': 3, 'f': 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "s = \"The quick brown fox jumps over the lazy dog.\"\n",
        "\n",
        "print(\"findall: \",re.findall('o',s))\n",
        "print(\"search: \",re.search('o',s))\n",
        "print(\"split: \",re.split('o',s))\n",
        "print(\"sub: \",re.sub('o',\"oo\",s))\n",
        "\n",
        "for i in re.finditer('o',s):\n",
        "  print(i)\n",
        "\n",
        "\n",
        "pat = re.compile(r'o')"
      ],
      "metadata": {
        "id": "1fsF6mo-wOIA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4f017b22-b5af-4049-8f84-f38174d3ace7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "findall:  ['o', 'o', 'o', 'o']\n",
            "search:  <re.Match object; span=(12, 13), match='o'>\n",
            "split:  ['The quick br', 'wn f', 'x jumps ', 'ver the lazy d', 'g.']\n",
            "sub:  The quick broown foox jumps oover the lazy doog.\n",
            "<re.Match object; span=(12, 13), match='o'>\n",
            "<re.Match object; span=(17, 18), match='o'>\n",
            "<re.Match object; span=(26, 27), match='o'>\n",
            "<re.Match object; span=(41, 42), match='o'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# String operations problem\n",
        "\n",
        "mySubject = \"Computer Science\"\n",
        "print(mySubject[0:len(mySubject)]) #Computer Science\n",
        "print(mySubject[-7:-1])\n",
        "print(mySubject[::2])\n",
        "print(mySubject[len(mySubject)-1])\n",
        "print(2*mySubject)\n",
        "print(mySubject[::-2])\n",
        "print(mySubject[:3] + mySubject[3:])\n",
        "print(mySubject.swapcase())\n",
        "print(mySubject.startswith('Comp'))\n",
        "print(mySubject.isalpha())"
      ],
      "metadata": {
        "id": "CxPKn4W8fSoC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "myAddress = \"WZ-1, New Ganga Nagar, New Delhi\"\n",
        "print(myAddress.lower()) # all lowercase\n",
        "print(myAddress.upper()) # all uppercase\n",
        "print(myAddress.count('New')) #counts the term new\n",
        "print(myAddress.find(\"New\"))\n",
        "print(myAddress.rfind(\"New\"))\n",
        "print(myAddress.split(','))\n",
        "print(myAddress.split(' '))\n",
        "print(myAddress.replace('New', 'Old'))\n",
        "print(myAddress.partition(','))\n",
        "#print(myAddress.index('Agra'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "57uvBUe8877V",
        "outputId": "16f88a1c-11e6-421b-b5e2-2678dfb61a63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "wz-1, new ganga nagar, new delhi\n",
            "WZ-1, NEW GANGA NAGAR, NEW DELHI\n",
            "2\n",
            "6\n",
            "23\n",
            "['WZ-1', ' New Ganga Nagar', ' New Delhi']\n",
            "['WZ-1,', 'New', 'Ganga', 'Nagar,', 'New', 'Delhi']\n",
            "WZ-1, Old Ganga Nagar, Old Delhi\n",
            "('WZ-1', ',', ' New Ganga Nagar, New Delhi')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "string = \"ABCDCD\"\n",
        "print(string.count(\"CD\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r6MzeEwn_QJx",
        "outputId": "2598840c-eba2-4b6e-879a-26088146f09a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mystring = input(\"Enter till ENTER pressed: \")\n",
        "\n",
        "words = 0\n",
        "alpha = 0\n",
        "digit = 0\n",
        "special = 0\n",
        "\n",
        "print(\"Total characters: \",len(mystring))\n",
        "\n",
        "# FOR WORDS\n",
        "words_list = mystring.split()\n",
        "for i in words_list:\n",
        "  if i.isalpha():\n",
        "    words+=1\n",
        "\n",
        "# FOR EVERYTHING ELSE\n",
        "s = mystring.replace(\" \", \"\")\n",
        "lst = list(s)\n",
        "for i in lst:\n",
        "  if i.isalpha():\n",
        "    alpha+=1    \n",
        "  elif i.isdigit():\n",
        "    digit+=1\n",
        "  else:\n",
        "    special+=1\n",
        "\n",
        "print(\"Total alphabets: \",alpha)\n",
        "print(\"Total digits: \",digit)\n",
        "print(\"Total special characters: \",special)\n",
        "print(\"Total word count\", words)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K8G1ziJEADr0",
        "outputId": "5046fb49-54a1-4ff4-aa81-36866a78d5f4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter till ENTER pressed: this is my string 1234 %^&\n",
            "Total Characters:  26\n",
            "Total alphabets:  14\n",
            "Total digits:  4\n",
            "Total special characters:  3\n",
            "Total word count 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# list has to return max of the 3\n",
        "# 1 is sum of positive numbers\n",
        "# 2 is sum of negative numbers\n",
        "# 3 is sum of 0's \n",
        "# whichever is greater has to be returned \n",
        "\n",
        "a = [1, 2, -3, 4, 0, 0, -3, -2]\n",
        "p = [x for x in a if x>0]\n",
        "n = [x for x in a if x<0]\n",
        "z = [x for x in a if x==0]\n",
        "psum = sum(p)\n",
        "nsum = sum(n)\n",
        "zsum = sum(z)\n",
        "\n",
        "lst = [psum, (nsum*-1), zsum]\n",
        "m = max(lst)\n",
        "if m == (nsum*-1):\n",
        "  print(m*-1)\n",
        "else:\n",
        "  print(m)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EKWAG8GwLNBb",
        "outputId": "d8a7a0b6-71f3-4afd-9991-475617e95d52"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def usrTitle(s):\n",
        "  print(s)\n",
        "  lst = s.split()\n",
        "  a = []\n",
        "  for i in lst: \n",
        "    a.append(i[0].upper()+i[1:])\n",
        "  f = \" \".join(a)\n",
        "  return f\n",
        "\n",
        "s1 = input(\"enter string: \")\n",
        "usrTitle(s1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "POZZCh1IPuoI",
        "outputId": "001f575d-13c6-47ef-fb24-d044a17aaedb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter string: this is my string\n",
            "this is my string\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'This Is My String'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def deleteChar(string,character):\n",
        "  result = \"\"\n",
        "  for i in string:\n",
        "    if i == character:\n",
        "      pass\n",
        "    else:\n",
        "      result += i\n",
        "  return result\n",
        "\n",
        "print(deleteChar(\"this is my string\", 's'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sjHSrt1NTejO",
        "outputId": "faaebf6c-f851-474a-ea76-091a63ad8672"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "thi i my tring\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def SumDigits(string):\n",
        "  cnt = 0\n",
        "  for i in string:\n",
        "    if i.isdigit():\n",
        "      cnt = cnt + int(i)\n",
        "  return cnt\n",
        "\n",
        "\n",
        "\n",
        "print(SumDigits(\"this is my string 1234\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQzykhTQUT2y",
        "outputId": "bc6c21a7-4085-4339-cff7-d5419e810672"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def PutHyphen(string):\n",
        "  return string.replace(\" \", \"-\")\n",
        "\n",
        "s = \"this is my string with many words\"\n",
        "print(PutHyphen(s))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8-exkJEjVDmv",
        "outputId": "607bc0d3-1099-4232-82e2-d2b14c89ab16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "this-is-my-string-with-many-words\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stRecord = ['Raman','A-36',[56,98,99,72,69],78.8]\n",
        "# name, rolno, marks in 5 subjects, percentage \n",
        "print(\"Percentage of Student: \", stRecord[-1])\n",
        "print(\"Marks in the 5th subject: \", stRecord[2][-1])\n",
        "print(\"Maximum marks of student: \", max(stRecord[2]))\n",
        "print(\"Roll No of student: \", stRecord[1])\n",
        "stRecord[0]='Raghav'\n",
        "print(\"Name Change: \", stRecord)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LZj2sg6cV3hg",
        "outputId": "0de49b6b-01fe-4d86-d7b1-501eb4d2c2f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Percentage of Student:  78.8\n",
            "Marks in the 5th subject:  69\n",
            "Maximum marks of student:  99\n",
            "Roll No of student:  A-36\n",
            "Name Change:  ['Raghav', 'A-36', [56, 98, 99, 72, 69], 78.8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def CntElement(l, k):\n",
        "  cnt = 0\n",
        "  for i in l:\n",
        "    cnt+=1\n",
        "  return cnt\n",
        "\n",
        "lst = [55, 22, 44, 22, 55, 11, 55, 66, 39]\n",
        "print(CntElement(lst, '55'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OHLSclOzYBwe",
        "outputId": "d3411be1-2abb-4aa7-b51d-245a19dd3ffa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = int(input(\"Enter number of integers you want: \"))\n",
        "lst = []\n",
        "for i in range(0, num):\n",
        "  lst.append(int(input()))\n",
        "p = [ x for x in lst if x>0]\n",
        "n = [ x for x in lst if x<0]\n",
        "print(\"First: \", lst)\n",
        "print(\"Second: \", p)\n",
        "print(\"Third: \", n)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E4lDd2XlYi7b",
        "outputId": "98542cab-a1ee-4ca5-8b06-d8f2ca9dd0c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter number of integers you want: 10\n",
            "-1\n",
            "-4\n",
            "5\n",
            "7\n",
            "99\n",
            "44\n",
            "32\n",
            "-5\n",
            "94\n",
            "234\n",
            "First:  [-1, -4, 5, 7, 99, 44, 32, -5, 94, 234]\n",
            "Second:  [5, 7, 99, 44, 32, 94, 234]\n",
            "Third:  [-1, -4, -5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def LargestNumber(a):\n",
        "  p = [x for x in a if x>0]\n",
        "  n = [x*-1 for x in a if x<0]\n",
        "  z = [x for x in a if x==0]\n",
        "  psum = max(p)\n",
        "  nsum = max(n)\n",
        "  zsum = max(z)\n",
        "\n",
        "  lst = [psum, nsum, zsum]\n",
        "  \n",
        "  m = max(lst)\n",
        "  if m == nsum:\n",
        "    return (m*-1)\n",
        "  else:\n",
        "    return m \n",
        "\n",
        "\n",
        "lst =  [-1, -4, 5, 7, 99, 44, 32, -5, 945, 234, 0]\n",
        "print(LargestNumber(lst))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8MoJLj6ocCwg",
        "outputId": "a9ff7ea7-6275-4514-aec0-a1d92bab5add"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "945\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "___________________________________________________________________\n",
        "5. Write a program to read a list of n integers and find\n",
        "their median.\n",
        "Note: The median value of a list of values is the\n",
        "middle one when they are arranged in order. If there\n",
        "are two middle values then take their average.\n",
        "Hint: You can use an built-in function to sort the list\n"
      ],
      "metadata": {
        "id": "qamGN3N-H68a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1 -2 -5 6 3 -2 -6 32 12 \n",
        "\n",
        "lst = list(map(int, input().split()))\n",
        "lst.sort()\n",
        "print(\"sorted list of ints:\",lst)\n",
        "#print(\"# of elements in list:\",len(lst))\n",
        "med = 0\n",
        "l = len(lst)\n",
        "print(lst[(l//2)], l)\n",
        "if l%2 == 1:\n",
        "  med = lst[(l//2)]\n",
        "elif l%2 == 0:\n",
        "  med = (lst[(l//2)]+lst[(l//2)-1])/2\n",
        "\n",
        "print(med)"
      ],
      "metadata": {
        "id": "47RKJIjNeuB5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f7fc3f5-955c-4a6e-8c59-72ab8f062654"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 -2 -5 6 3 -2 -6 32\n",
            "sorted list of ints: [-6, -5, -2, -2, 1, 3, 6, 32]\n",
            "1 8\n",
            "-0.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "___________________________________________________________________\n",
        "6. Write a program to read a list of elements. Modify\n",
        "this list so that it does not contain any duplicate\n",
        "elements, i.e., all elements occurring multiple times\n",
        "in the list should appear only once."
      ],
      "metadata": {
        "id": "doyYZp9_caTE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = list(set(input().split()))\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4uV6R-7YcUKs",
        "outputId": "2e707d45-b73d-4523-d3c9-c0bf0bcd717e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 42 44 2 55 2 4 44 yy aa fjfj aa\n",
            "['yy', 'fjfj', '44', '2', 'aa', '4', '42', '55']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "___________________________________________________________________\n",
        "7. Write a program to read a list of elements. Input\n",
        "an element from the user that has to be inserted in\n",
        "the list. Also input the position at which it is to be\n",
        "inserted. Write a user defined function to insert the\n",
        "element at the desired position in the list.\n",
        "_________________________________________________"
      ],
      "metadata": {
        "id": "LVxzcU2vc3-q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# accept list, index, value\n",
        "a = [1,2,3,4,5]\n",
        "idx = 4\n",
        "value= 6\n",
        "\n",
        "def insert_element(a,i,e):\n",
        "    b=a[:i] + [e] + a[i:]\n",
        "    return b\n",
        "\n",
        "result = insert_element(a,idx,value)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K7zgS4_McyFq",
        "outputId": "0f7541f2-fe69-496f-8123-d6c48b89cbac"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 6, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "___________________________________________________________________\n",
        "8. Write a program to read elements of a list.\n",
        "a) The program should ask for the position of\n",
        "the element to be deleted from the list. Write\n",
        "a function to delete the element at the desired\n",
        "position in the list.\n",
        "b) The program should ask for the value of the\n",
        "element to be deleted from the list. Write a\n",
        "function to delete the element of this value\n",
        "from the list.\n",
        "___________________________________________________________________"
      ],
      "metadata": {
        "id": "8vAn7G9tszQn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = input().split()\n",
        "pos = int(input(\"Enter pos to delete: \"))\n",
        "\n",
        "def delete_element_index(a, i):\n",
        "  b = []\n",
        "  b = a[:i-1] + a[i:]\n",
        "  return b\n",
        "\n",
        "result = delete_element_index(lst, pos)\n",
        "print(result)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m9ZKmzIps53Z",
        "outputId": "fb70bdf1-3472-4acd-e5e6-15dd25e317df"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 2 3 4 5\n",
            "Enter pos to delete: 4\n",
            "['1', '2', '3', '5']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = input().split()\n",
        "value = input(\"Enter value to delete: \")\n",
        "\n",
        "def delete_element_value(a, v):\n",
        "  b = list(filter(lambda x: x!= v, a))\n",
        "  return b\n",
        "result = delete_element_value(lst, value)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BNGPyY9VscVK",
        "outputId": "0a25f067-c765-45b0-b94a-9d220327720f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3 4 5 3 2 9 3\n",
            "Enter value to delete: 3\n",
            "['4', '5', '2', '9']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Write a program to input your friend’s, names and their\n",
        "phone numbers and store them in the dictionary as the\n",
        "key-value pair. Perform the following operations on the\n",
        "dictionary:\n",
        "a) Display the Name and Phone number for all your\n",
        "friends.\n",
        "b) Add a new key-value pair in this dictionary and\n",
        "display the modified dictionary\n",
        "2022-23\n",
        "78 Informatics Practices – Class XI\n",
        "c) Delete a particular friend from the dictionary\n",
        "d) Modify the phone number of an existing friend\n",
        "e) Check if a friend is present in the dictionary or not\n",
        "f) Display the dictionary in sorted order of names"
      ],
      "metadata": {
        "id": "DSfCWbBz0PeO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "wfgxLmZNV9of"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "names = list(map(str, input().split()))\n",
        "phones = list(map(int, input().split()))\n",
        "\n",
        "phonedir = dict(zip(names, phones))\n",
        "print(phonedir)\n",
        "\n",
        "def addnew()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FN-98KK00OUQ",
        "outputId": "f98e2573-7fd5-4ed2-954e-426b10049d23"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a b c d\n",
            "1 2 3 4 \n",
            "{'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
          ]
        }
      ]
    }
  ]
}