practical_python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "practical python",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPtJWGNweAdZLMfFumMDejz",
      "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/ARPIT2128/KU-BTECH-AIML/blob/main/practical_python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program to convert a given tuple of positive integers into an integer. Original tuple: (1, 2, 3) Convert the said tuple of positive integers into an integer: 123"
      ],
      "metadata": {
        "id": "XnAckqzmPMBl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nums=(1,2,3)\n",
        "res = int(''.join(map(str,nums)))\n",
        "print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y9e1UlTcPPY9",
        "outputId": "7abce9a7-de1e-4a1f-da25-f31b9afe6312"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to demonstrate basic data types and purposefully raise indentation error along with its correction."
      ],
      "metadata": {
        "id": "pNlOE2xrPh82"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 20     \n",
        "\n",
        "print(x)\n",
        "\n",
        "print(type(x))\n",
        "\n",
        "y = 20.5 #float\n",
        "\n",
        "print(y)\n",
        "\n",
        "print(type(y))\n",
        "\n",
        "z= 1j        \n",
        "\n",
        "print(z)\n",
        "\n",
        "print(type(z))\n",
        "a = \"GoEduHub.com\"   \n",
        "\n",
        "print(a)\n",
        "\n",
        "print(type(a))\n",
        "b = [\"Go\", \"Edu\", \"Hub\"]       #list\n",
        "\n",
        "print(b)\n",
        "\n",
        "print(type(b))\n",
        "c= (\"Python\", \"from\", \"GoEduHub.com\")       #tuple\n",
        "\n",
        "print(c)\n",
        "\n",
        "print(type(c))\n",
        "d= {\"name\" : \"anu\", \"age\" : 36}  #dict\n",
        "\n",
        "print(d)\n",
        "\n",
        "print(type(d))\n",
        "e = True  #bool\n",
        "\n",
        "print(e)\n",
        "\n",
        "print(type(e))\n",
        "\n",
        "f = b\"Hello\"  \n",
        "\n",
        "print(f)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XPIIhxmWPjvV",
        "outputId": "96d4ae9c-76ca-40f5-84ed-3ce6035e0859"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n",
            "<class 'int'>\n",
            "20.5\n",
            "<class 'float'>\n",
            "1j\n",
            "<class 'complex'>\n",
            "GoEduHub.com\n",
            "<class 'str'>\n",
            "['Go', 'Edu', 'Hub']\n",
            "<class 'list'>\n",
            "('Python', 'from', 'GoEduHub.com')\n",
            "<class 'tuple'>\n",
            "{'name': 'anu', 'age': 36}\n",
            "<class 'dict'>\n",
            "True\n",
            "<class 'bool'>\n",
            "b'Hello'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to compute distance between two points taking input from the user (Pythagorean Theorem)."
      ],
      "metadata": {
        "id": "FuDubydAPqN8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x1=int(input(\"enter x1 : \"))\n",
        "\n",
        "x2=int(input(\"enter x2 : \"))\n",
        "\n",
        "y1=int(input(\"enter y1 : \"))\n",
        "\n",
        "y2=int(input(\"enter y2 : \"))\n",
        "\n",
        "result= ((((x2 - x1 )**2) + ((y2-y1)**2) )**0.5)\n",
        "\n",
        "print(\"distance between\",(x1,x2),\"and\",(y1,y2),\"is : \",(result))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8YwQsBqsPxE9",
        "outputId": "5f28f600-bab8-47a4-ae17-55d92814c87f"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter x1 : 34\n",
            "enter x2 : 23\n",
            "enter y1 : 12\n",
            "enter y2 : 12\n",
            "distance between (34, 23) and (12, 12) is :  11.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program (a) For checking whether the given number is even or not (b) To check whether given number is Armstrong or not."
      ],
      "metadata": {
        "id": "v6L5CYV7QDQr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = int(input(\"Enter a number: \"))\n",
        "s = 0\n",
        "temp = num\n",
        "while temp > 0:\n",
        "   digit = temp % 10\n",
        "   s += digit ** 3\n",
        "   temp //= 10\n",
        "if num == s:\n",
        "   print(num,\"is an Armstrong number\")\n",
        "else:\n",
        "   print(num,\"is not an Armstrong number\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tIMBc4uDQEAX",
        "outputId": "b43b053c-3a8c-49d5-9dea-aed1c4b22b56"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 407\n",
            "407 is an Armstrong number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = int(input(\"Enter a number: \"))  \n",
        "if (num % 2) == 0:  \n",
        "   print(\"{0} is Even number\".format(num))  \n",
        "else:  \n",
        "   print(\"{0} is Odd number\".format(num))  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QjlFSHXoQVS-",
        "outputId": "c23ec499-9bd7-464b-e5bf-648e964ea0f4"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 56\n",
            "56 is Even number\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program using a while loop that asks the user for a number and prints a countdown from that number to zero."
      ],
      "metadata": {
        "id": "VDDjamYSQa6a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n=int(input(\"Enter your number\"))\n",
        "\n",
        "while(n>=0):\n",
        "\n",
        "    print(n)\n",
        "\n",
        "    n=n-1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L8ZPO4SaQdxj",
        "outputId": "45a6aad7-d0a9-4550-a55c-601f7b2d6540"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your number4\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to count the number of characters in the string and store them in a dictionary data structure.\n",
        "\n"
      ],
      "metadata": {
        "id": "RAzixZJwQn_C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s1=input(\"enter string : \")\n",
        "\n",
        "f = {} \n",
        "\n",
        "for i in s1: \n",
        "\n",
        "    if i in f: \n",
        "\n",
        "        f[i] += 1\n",
        "\n",
        "    else: \n",
        "\n",
        "        f[i] = 1\n",
        "\n",
        "print(f)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fOPgSLM8Qo2D",
        "outputId": "0a7a9a98-b4cc-4a03-bf2d-91b9669a4b60"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter string : hello\n",
            "{'h': 1, 'e': 1, 'l': 2, 'o': 1}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to demonstrate list and tuple in python. Write a program using a for loop that loops over a sequence."
      ],
      "metadata": {
        "id": "i51oNEXkQ5lf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = () \n",
        "\n",
        "print (t)\n",
        "\n",
        "tup = 'python', 'tuple'\n",
        "\n",
        "print(tup) \n",
        "tup = ('python', 'GoEduHub') \n",
        "\n",
        "print(tup) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_9HDjp2MQ6tZ",
        "outputId": "49790b58-65ea-4853-a249-e020b709a61d"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "()\n",
            "('python', 'tuple')\n",
            "('python', 'GoEduHub')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "L = []\n",
        "print(\"Blank List: \")\n",
        "print(L)\n",
        " \n",
        "# Creating a List of numbers\n",
        "L = [10, 20, 14]\n",
        "print(\"\\nList of numbers: \")\n",
        "print(L)\n",
        " \n",
        "# Creating a List of strings and accessing\n",
        "# using index\n",
        "L = [\"Geeks\", \"For\", \"Geeks\"]\n",
        "print(\"\\nList Items: \")\n",
        "print(L[0])\n",
        "print(L[2])\n",
        " \n",
        "# Creating a Multi-Dimensional List\n",
        "# (By Nesting a list inside a List)\n",
        "L = [['Geeks', 'For'], ['Geeks']]\n",
        "print(L)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jmvx1ftxRDfl",
        "outputId": "72d902dc-dbbb-40ad-e02f-d25df5c97cd0"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Blank List: \n",
            "[]\n",
            "\n",
            "List of numbers: \n",
            "[10, 20, 14]\n",
            "\n",
            "List Items: \n",
            "Geeks\n",
            "Geeks\n",
            "[['Geeks', 'For'], ['Geeks']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "color_list=['red','green','white','purple','pink','marron']\n",
        "\n",
        "for i in color_list:\n",
        "\n",
        "   print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P9LaTFemRUNI",
        "outputId": "d0a58071-4c56-43bb-f17b-619de2e4f0c9"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "red\n",
            "green\n",
            "white\n",
            "purple\n",
            "pink\n",
            "marron\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a python program that should perform the following four tasks:\n",
        "\n",
        "After getting a word (of input) from the user, your program should use a while (or for) loop to print outreach of the letters of the word. just remember that strings in python start with element 0!\n",
        "Your program should then use another loop to print out each of the letters of the (same) word in reverse order.\n",
        "Make a new variable that is the original word in reverse and print that variable. you can do this easily in python with a “string slice”.\n",
        "Ask the user for a letter to count. Use another loop to count how many times that letter appears in the original word. print out this count"
      ],
      "metadata": {
        "id": "A8Y6V6DpRZ1I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s=input(\"enter a word \")\n",
        "for i in s:\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f37iALuxRanN",
        "outputId": "20963601-6615-49e7-9a0d-b146c145a0c6"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter a word hello\n",
            "h\n",
            "e\n",
            "l\n",
            "l\n",
            "o\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "str1= input (\"Enter the Word :- \")\n",
        "for i in range ( len(str1) -1, -1,-1) :\n",
        "    print (str1[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uv4ai0hsRj6A",
        "outputId": "41996135-d0ab-4672-8e6f-cccd1a8d39d9"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the Word :- hello\n",
            "o\n",
            "l\n",
            "l\n",
            "e\n",
            "h\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "str1 = input (\"Enter the Word :- \")\n",
        "newstr = str1[::-1]\n",
        "print (newstr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_xHzqfXYRomt",
        "outputId": "74afeca0-689c-44a5-b76c-8995b3fd0025"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the Word :- hello\n",
            "olleh\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sr1= input (\"Enter the Word :- \")\n",
        "letter = input (\"Enter a letter to count :- \") \n",
        "count = 0\n",
        "for i in sr1 :\n",
        "    if i == letter :\n",
        "        count += 1\n",
        "print (\"Number of letter :- \", count )\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wk6TZXjsRuGS",
        "outputId": "3c7a1151-5dff-449f-f14c-bf3e92bb4e3a"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the Word :- hello\n",
            "Enter a letter to count :- l\n",
            "Number of letter :-  2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to print the mean, median, mode and range of the list."
      ],
      "metadata": {
        "id": "XgzVAVdvR28H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = [1, 2, 3, 4, 5]\n",
        "n = len(num)\n",
        "s=0\n",
        "for i in num:\n",
        "  s=s+i\n",
        "print(s)\n",
        "mean=s/n\n",
        "print(\"mean is \",mean)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z46WcGo1R6AK",
        "outputId": "5371506d-851c-4e0d-d131-f2f02c503ff6"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n",
            "mean is  3.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n_num = [1, 2, 3, 4, 5]\n",
        "n = len(n_num)\n",
        "n_num.sort()\n",
        "  \n",
        "if n % 2 == 0:\n",
        "    median1 = n_num[n//2]\n",
        "    median2 = n_num[n//2 - 1]\n",
        "    median = (median1 + median2)/2\n",
        "else:\n",
        "    median = n_num[n//2]\n",
        "print(\"Median is: \" ,median)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cpr7f_4zSGF9",
        "outputId": "00c8d404-97d3-43ba-d4c1-1bfd54edccda"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Median is:  3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y= [11, 8, 8, 3, 4, 4, 5, 6, 6, 6, 7, 8]\n",
        "y.sort()\n",
        "L1=[]\n",
        "i = 0\n",
        "while i < len(y) :\n",
        "    L1.append(y.count(y[i]))\n",
        "    i += 1\n",
        "d1 = dict(zip(y, L1))\n",
        "d2={k for (k,v) in d1.items() if v == max(L1) }\n",
        "print(\"mode is \",(d2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dAluTjiySMrj",
        "outputId": "a3c9c905-40dd-4292-a675-4b36da7697c2"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mode is  {8, 6}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program that uses a dictionary that contains ten usernames and passwords. the program should ask the user to enter their usernames and passwords. if the username is not in the dictionary, the program should indicate that the person is not a valid user of the system. if the username is in the dictionary, but the user does not enter the right password, the program should say that the password is invalid. if the password is correct, then the program should tell the user that they are now logged into the 1"
      ],
      "metadata": {
        "id": "NliNc-f9Snmb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dic = {'Path' : \"2003\",\n",
        "       'walla' : \"1809\",\n",
        "       'Portal' : \"1912\",\n",
        "       'Express' : \"2003\",\n",
        "       'Computer' : \"9834\",\n",
        "       'Python' : \"1990\",\n",
        "       'Mysql' : \"2001\",\n",
        "       'c++' : \"1996\",\n",
        "       'java' : \"1998\",\n",
        "       'html' : \"1999\" }\n",
        "\n",
        "username = input(\"Enter username :- \")\n",
        "\n",
        "if username in dic :\n",
        "    password = input(\"Enter password :- \")\n",
        "    if dic[username] == password :\n",
        "        print (\"You are now logged into the system.\")\n",
        "    else :\n",
        "        print (\"Invalid password.\")\n",
        "else :\n",
        "    print (\"You are not valid user.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R_hvP_QhStol",
        "outputId": "60578ac9-628e-463f-a75c-e45eb71bef2d"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter username :- html\n",
            "Enter password :- 1999\n",
            "You are now logged into the system.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program to convert a given tuple of positive integers into an integer. Original tuple: (1, 2, 3) Convert the said tuple of positive integers into an integer: 123\n",
        "\n"
      ],
      "metadata": {
        "id": "DDTWMP8MTbKy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nums=(1,2,3)\n",
        "res = int(''.join(map(str,nums)))\n",
        "print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gKzDb_ZLTcHw",
        "outputId": "8804ef82-c57d-4f09-ecdd-13554f69f50d"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a Python program to sort a list of tuples using Lambda. Original list of tuples: – Original list of tuples: – [('Discrete Mathematics', 93), ('Python Programming', 95), ('Environmental Science', 88), ('Engineering Physics', 83)] – Sorting the List of Tuples: – [('Engineering Physics', 83), ('Environmental Science', 88), ('Discrete Mathematics', 93), ('Python Programming', 95)]"
      ],
      "metadata": {
        "id": "Zus37djaS4qO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subject_marks = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]\n",
        "print(\"Original list of tuples:\")\n",
        "print(subject_marks)\n",
        "subject_marks.sort(key = lambda x: x[1])\n",
        "print(\"\\nSorting the List of Tuples:\")\n",
        "print(subject_marks)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L5XZkqrNS5mB",
        "outputId": "69376d81-1786-417c-a76a-600fa043669e"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original list of tuples:\n",
            "[('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]\n",
            "\n",
            "Sorting the List of Tuples:\n",
            "[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program that inputs a tuple having words of a string as its element e.g., (“The”,” quick”,” brown”, “fox”) and then translate each text element to pig Latin.\n",
        "Write a program that takes a tuple with words in pig latin (as created by previous question) and translate it back to original text"
      ],
      "metadata": {
        "id": "aovyr4GMTDRq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tup = (\"The\", \"quick\", \"brown\", \"fox\")\n",
        "index = 0\n",
        "while index < len(tup):\n",
        "    new = tup[ index ][1 : ] + tup[ index ][ 0 ] + \"ay\"\n",
        "    print (new, end = \" \")\n",
        "    index += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ANPMHi6pTD_J",
        "outputId": "b4069dc4-8b8a-4ef2-a768-f01b518d8260"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "heTay uickqay rownbay oxfay "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tup =(\"heTay\",\"uickqay\",\"rownbay\", \"oxfay\") \n",
        "index = 0\n",
        "while index < len(tup):\n",
        "    new = tup[ index ][ -3 ] + tup[ index ][0 : -3 ] \n",
        "    print (new, end = \" \")\n",
        "    index += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1HNwB3y-TKgV",
        "outputId": "03cce5a3-d4cb-4c0c-aaca-1d7cb1d805a5"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The quick brown fox "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to solve the Eight Queens’ problem using recursion."
      ],
      "metadata": {
        "id": "ZeYhaBoXTp7o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "C6WtKf8fTugm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a menu-driven program to implement linear search and binary search."
      ],
      "metadata": {
        "id": "EElXG4IiTxVW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def LinearSearch(array, n, k):\n",
        "\n",
        "    for j in range(0, n):\n",
        "\n",
        "        if (array[j] == k):\n",
        "\n",
        "            return j\n",
        "\n",
        "    return -1\n",
        "\n",
        " \n",
        "array = [1, 3, 5, 7, 9]\n",
        "\n",
        "k = 7\n",
        "n = len(array)\n",
        "\n",
        "result = LinearSearch(array, n, k)\n",
        "\n",
        "if(result == -1):\n",
        "\n",
        "    print(\"Element not found\")\n",
        "\n",
        "else:\n",
        "\n",
        "    print(\"Element found at index: \", result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pMBeY3_STySS",
        "outputId": "511fcca2-cbeb-46dd-c21b-a2eb888d082d"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Element found at index:  3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def binarySearch(arr, k, low, high):\n",
        "   \n",
        "    while low <= high:\n",
        "        mid = low + (high - low)//2\n",
        "        if arr[mid] == k:\n",
        "            return mid\n",
        "        elif arr[mid] < k:\n",
        "\n",
        "            low = mid + 1\n",
        "        else:\n",
        "\n",
        "            high = mid - 1\n",
        "    return -1\n",
        "\n",
        "arr = [1, 3, 5, 7, 9]\n",
        "\n",
        "k = 5\n",
        "result = binarySearch(arr, k, 0, len(arr)-1)\n",
        "\n",
        "if result != -1:\n",
        "\n",
        "    print(\"Element is present at index \" ,result)\n",
        "\n",
        "else:\n",
        "\n",
        "    print(\"Not found\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CQKiMESjT7Fj",
        "outputId": "8878cce5-fa6d-42f5-f639-911cfebe5302"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Element is present at index  2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program to implement merge sort, selection sort and insertion sort."
      ],
      "metadata": {
        "id": "6ozqL3LqTr29"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "3axkJG7HUD9s"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}