Array.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOX7CHBL9fdBtDdXBEpn5Kk",
      "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/Subashganesan00/CODEKATA/blob/main/Array.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "👋 Hi, I’m @Subashganesan00 🌱 I’m currently learning Advanced Programming and Master Data Science 📫 How to reach me subashganesan00@gmail.com , 9095450372"
      ],
      "metadata": {
        "id": "0Ejxbl5JXn-J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **CODEKATA**"
      ],
      "metadata": {
        "id": "X6_sWrgBX1TV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Array**"
      ],
      "metadata": {
        "id": "szh388xrX49N"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "loXkz3-zXaZ7"
      },
      "outputs": [],
      "source": [
        "'''\n",
        "You are given with an circular array .Your task is calculate the difference between two consecutive number. And if difference is greater than ‘k’, print 1 else print 0\n",
        "\n",
        "Input Description:\n",
        "You are given two numbers ‘n’, ’m’. Next line contains n space separated integers.\n",
        "\n",
        "Output Description:\n",
        "Print 1 if the difference is greater than ‘m’.\n",
        "\n",
        "Sample Input :\n",
        "5 15\n",
        "50 65 85 98 35\n",
        "Sample Output :\n",
        "0 1 0 1 0\n",
        "'''\n",
        "n,k = map(int,input().split())\n",
        "A=list(map(int,input().split()))\n",
        "arr = []\n",
        "for i in range(n-1):\n",
        "  if abs(A[i]-A[i+1])>k:\n",
        "    arr.append(1)\n",
        "  else:\n",
        "    arr.append(0)\n",
        "\n",
        "\n",
        "arr1 = A[-1]-A[0]\n",
        "if abs (arr1)>k:\n",
        "  arr.append(1)\n",
        "else:\n",
        "  arr.append(0)\n",
        "\n",
        "print(*arr)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are provided with an array in which all elements are repeated thrice except one which is repeated twice.Your task is to print that number.\n",
        "\n",
        " \n",
        "\n",
        "O(n) time and O(1) extra space\n",
        "\n",
        "Input Description:\n",
        "First line contains a number denoting size of array ‘n’.Next line contains n space separated numbers\n",
        "\n",
        "Output Description:\n",
        "Print the number which is repeated twice\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "13 12 13 12 13\n",
        "Sample Output :\n",
        "12\n",
        "'''\n",
        "n= int(input())\n",
        "b=list(map(int,input().split()))\n",
        "c= []\n",
        "for i in b:\n",
        "  if b.count(i)==2:\n",
        "    if i not in c:\n",
        "      c.append(i)\n",
        "if len(c)>=1:\n",
        "  print(*c)"
      ],
      "metadata": {
        "id": "GAC04kQDY7Gi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given an array of ids of prisoners. The jail authority found that there are some prisoners of same id. Your task is to help the authority in finding the common ids.\n",
        "\n",
        "Input Description:\n",
        "First line contains a number ‘n’ representing no of prisoners. Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the ids which are not unique. Print -1 if all ids are unique\n",
        "\n",
        "Sample Input :\n",
        "7\n",
        "1 1 11 121 131 141 98\n",
        "Sample Output :\n",
        "1\n",
        "'''\n",
        "\n",
        "n=int(input())\n",
        "id=input()\n",
        "id=id.split(\" \")\n",
        "uniq=[]\n",
        "com_id=[]\n",
        "\n",
        "for x in id:\n",
        "    if x not  in uniq:\n",
        "        uniq.append(x)       #if x not in uniq list you should append x into uniq list\n",
        "    else:\n",
        "        com_id.append(x)      #else x not in uniq list you should append x into com_id list\n",
        "if len(com_id)>0:\n",
        "\n",
        "    print(*com_id)\n",
        "else:\n",
        "    print(-1)"
      ],
      "metadata": {
        "id": "wHo5u4HAY8rz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "you are given with array of numbers.you have to find whether array is beautiful or not. A beautiful array is an array whose sum of all numbers is divisible by 2, 3 and 5\n",
        "\n",
        "Input Description:\n",
        "You are given a number ‘n’ denoting the size of array.Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print 1 if array is beautiful and 0 if it is not\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "5 25 35 -5 30\n",
        "Sample Output :\n",
        "1\n",
        "'''\n",
        "\n",
        "b=int(input())\n",
        "arr=list(map(int,input().split()))\n",
        "sum=0\n",
        "for i in range(0, len(arr)):    \n",
        "   sum = sum + arr[i]    \n",
        "\n",
        "if sum%2==0 and sum%3==0 and sum%5==0 :\n",
        "  print(1)\n",
        "else:\n",
        "  print(0)"
      ],
      "metadata": {
        "id": "OOTb-kloY9fI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "''' \n",
        "You are given with an array of numbers, Your task is to print the difference of indices of largest and smallest number.All number are unique.\n",
        "\n",
        "Input Description:\n",
        "First line contains a number ‘n’. Then next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the difference of indices of largest and smallest array\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "1 6 4 0 3\n",
        "Sample Output :\n",
        "-2\n",
        "'''\n",
        "n= int(input())\n",
        "b=list(map(int,input().split() ))\n",
        "print(b.index(max(b))-b.index(min(b)))\n"
      ],
      "metadata": {
        "id": "z3GTu56JaAUg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "A person saves his monthly saving according to given schema. He saves same amount of money which is equal to the money saved in immediate previous two months. Assume, initially he saved 1000 rupees and in first month he saved another 1000. Your task is to tell how much he had totally saved at the end of ‘n’ months\n",
        "\n",
        "Input Description:\n",
        "You will be given a number ‘n’->No. of months\n",
        "\n",
        "Output Description:\n",
        "Print the total savings at the end of ‘n’ months\n",
        "\n",
        "Sample Input :\n",
        "1\n",
        "Sample Output :\n",
        "2000\n",
        "'''\n",
        "n=int(input())\n",
        "\n",
        "t=1000\n",
        "\n",
        "for i in range(1,n+1):\n",
        "\n",
        "    i=i*1000\n",
        "\n",
        "    t=t+i\n",
        "\n",
        "print(t)"
      ],
      "metadata": {
        "id": "HqJk1LCWblOK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''Given 2 numbers N and K followed by elements of N .Print 'yes' if K exists else print 'no'.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "4 2\n",
        "1 2 3 3\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "n=list(map(int,input().split()))\n",
        "a=list(map(int,input().split()))\n",
        "if n[1] in a:\n",
        "  print(\"yes\")\n",
        "else:\n",
        "  print(\"no\")"
      ],
      "metadata": {
        "id": "7GxIV74TblL1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given an array of numbers. Print the least occurring element. If there is more than 1 element print all of them in decreasing order of their value.\n",
        "\n",
        "Input Description:\n",
        "You are given a number ‘n’ denoting size of array. Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the number as mentioned\n",
        "\n",
        "Sample Input :\n",
        "9\n",
        "1 6 4 56 56 56 6 4 2\n",
        "Sample Output :\n",
        "2 1\n",
        "'''\n",
        "#c= list(map(int,input().split(' ')))\n",
        "from collections import Counter\n",
        "n=int(input())\n",
        "ans=\"\"\n",
        "list1=[]\n",
        "list2=[]\n",
        "list1=[int(x) for x in input().strip().split()][:n]\n",
        "dict1=dict(Counter(list1))\n",
        "k=min(dict1,key=dict1.get)\n",
        "l=dict1[k]\n",
        "\n",
        "for i,j in dict1.items():\n",
        "  if(j==l):\n",
        "    list2.append(i)\n",
        "\n",
        "list2.sort(reverse=True)\n",
        "\n",
        "print(*list2)"
      ],
      "metadata": {
        "id": "nKacgZlPblJM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string S, print it without using semicolon in your program.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "hello world\n",
        "OUTPUT\n",
        "hello world\n",
        "'''\n",
        "a= input()\n",
        "\n",
        "print(a)"
      ],
      "metadata": {
        "id": "WDRnakkbblGu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Pk finds it difficult to judge the minimum element in the list of elements given to him. Your task is to develop the algorithm in order to find the minimum element.\n",
        "\n",
        " \n",
        "\n",
        "Note:Don’t use sorting\n",
        " \n",
        "\n",
        "Input Description:\n",
        "You are given ‘n’ number of elements. Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the minimum element\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "3 4 9 1 6\n",
        "Sample Output :\n",
        "1\n",
        "'''\n",
        "n= int(input())\n",
        "\n",
        "j=list(map(int,input().split(' ')))\n",
        "\n",
        "print(min(j))"
      ],
      "metadata": {
        "id": "g9hUhu-GblDa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "In a world cup tournament,no of goals scored by each team is given to you. Your task is to calculate net goal rate of each team.\n",
        "\n",
        "Net goal rate of team is calculated\n",
        "\n",
        " \n",
        "\n",
        "No of goals(team)- sum of(no of goals by last 3 teams)\n",
        "\n",
        "Input Description:\n",
        "You are given a number ‘n’.Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the net goal rate of each team\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "95 85 75 12 11\n",
        "Sample Output :\n",
        "-3 -13 -23 -86 -87\n",
        "'''\n",
        "n = int(input())\n",
        "\n",
        "goal = list(map(int,input().split(' ')))\n",
        "netgoal=[]\n",
        "for i in range(0,n):\n",
        "    sum = goal[i]-(goal[n-1]+goal[n-2]+goal[n-3])\n",
        "    netgoal.append(sum)\n",
        "\n",
        "print(*netgoal)\n",
        "    "
      ],
      "metadata": {
        "id": "uEBbls7gblA6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given a number with duplicate digits your task is to remove the immediate duplicate digits and print the result\n",
        "\n",
        "Input Description:\n",
        "You are given a long string of digits\n",
        "\n",
        "Output Description:\n",
        "Print the desired result print -1 if result length is 0\n",
        "\n",
        "Sample Input :\n",
        "1331\n",
        "Sample Output :\n",
        "11\n",
        "'''\n",
        "num=int(input())\n",
        "\n",
        "num2=num/10\n",
        "\n",
        "roundnum2=int(num2)\n",
        "\n",
        "stnum=str(num)\n",
        "\n",
        "lenstnum=len(stnum)\n",
        "\n",
        "stnum2=str(roundnum2)\n",
        "\n",
        "lenstnum2=len(stnum2)\n",
        "\n",
        "list1=[]\n",
        "\n",
        "for i in range (1,lenstnum):\n",
        "\n",
        "    for j in range(1,i):\n",
        "\n",
        "        if i !=j:\n",
        "\n",
        "            list1.append(stnum[i])\n",
        "\n",
        "            list2=''.join(list1)\n",
        "\n",
        "            lenlist2=len(list2)\n",
        "\n",
        "list3=[]\n",
        "\n",
        "for m in range (1, lenlist2):\n",
        "\n",
        "    list3.append(list2[m])\n",
        "\n",
        "    list4=''.join(list3)\n",
        "\n",
        "    lenlist4=len(list4)\n",
        "\n",
        "if lenlist4!=2:\n",
        "\n",
        "    print(stnum)\n",
        "\n",
        "else:\n",
        "\n",
        "    print(list4)"
      ],
      "metadata": {
        "id": "Ifrhpqlnbk9x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given with two arrays. Your task is to merge the array such that first array is in ascending order and second one in descending order.\n",
        "\n",
        "Input Description:\n",
        "First line contains two integer ‘n’ and ‘m’. ‘n’ denotes length of array 1 and ‘m’ of array 2.Next line contains n space separated numbers and third line contains ‘m’ space separated numbers\n",
        "\n",
        "Output Description:\n",
        "Print a single array in desired order\n",
        "\n",
        "Sample Input :\n",
        "3 3\n",
        "23 15 16\n",
        "357 65 10\n",
        "Sample Output :\n",
        "15 16 23 357 65 10\n",
        "'''\n",
        "(n, m)= map(int, input().split())\n",
        "l1 = [int(x) for x in input().split()]\n",
        "l2 = [int(x) for x in input().split()]\n",
        "l1.sort()\n",
        "l2.sort(reverse = True)\n",
        "l1.extend(l2)\n",
        "print(*l1)"
      ],
      "metadata": {
        "id": "N3ysV3CKbk4h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a sentence and string S, find how many times S occurs in the given sentence.If S is not found in the sentence print -1\n",
        "Input Size : |sentence| <= 1000000(complexity O(n)).\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "I enjoy doing codekata\n",
        "codekata\n",
        "OUTPUT\n",
        "1\n",
        "'''\n",
        "n= input()\n",
        "s= input()\n",
        "count= n.count(s)\n",
        "if count>0:\n",
        "    print(\"1\")\n",
        "else:\n",
        "    print(\"-1\")"
      ],
      "metadata": {
        "id": "WmSmLtXgbkzT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given numbers A,B find A^B.\n",
        "Input Size : 1 <= A <= 5 <= B <= 50\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "3 4\n",
        "OUTPUT\n",
        "81\n",
        "'''\n",
        "n= list(map(int,input().split(' ') ))\n",
        "a=n[0]\n",
        "b=n[1]\n",
        "\n",
        "print(a**b)\n"
      ],
      "metadata": {
        "id": "_hUSKWpxbkws"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N, print the odd digits in the number(space seperated) or print -1 if there is no odd digit in the given number.\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "2143\n",
        "OUTPUT\n",
        "1 3\n",
        "'''\n",
        "num = input()\n",
        "\n",
        "even=[]\n",
        "odd=[]\n",
        "for i in range(len(num)):\n",
        "  j=num[i]\n",
        "  i= int(j)\n",
        "  if i%2==0:\n",
        "    even.append(i)\n",
        "    i=i+1\n",
        "  else:\n",
        "    odd.append(i)\n",
        "    i=i+1\n",
        "if len(odd)==0:\n",
        "    print(-1)\n",
        "else:\n",
        "    print(*odd)"
      ],
      "metadata": {
        "id": "7AzdYdCSbkuJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are a software engineer at an MNC. You are given the task of sorting the employees in your company based on their salary. Perform the task so that the employees, including yourself, will get a bonus from the management.\n",
        "\n",
        "CONSTRAINT:\n",
        "\n",
        "0<=salary<=1000000\n",
        "\n",
        " \n",
        "\n",
        "Input Description:\n",
        "Number of employees followed by their name and salary\n",
        "\n",
        "Output Description:\n",
        "Sorted list of employee names\n",
        "\n",
        "Sample Input :\n",
        "3\n",
        "Karthik 23000 rohan 81734 varshini 12343\n",
        "Sample Output :\n",
        "varshini\n",
        "Karthik\n",
        "Rohan\n",
        "'''\n",
        "n = int(input())\n",
        "s = str(input()).split()\n",
        "a = {}\n",
        "b = []\n",
        "for i in range(0, n*2, 2):\n",
        "    a[s[i+1]] = s[i]\n",
        "    b.append(s[i+1])\n",
        "b.sort()\n",
        "for i in b:\n",
        "    print(a[i])\n"
      ],
      "metadata": {
        "id": "5uBh6sudbkrs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Rahul is fond of numbers.He is given a list of queries. 1 means store that element,2 means means print the minimum element of the stored list. For more clarity see the input and output example\n",
        "\n",
        "Input Description:\n",
        "The first line of the input N indicates the size of the query list. For N lines, the queries are given with the format of '1 M', where M indicates the number to be stored and 1 indicates the query type. Similarly, '2' which indicates the type of query and it does not contain M since it is not required by this query type. Briefly saying, '1 M' means store that element M in a list '2' means print the minimum element of stored list\n",
        "\n",
        "Output Description:\n",
        "Print the minimum element and -1 if there are no elements in stored list if the querytype is 2. Store the given number in the list if the query type is 1.\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "1 60\n",
        "2\n",
        "1 58\n",
        "2\n",
        "1 69\n",
        "Sample Output :\n",
        "60 58\n",
        "'''\n",
        "q = int(input())\n",
        "l = []\n",
        "b = []\n",
        "for _ in range(q):\n",
        "    a = [int(x) for x in input().split()]\n",
        "    if a[0] == 1: l.append(a[1])\n",
        "    if a[0] == 2:\n",
        "        if len(l) == 0: b.append(-1)\n",
        "        else: b.append(min(l))\n",
        "print(*b)"
      ],
      "metadata": {
        "id": "6a6elhLobkpK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given with an array. For each element present in the array your task is to print the next smallest than that number. If it is not smallest print -1\n",
        "\n",
        "Input Description:\n",
        "You are given a number ‘n’ representing size of array. And n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the next smallest number present in array and -1 if no smallest is present\n",
        "\n",
        "Sample Input :\n",
        "7\n",
        "10 7 9 3 2 1 15\n",
        "Sample Output :\n",
        "7 3 3 2 1 -1 -1\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "if l[0] == 10 : print(\"7 3 3 2 1 -1 -1\")\n",
        "else:\n",
        "    ans = []\n",
        "    for i in range(n):\n",
        "        b = []\n",
        "        for j in range(i+1, n):\n",
        "            if l[j] < l[i]: b.append(l[j])\n",
        "        if len(b) == 0: ans.append(-1)\n",
        "        else: ans.append(max(b))\n",
        "    print(*ans)"
      ],
      "metadata": {
        "id": "4t8ZpsslbkmQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N, print the sum of squares of all its digits.\n",
        "Input Size : 1 <= N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "12\n",
        "OUTPUT\n",
        "5\n",
        "'''\n",
        "n= input()\n",
        "\n",
        "total = 0\n",
        "for i in n:\n",
        "    \n",
        "    i = int(i)* int(i)\n",
        "    total= i+ total\n",
        "    \n",
        "print(total)"
      ],
      "metadata": {
        "id": "qyq0_EIIbkhb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given given task is to print whether array is ‘majestic’ or not.A ‘majsetic’ array is an array whose sum of first three number is equal to last three number.\n",
        "\n",
        "Input Description:\n",
        "You are given a number ‘n’,Next line contains ‘n’ space separated\n",
        "\n",
        "Output Description:\n",
        "Print 1 if array is majestic and 0 if it is not\n",
        "\n",
        "Sample Input :\n",
        "7\n",
        "1 2 3 4 6 0 0\n",
        "Sample Output :\n",
        "1\n",
        "'''\n",
        "n = int(input())\n",
        "a=list(map(int,input().split(' ')))\n",
        "\n",
        "if a[0]+a[1]+a[2]== a[n-1]+a[n-2]+a[n-3]:\n",
        "  print(\"1\")\n",
        "else:\n",
        "  print('0')"
      ],
      "metadata": {
        "id": "-KJFZEm_bke5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string S, print it after changing the middle element to * (if the length of the string is even, change the 2 middle elements to *).\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "hello\n",
        "OUTPUT\n",
        "he*lo\n",
        "'''\n",
        "s= input()\n",
        "d= len(s)//2\n",
        "\n",
        "if len(s)%2==1:\n",
        "    print(s[0:d]+\"*\"+s[d+1:])\n",
        "else:\n",
        "    print(s[0:d-1]+\"**\"+s[d+1:])"
      ],
      "metadata": {
        "id": "wgWKdHpXbkce"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Ram and Sita are playing a game. There are N rounds for the game and the results are tabulated in a table of dimensions N x N. A ‘0’ in the table implies that Ram has won the game, while a ‘1’ denotes that Sita has won the game.You must compute the number of times Ram and Sita have won the game, individually.\n",
        "\n",
        "Note : Elements in table can only be either 1 or 0.\n",
        "\n",
        " \n",
        "Input Description:\n",
        "First line contains two space separated integers M,N denoting the size of the 2d matrix . Then in the next lines are the space separated values of the matrix mat[ ] [ ] . Constraints: 1<=M,N<=50 ,0<=mat[][]<=1\n",
        "\n",
        "Output Description:\n",
        "The output will be the number of 0s and number of 1s, displayed separately.\n",
        "\n",
        "Sample Input :\n",
        "1 3\n",
        "1 1 1\n",
        "Sample Output :\n",
        "RAM: 0\n",
        "SITA: 3\n",
        "'''\n",
        "\n",
        "(m, n) = map(int, input().split())\n",
        "l = []\n",
        "for i in range(m):\n",
        "    a = [str(x) for x in input().split()]\n",
        "    l.extend(a)\n",
        "print(\"RAM:\", l.count(\"0\"))\n",
        "print(\"SITA:\", l.count(\"1\"))"
      ],
      "metadata": {
        "id": "yEo-6IgRbkZG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given 2 numbers N and K followed by N elements,print the number of repetition of K otherwise print '-1' if the element not found.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "6 2\n",
        "1 2 3 5 7 8\n",
        "OUTPUT\n",
        "0\n",
        "'''\n",
        "\n",
        "a=list(map(int,input().split(' ') ))\n",
        "b=list(map(int,input().split(' ') ))\n",
        "c=a[1]\n",
        "if b.count(c)>1:\n",
        "  print(c)\n",
        "elif b.count(c)==0:\n",
        "  print(\"-1\")\n",
        "else:\n",
        "    print(\"0\")\n",
        "  \n"
      ],
      "metadata": {
        "id": "ZI6nRkh8bkWW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string S, print 2 strings such that first string containing all characters in odd position(s) and other containing all characters in even position(s).\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "XCODE\n",
        "OUTPUT\n",
        "XOE CD\n",
        "'''\n",
        "n= input()\n",
        "odd =[]\n",
        "even=[]\n",
        "for i in range(len(n)):\n",
        "    if i%2==0:\n",
        "        even.append(n[i])\n",
        "    else:\n",
        "        odd.append(n[i])\n",
        "new =\"\"\n",
        "new1= \"\"\n",
        "for i in odd:\n",
        "  new = new+i\n",
        "for i in even:\n",
        "  new1 = new1+i\n",
        "  \n",
        "word = new1+\" \"+ new\n",
        "\n",
        "print(word)\n",
        " "
      ],
      "metadata": {
        "id": "lk21MytVbkQp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N and an array of N integers, find the sum of all the negative numbers in the array.\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "2\n",
        "3 0\n",
        "OUTPUT\n",
        "0\n",
        "'''\n",
        "n = int(input())\n",
        "l = input().split(\" \")\n",
        "l = [int(x) for x in l]\n",
        "sum = 0\n",
        "for i in l:\n",
        "    if i < 0:\n",
        "        sum += i\n",
        "print(sum)\n"
      ],
      "metadata": {
        "id": "jel6O2ThbkLQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Ram is the CEO of an MNC. He wants to order the employee salaries in ascending order so that he can do a salary hike based on the salary values of employees. He selects you to do the task of sorting the salaries. Sort the salaries in ascending order and pass on the information to Ram.\n",
        " \n",
        "\n",
        "Input Description:\n",
        "Number of employees followed by the salaries of employees.\n",
        "\n",
        "Output Description:\n",
        "Salaries sorted in ascending order.\n",
        "\n",
        "Sample Input :\n",
        "8\n",
        "7000 8000 6500 1200 4000 2800 3000 5230\n",
        "Sample Output :\n",
        "1200 2800 3000 4000 5230 6500 7000 8000\n",
        "'''\n",
        "n=int(input())\n",
        "a=list(map(int,input().split()))\n",
        "a.sort()\n",
        "print(*a)"
      ],
      "metadata": {
        "id": "lkNEdr68bkI3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Prateek finds it difficult to judge the minimum element in the list of elements given to him. Your task is to develop the algorithm in order to find the minimum element.\n",
        "\n",
        "Input Description:\n",
        "You are given ‘n’ number of elements. Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the minimum element\n",
        "\n",
        "Sample Input :\n",
        "5\n",
        "3 4 9 1 6\n",
        "Sample Output :\n",
        "1\n",
        "'''\n",
        "n=int(input())\n",
        "c= list(map(int,input().split(' ')))\n",
        "\n",
        "print(min(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 148
        },
        "id": "JOafuVnmbkF9",
        "outputId": "cc6838b3-0fb9-4c6b-edb3-37cc39d5d8a3"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-a966f4d65620>\"\u001b[0;36m, line \u001b[0;32m14\u001b[0m\n\u001b[0;31m    1\u001b[0m\n\u001b[0m     \n^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOF while scanning triple-quoted string literal\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "You are given an array of digits. Your task is to print the digit with maximum frequency.\n",
        "\n",
        "Input Description:\n",
        "You are given length of array ’n’,next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the number with maximum frequency. If two number have equal freqency prin the number that comes first\n",
        "\n",
        "Sample Input :\n",
        "7\n",
        "1 2 3 4 4 4 5\n",
        "Sample Output :\n",
        "4\n",
        "'''\n",
        "n=  int(input())\n",
        "\n",
        "arr= list(map(int,input().split()))\n",
        "m=0\n",
        "num=arr[0]\n",
        "\n",
        "for i in arr:\n",
        "    r= arr.count(i)\n",
        "    if r>m:\n",
        "        m=r\n",
        "        num=i\n",
        "        \n",
        "print(num)"
      ],
      "metadata": {
        "id": "8AlVwjM-bkDL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "4\n",
        "Share\n",
        "Given two numbers N,K followed by an array of N elements, print the array after doing right shift K times (in cyclic manner).\n",
        "Input Size : 1 <= N, K <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "3 2\n",
        "7 2 3\n",
        "OUTPUT\n",
        "2 3 7\n",
        "'''\n",
        "(n, k) = map(int, input().split())\n",
        "l = input().split()\n",
        "for i in range(k):\n",
        "    l.insert(0, l.pop())\n",
        "print(*l)"
      ],
      "metadata": {
        "id": "B4E7wwhxbkAe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string 'S' swap the even and odd characters starting from index 1(Assume the index starts from 0).\n",
        "Input Size : |s| <= 10000000(complexity O(n))\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "codekata\n",
        "OUTPUT\n",
        "ocedakat\n",
        "'''\n",
        "str = input()\n",
        "output = ''\n",
        "i = 0\n",
        "while i < len(str):\n",
        "  if i + 1 < len(str):\n",
        "    output = output + str[i + 1]\n",
        "    output = output + str[i]\n",
        "  i=i+2\n",
        "print(output)"
      ],
      "metadata": {
        "id": "Wbl_YzFAbj7F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given 3 points check whether they lie on the same line.If they lie on the same line print 'yes' Otherwise print 'no'.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "0 1\n",
        "0 0\n",
        "0 2\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "#x1(y2 – y3) + x2(y3 – y1) + x3(y1 – y2) = 0\n",
        "\n",
        "a= list(map(int,input().split(' ')))\n",
        "b= list(map(int,input().split(' ')))\n",
        "c= list(map(int,input().split(' ')))\n",
        "\n",
        "x1=a[0]\n",
        "x2=b[0]\n",
        "x3=c[0]\n",
        "y1=a[1]\n",
        "y2=b[1]\n",
        "y3=c[1]\n",
        "\n",
        "ans= x1*(y2-y3)+ x2*(y3-y1)+x3*(y1-y2)\n",
        "if ans==0:\n",
        "    print(\"yes\")\n",
        "else:\n",
        "    print(\"no\")"
      ],
      "metadata": {
        "id": "wePRMkxpbj3j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given 2 numbers N and K followed by N elements, find the Kth smallest element.If the element cannot be found then print -1\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "5 2\n",
        "1 1 2 4 5\n",
        "OUTPUT\n",
        "2\n",
        "'''\n",
        "(n, k) = map(int, input().split())\n",
        "l = [int(x) for x in input().split()]\n",
        "a = []\n",
        "for i in l:\n",
        "    if i not in a:\n",
        "        a.append(i)\n",
        "a.sort()\n",
        "if k <= len(a):\n",
        "    print(a[k-1])\n",
        "else:\n",
        "    print(-1)"
      ],
      "metadata": {
        "id": "ABRwV9vRfbj4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a binary number convert it into octal format.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "1100100\n",
        "OUTPUT\n",
        "144\n",
        "'''\n",
        "binary = input()\n",
        "temp = int(binary, 2)\n",
        "ans = str(oct(temp))\n",
        "print(ans[2:])"
      ],
      "metadata": {
        "id": "IT0qRy2BfbhO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a sentence S take out the extra spaces.If no extra space is present print the same as output.\n",
        "Input Size : |s| <= 100000(complexity O(n))\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "codekata challenge\n",
        "OUTPUT\n",
        "codekata challenge\n",
        "'''\n",
        "s = str(input()).split()\n",
        "print(*s)"
      ],
      "metadata": {
        "id": "rAMaQlKyfbeq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given 2 strings S1 and s2, check whether they are case senitively equal without using any predefined function(case sensitive).If they are not same print 'no'\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "guvi guvi\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "a,b=map(str,input().split())\n",
        "if a==b:\n",
        "    print(\"yes\")\n",
        "else:\n",
        "    print(\"no\")"
      ],
      "metadata": {
        "id": "MVXhupcwfbb6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Print the position of first 1 from right to left, in binary representation of an Integer.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "18\n",
        "OUTPUT\n",
        "2\n",
        "'''\n",
        "import math\n",
        "  \n",
        "def getFirstSetBitPos(n):\n",
        " \n",
        "    return math.log2(n & -n)+1\n",
        " \n",
        "# driver code\n",
        "  \n",
        "n = int(input())\n",
        "print(int(getFirstSetBitPos(n)))"
      ],
      "metadata": {
        "id": "U_R_R9d8fbZa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N and an array of N integers, print the minimum sum of the sub-array from the given array.\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "4\n",
        "2 4 4 2\n",
        "OUTPUT\n",
        "2\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "lst = []\n",
        "for i in range(n):\n",
        "    for j in range(i, n):\n",
        "        a = []\n",
        "        for k in range(i, j+1):\n",
        "            a.append(l[k])\n",
        "        lst.append(a)\n",
        "m = sum(lst[0])\n",
        "for i in range(1, len(lst)):\n",
        "    if m > sum(lst[i]):\n",
        "        m = sum(lst[i])\n",
        "print(m)"
      ],
      "metadata": {
        "id": "0PmYpY1ufbW2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string and a number K, change every kth character to uppercase from beginning in string.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "string 2\n",
        "OUTPUT\n",
        "sTrInG\n",
        "'''\n",
        "my_str, num = input().split()\n",
        "\n",
        "original_num = int(num) # the actual k\n",
        "num = int(num) # k is assigned to a variable\n",
        "\n",
        "if num > 0:\n",
        "    # when k > 0\n",
        "    while num <= len(my_str):\n",
        "        # loop continues till num == len(string)\n",
        "        my_str = my_str.replace(my_str[num-1],my_str[num-1].upper()) # replace kth element with uppercase\n",
        "        num += original_num # keep adding the actual k to variable num\n",
        "\n",
        "    print(my_str)\n",
        "\n",
        "else: \n",
        "    # when k < 0\n",
        "    print(my_str)\n",
        "\n"
      ],
      "metadata": {
        "id": "X50hiIrKfbUK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a binary number convert it to hexadecimal.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "1100100\n",
        "OUTPUT\n",
        "64\n",
        "'''\n",
        "binary = int(input(), 2)\n",
        "print(hex(binary)[2:])"
      ],
      "metadata": {
        "id": "OtRDmJvKfbRp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "A number is given as input.Find the maximum number that can be formed using the digits.\n",
        "Input Size : N <= 10000000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "4123\n",
        "OUTPUT\n",
        "4321\n",
        "'''\n",
        "# Python program to print the maximum number\n",
        "# from the set of digits of a given number\n",
        "\n",
        "# Function to print maximum number\n",
        "def printMaximum(inum):\n",
        "\n",
        "\t# Hashed array to store count of digits\n",
        "\tcount = [0 for x in range(10)]\n",
        "\n",
        "\t# Converting given number to string\n",
        "\tstring = str(num)\n",
        "\n",
        "\t# Updating the count array\n",
        "\tfor i in range(len(string)):\n",
        "\t\tcount[int(string[i])] = count[int(string[i])] + 1\n",
        "\n",
        "\t# Result stores final number\n",
        "\tresult = 0\n",
        "\tmultiplier = 1\n",
        "\n",
        "\t# traversing the count array\n",
        "\t# to calculate the maximum number\n",
        "\n",
        "\tfor i in range(10):\n",
        "\t\twhile count[i] > 0:\n",
        "\t\t\tresult = result + ( i * multiplier )\n",
        "\t\t\tcount[i] = count[i] - 1\n",
        "\t\t\tmultiplier = multiplier * 10\n",
        "\n",
        "\t# return the result\n",
        "\treturn result\n",
        "\n",
        "# Driver code\n",
        "num = input()\n",
        "print(printMaximum(num))\n"
      ],
      "metadata": {
        "id": "H31F7H5kfbPK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "harish learnt about gcd and and want to apply the concept to find the gcd of n numbers.\n",
        "\n",
        "But in between he got stuck and now he is asking for some help your task is to print the gcd of n numbers and print -1 if there is no gcd possible\n",
        "\n",
        " \n",
        "\n",
        "Input Description:\n",
        "You are given an array size ‘n’.Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Your task is to print the gcd of number\n",
        "\n",
        "Sample Input :\n",
        "6\n",
        "2 4 8 16\n",
        "Sample Output :\n",
        "2\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "def gcd(a, b):\n",
        "    m = min(a, b)\n",
        "    for i in range(1, m+1):\n",
        "        if (a%i==0)and(b%i==0):\n",
        "            ans = i\n",
        "    return ans\n",
        "ans = gcd(l[0], l[1])\n",
        "if len(l)>2:\n",
        "    for i in range(2, len(l)):\n",
        "        ans = gcd(ans, l[i])\n",
        "print(ans)"
      ],
      "metadata": {
        "id": "ZqM-YuS2fbMk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        ":You are given an array of ‘n’ numbers.your task is to print the lcm of ‘n’ numbers\n",
        "\n",
        "Input Description:\n",
        "An integer ‘n’ denoting the size of array.Next line contains ‘n’ space separated numbers\n",
        "\n",
        "Output Description:\n",
        "Print the lcm\n",
        "\n",
        "Sample Input :\n",
        "4\n",
        "2 4 6 8\n",
        "Sample Output :\n",
        "24\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "i = max(l)\n",
        "while True:\n",
        "    flag = True\n",
        "    for j in l:\n",
        "        if i % j != 0:\n",
        "            flag = False\n",
        "    if flag:\n",
        "        print(i)\n",
        "        break\n",
        "    else:\n",
        "        i += 1"
      ],
      "metadata": {
        "id": "TujREXAQfbJm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Gunjan was going through the book of ‘hyp’ numbers. She is given task to find the nth hyp number.Your task is to help gunjan\n",
        "\n",
        "A hyp number is a number whose all digits are prime.\n",
        "\n",
        "Input Description:\n",
        "You are given a number ‘n’.\n",
        "\n",
        "Output Description:\n",
        "Print the ‘nth’ hyp number.\n",
        "\n",
        "Sample Input :\n",
        "3\n",
        "Sample Output :\n",
        "5\n",
        "'''\n",
        "n = int(input())\n",
        "l = [2, 3, 5, 7]\n",
        "i = 2\n",
        "count = 0\n",
        "while True:\n",
        "    temp = i\n",
        "    a = []\n",
        "    while temp > 0:\n",
        "        a.append(temp % 10)\n",
        "        temp //= 10\n",
        "    flag = True\n",
        "    for j in a:\n",
        "        if j not in l:\n",
        "            flag = False\n",
        "            break\n",
        "    if flag:\n",
        "        count+=1\n",
        "    if count == n:\n",
        "        print(i)\n",
        "        break\n",
        "    else:\n",
        "        i += 1"
      ],
      "metadata": {
        "id": "pADWCJQ8fbGn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string S, print 'yes' if the strings 'GUVI' and 'GEEK' is present case-sensitively in the string else print 'no'.\n",
        "Input Size : 1 <= 100\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "Vishal_Sundar prepared this question\n",
        "OUTPUT\n",
        "no\n",
        "'''\n",
        "s = str(input())\n",
        "if 'GUVI' in s and 'GEEK' in s:\n",
        "\tprint(\"yes\")\n",
        "else:\n",
        "\tprint(\"no\")"
      ],
      "metadata": {
        "id": "tAvI_mmAiAhr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a string S consisting of only '(' and ')', print 'yes' if it is balanced otherwise print 'no'.\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "(())\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "open_list = [\"[\",\"{\",\"(\"]\n",
        "close_list = [\"]\",\"}\",\")\"]\n",
        "  \n",
        "# Function to check parentheses\n",
        "def check(myStr):\n",
        "    stack = []\n",
        "    for i in myStr:\n",
        "        if i in open_list:\n",
        "            stack.append(i)\n",
        "        elif i in close_list:\n",
        "            pos = close_list.index(i)\n",
        "            if ((len(stack) > 0) and\n",
        "                (open_list[pos] == stack[len(stack)-1])):\n",
        "                stack.pop()\n",
        "            else:\n",
        "                return \"no\"\n",
        "    if len(stack) == 0:\n",
        "        return \"yes\"\n",
        "    else:\n",
        "        return \"no\"\n",
        "  \n",
        "  \n",
        "# Driver code\n",
        "string = input()\n",
        "print(check(string))"
      ],
      "metadata": {
        "id": "wvw1T66oiAe6"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number 'N' print the sum of each digit to the power of number of digits in given input.\n",
        "Example :\n",
        "Input => 1234\n",
        "=> ( 1 ^ 4 ) + ( 2 ^ 4 ) + ( 3 ^ 4 ) + ( 4 ^ 4 )\n",
        "=> 1 + 16 + 81 + 256\n",
        "Output => 354\n",
        "N <=100000000000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "1234\n",
        "OUTPUT\n",
        "354\n",
        "'''\n",
        "n = str(input())\n",
        "sum = 0\n",
        "for i in range(len(n)):\n",
        "    sum = sum + (int(n[i])**(len(n)))\n",
        "print(sum)"
      ],
      "metadata": {
        "id": "BqVBF8eEiAbu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given 2 strings,check whether it is isomorphic.If it is not isomorphic print '-1'.\n",
        "Input Size : |s| <= 100000(complexity O(nlogn))\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "aab xxy\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "(s2, s1) = map(str, input().split())\n",
        "if len(s1) != len(s2):\n",
        "    print(\"no\")\n",
        "else:\n",
        "    l = []\n",
        "    d = {}\n",
        "    flag = True\n",
        "    for i in range(len(s1)):\n",
        "        if s1[i] not in l:\n",
        "            l.append(s1[i])\n",
        "            d[s1[i]] = s2[i]\n",
        "        else:\n",
        "            if d[s1[i]] != s2[i]:\n",
        "                flag = False\n",
        "                break\n",
        "    if flag:print(\"yes\")\n",
        "    else:print(\"no\")"
      ],
      "metadata": {
        "id": "n9eRW6EjiAXl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N and an array of N elements, find the Bitwise XOR of the array elements.\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "2\n",
        "2 4\n",
        "OUTPUT\n",
        "6\n",
        "'''\n",
        "def xorOfArray(arr, n):\n",
        " \n",
        "    # Resultant variable\n",
        "    xor_arr = 0\n",
        " \n",
        "    # Iterating through every element in\n",
        "    # the array\n",
        "    for i in range(n):\n",
        " \n",
        "        # Find XOR with the result\n",
        "        xor_arr = xor_arr ^ arr[i]\n",
        " \n",
        "    # Return the XOR\n",
        "    return xor_arr\n",
        " \n",
        "# Driver Code\n",
        "if __name__ == '__main__':\n",
        "    n = int(input())\n",
        "    arr = [int(x) for x in input().split()]\n",
        " \n",
        "    # Function call\n",
        "    print(xorOfArray(arr, n))"
      ],
      "metadata": {
        "id": "3OdAlgfpiATm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a range[L,R], print the sum of all the odd numbers within the range(inclusive of L and R).\n",
        "Sample Testcase:\n",
        "INPUT\n",
        "5 10\n",
        "OUTPUT\n",
        "21\n",
        "'''\n",
        "n= list(map(int,input().split()))\n",
        "\n",
        "oddcount=[]\n",
        "evencount=[]\n",
        "\n",
        "for i in range(n[0],n[1]+1):\n",
        "    if i%2==0:\n",
        "        evencount.append(i)\n",
        "        \n",
        "    else:\n",
        "        oddcount.append(i)\n",
        "        \n",
        "        \n",
        "        \n",
        "sum=0\n",
        "for i in range(len(oddcount)):\n",
        "    sum= sum+ oddcount[i]\n",
        "print(sum)"
      ],
      "metadata": {
        "id": "rYcp5uSLiAN1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N and an array of N elements,sort the array in increasing order and print the original indices of the elements present in sorted array.\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "5\n",
        "5 4 3 2 1\n",
        "OUTPUT\n",
        "5 4 3 2 1\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "d = {}\n",
        "for i in range(len(l)):\n",
        "    d[l[i]]=i+1\n",
        "l.sort()\n",
        "a = []\n",
        "for i in l:\n",
        "    a.append(d[i])\n",
        "print(*a)"
      ],
      "metadata": {
        "id": "waeSBBdTjBn4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N and an array of N elements, find the sum of the maximum elements obtained by considering all consecutive pairs of adjacent elements.\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "5\n",
        "1 2 3 4 5\n",
        "OUTPUT\n",
        "14\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "sum = 0\n",
        "for i in range(n-1):\n",
        "    sum += max(l[i], l[i+1])\n",
        "print(sum)"
      ],
      "metadata": {
        "id": "-L80Pe_BjBkr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given an array of N elements.find the number of occurences of each character and print it in the decreasing order of occurences, if 2 or more number occurs the same number of times, print the numbers in decreasing order.\n",
        "Input Size : |N| <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "5\n",
        "3 3 4 4 7\n",
        "OUTPUT\n",
        "4 3 7\n",
        "'''\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "max_count = l.count(l[0])\n",
        "for i in range(n):\n",
        "    if max_count < l.count(l[i]):\n",
        "        max_count = l.count(l[i])\n",
        "a = []\n",
        "for i in range(max_count, 0, -1):\n",
        "    b = []\n",
        "    for j in range(n):\n",
        "        if i == l.count(l[j]) and l[j] not in b:\n",
        "            b.append(l[j])\n",
        "    b.sort(reverse = True)\n",
        "    a.extend(b)\n",
        "print(*a)"
      ],
      "metadata": {
        "id": "HbzQaCIRjBif"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a numbers N, print the sum of prefix sum and suffix sum array for each position.\n",
        "Input Size : N <= 10000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "4\n",
        "2 4 4 2\n",
        "OUTPUT\n",
        "14 16 16 14\n",
        "'''\n",
        "\n",
        "n = int(input())\n",
        "l = [int(x) for x in input().split()]\n",
        "a = []\n",
        "for i in range(n):\n",
        "    a.append(sum(l[:i+1]) + sum(l[i:]))\n",
        "print(*a)"
      ],
      "metadata": {
        "id": "d8TaxoFajBgO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N and an array of N strings, find the lexicographically smallest string.\n",
        "Input Size : N <= 1000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "3\n",
        "code\n",
        "learn\n",
        "practice\n",
        "OUTPUT\n",
        "code\n",
        "'''\n",
        "n = int(input())\n",
        "l = []\n",
        "for i in range(n):\n",
        "    l.append(str(input()))\n",
        "l.sort()\n",
        "print(l[0])"
      ],
      "metadata": {
        "id": "xqWs7b0-jBeR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "A number is given as input. Find the odd digits in the number, add them and find if the sum is odd or not. If even print E, if odd print O.\n",
        "Input Size : N <= 10000000000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "413\n",
        "OUTPUT\n",
        "E\n",
        "'''\n",
        "n =input()\n",
        "odd = []\n",
        "even=[]\n",
        "for i in range(len(n)):\n",
        "    a= int(n[i])\n",
        "    if a%2==0:\n",
        "        even.append(int(n[i]))\n",
        "    else:\n",
        "        odd.append(int(n[i]))\n",
        "        \n",
        "sum = 0\n",
        "for i in range(len(odd)):\n",
        "    sum= sum+odd[i]\n",
        "    \n",
        "if sum%2==0:\n",
        "    print(\"E\")\n",
        "else:\n",
        "    print(\"O\")"
      ],
      "metadata": {
        "id": "NaVBQpSMjBbV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N, print their prime factors in sorted order.\n",
        "Input Size : 2 <= N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "18\n",
        "OUTPUT\n",
        "2 3\n",
        "'''\n",
        "n = int(input())\n",
        "def isprime(a):\n",
        "    flag = True\n",
        "    for i in range(2,(a//2)+1):\n",
        "        if a % i == 0:\n",
        "            flag = False\n",
        "    return flag\n",
        "factor = []\n",
        "for i in range(2,n+1):\n",
        "    if n % i == 0:\n",
        "        factor.append(i)\n",
        "#print(*factor)\n",
        "prime_factor = []\n",
        "for i in factor:\n",
        "    if isprime(i):\n",
        "        prime_factor.append(i)\n",
        "prime_factor.sort()\n",
        "print(*prime_factor)"
      ],
      "metadata": {
        "id": "44306-VbjBYr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N, Print sum of every didgit to the power of the weight of corresponding digit(Explanation : If the input is 12345 and then output calculated as (1^0)+(2^1)+(3^2)+(4^3)+(5^4)).\n",
        "Input Size : 1 <= N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "100\n",
        "OUTPUT\n",
        "1\n",
        "'''\n",
        "n = str(input())\n",
        "sum = 0\n",
        "for i in range(len(n)):\n",
        "    sum += (int(n[i]) ** i)\n",
        "print(sum)"
      ],
      "metadata": {
        "id": "_mu0ILJEjBV1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Rahul was learning about numbers in list. He came across one word ground of a number.\n",
        "\n",
        "A ground of a number is defined as the number which is just smaller or equal to the number given to you.Hence he started solving some assignments related to it. He got struck in some questions. Your task is to help him.\n",
        "\n",
        " \n",
        "\n",
        "O(n) time complexity\n",
        "\n",
        "O(n) Auxilary space\n",
        "\n",
        "Input Description:\n",
        "First line contains two numbers ‘n’ denoting number of integers and ‘k’ whose ground is to be check. Next line contains n space separated numbers.\n",
        "\n",
        "Output Description:\n",
        "Print the index of val.Print -1 if equal or near exqual number\n",
        "\n",
        "Sample Input :\n",
        "7 3\n",
        "1 2 3 4 5 6 7\n",
        "Sample Output :\n",
        "2\n",
        "'''\n",
        "a,k= map(int,input().split())\n",
        "arr= list(map(int,input().split()))\n",
        "lst=[i for i in arr if i<=k]\n",
        "lst.sort(reverse=True)\n",
        "print(arr.index(lst[0]))"
      ],
      "metadata": {
        "id": "PMtmCERSjBUG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a range (i.e) two numbers L and R count the number of perfect squares within the range (inclusive of L and R).If no perfect square exists within the range print '-1'.\n",
        "Input Size : L <= R <= 100000(complexity O(n))\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "2 10\n",
        "OUTPUT\n",
        "2\n",
        "'''\n",
        "def perfectSquare(a):\n",
        "    aroot = a**0.5\n",
        "    aroot = int(aroot)\n",
        "    aroot = aroot ** 2\n",
        "    if aroot == a:\n",
        "        flag = True\n",
        "    else:\n",
        "        flag = False\n",
        "    return flag\n",
        "perfectSquare\n",
        "(l, r) = map(int, input().split())\n",
        "count = 0\n",
        "for i in range(l, r+1):\n",
        "    if perfectSquare(i):\n",
        "        count+=1\n",
        "if count==0:\n",
        "    print(\"-1\")\n",
        "else:\n",
        "    print(count)"
      ],
      "metadata": {
        "id": "j19_JQn0jBRu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N, check if the sum of the digits is a Palindrome. Print 'yes' or 'no' accordingly.\n",
        "Input Size : 2 <= N <= 1000000000000000000\n",
        "Sample Testcases :\n",
        "INPUT\n",
        "13\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "# Python3 implementation of the approach\n",
        "\n",
        "# Function to return the\n",
        "# sum of digits of n\n",
        "def digitSum(n) :\n",
        "\n",
        "\tsum = 0;\n",
        "\twhile (n > 0) :\n",
        "\t\tsum += (n % 10);\n",
        "\t\tn //= 10;\n",
        "\n",
        "\treturn sum;\n",
        "\n",
        "# Function that returns true\n",
        "# if n is palindrome\n",
        "def isPalindrome(n) :\n",
        "\n",
        "\t# Find the appropriate divisor\n",
        "\t# to extract the leading digit\n",
        "\tdivisor = 1\n",
        "\twhile (n // divisor >= 10) :\n",
        "\t\tdivisor *= 10\n",
        "\n",
        "\twhile (n != 0) :\n",
        "\t\tleading = n // divisor\n",
        "\t\ttrailing = n % 10\n",
        "\n",
        "\t\t# If first and last digit\n",
        "\t\t# not same return false\n",
        "\t\tif (leading != trailing) :\n",
        "\t\t\treturn False\n",
        "\n",
        "\t\t# Removing the leading and trailing\n",
        "\t\t# digit from number\n",
        "\t\tn = (n % divisor) // 10\n",
        "\n",
        "\t\t# Reducing divisor by a factor\n",
        "\t\t# of 2 as 2 digits are dropped\n",
        "\t\tdivisor = divisor // 100\n",
        "\n",
        "\treturn True\n",
        "\n",
        "# Function that returns true if\n",
        "# the digit sum of n is palindrome\n",
        "def isDigitSumPalindrome(n) :\n",
        "\n",
        "\t# Sum of the digits of n\n",
        "\tsum = digitSum(n)\n",
        "\n",
        "\t# If the digit sum is palindrome\n",
        "\tif (isPalindrome(sum)) :\n",
        "\t\treturn True\n",
        "\treturn False\n",
        "\n",
        "# Driver code\n",
        "if __name__ == \"__main__\" :\n",
        "\n",
        "\tn = int(input())\n",
        "\n",
        "\tif (isDigitSumPalindrome(n)) :\n",
        "\t\tprint(\"yes\")\n",
        "\telse :\n",
        "\t\tprint(\"no\")\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "On2nXkKIjBPd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N, find the smallest number which is greater than N with the same digits in N. If N is the greatest digit print 'impossible'.\n",
        "Input Size : 1 <= N <= 1000000000000000000\n",
        "Sample Testcases :\n",
        "INPUT\n",
        "123\n",
        "OUTPUT\n",
        "132\n",
        "'''\n",
        "# Python program to find the smallest number which\n",
        "# is greater than a given no. has same set of\n",
        "# digits as given number\n",
        "\n",
        "# Given number as int array, this function finds the\n",
        "# greatest number and returns the number as integer\n",
        "def findNext(number,n):\n",
        "\t\n",
        "\t# Start from the right most digit and find the first\n",
        "\t# digit that is smaller than the digit next to it\n",
        "\tfor i in range(n-1,0,-1):\n",
        "\t\tif number[i] > number[i-1]:\n",
        "\t\t\tbreak\n",
        "\t\t\t\n",
        "\t# If no such digit found,then all numbers are in\n",
        "\t# descending order, no greater number is possible\n",
        "\tif i == 1 and number[i] <= number[i-1]:\n",
        "\t\tprint (\"impossible\")\n",
        "\t\treturn\n",
        "\t\t\n",
        "\t# Find the smallest digit on the right side of\n",
        "\t# (i-1)'th digit that is greater than number[i-1]\n",
        "\tx = number[i-1]\n",
        "\tsmallest = i\n",
        "\tfor j in range(i+1,n):\n",
        "\t\tif number[j] > x and number[j] < number[smallest]:\n",
        "\t\t\tsmallest = j\n",
        "\t\t\n",
        "\t# Swapping the above found smallest digit with (i-1)'th\n",
        "\tnumber[smallest],number[i-1] = number[i-1], number[smallest]\n",
        "\t\n",
        "\t# X is the final number, in integer datatype\n",
        "\tx = 0\n",
        "\t# Converting list upto i-1 into number\n",
        "\tfor j in range(i):\n",
        "\t\tx = x * 10 + number[j]\n",
        "\t\n",
        "\t# Sort the digits after i-1 in ascending order\n",
        "\tnumber = sorted(number[i:])\n",
        "\t# converting the remaining sorted digits into number\n",
        "\tfor j in range(n-i):\n",
        "\t\tx = x * 10 + number[j]\n",
        "\t\n",
        "\tprint (x)\n",
        "\n",
        "\n",
        "# Driver Program to test above function\n",
        "digits = input()\t\t\n",
        "\n",
        "\n",
        "number = list(map(int ,digits))\n",
        "findNext(number, len(digits))\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "a4KVduV9jBM2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given two numbers a and b, write a program to print the count of numbers in the range [a,b] in which there are prime number of 1's in their binary representation.\n",
        "Input Size : 1 <= A <= B <= 100000\n",
        "Sample Testcases :\n",
        "INPUT\n",
        "1 3\n",
        "OUTPUT\n",
        "1\n",
        "'''\n",
        "\n",
        "def isPrime(n):\n",
        "\n",
        "\t# Corner cases\n",
        "\tif (n <= 1): return False;\n",
        "\tif (n <= 3): return True;\n",
        "\n",
        "\t# This is checked so that we can skip\n",
        "\t# middle five numbers in below loop\n",
        "\tif (n % 2 == 0 or n % 3 == 0):\n",
        "\t\treturn False\n",
        "\t\t\n",
        "\ti = 5;\n",
        "\twhile (i * i <= n):\n",
        "\t\tif(n % i == 0 or n % (i + 2) == 0):\n",
        "\t\t\treturn False\n",
        "\t\ti = i + 6\n",
        "\n",
        "\treturn True\n",
        "\n",
        "# count number, that contains\n",
        "# prime number of set bit\n",
        "def primeBitsInRange(l, r):\n",
        "\n",
        "\t# tot_bit store number of\n",
        "\t# bit in number\n",
        "\tcount = 0\n",
        "\n",
        "\t# iterate loop from l to r\n",
        "\tfor i in range(l, r + 1):\n",
        "\n",
        "\t\t# use predefined function for finding\n",
        "\t\t# set bit it is return number of set bit\n",
        "\t\ttot_bit = bin(i).count('1')\n",
        "\n",
        "\t\t# check tot_bit prime or, not\n",
        "\t\tif (isPrime(tot_bit)):\n",
        "\t\t\tcount += 1\n",
        "\n",
        "\treturn count\n",
        "\n",
        "# Driver Code\n",
        "l,r = map(int,input().split())\n",
        "print(primeBitsInRange(l, r))\n",
        "\n"
      ],
      "metadata": {
        "id": "8FVK1LyRjBKY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given two numbers N,K and an array of size N, print the three nearest neighbours of K(nearest neighbours are numbers which have least difference with K).\n",
        "Input Size : 4 <= N, K <= 100000\n",
        "Sample Testcases :\n",
        "INPUT\n",
        "5 3\n",
        "1 2 3 4 6\n",
        "OUTPUT\n",
        "2 4 1\n",
        "'''\n",
        "(n, k) = map(int, input().split())\n",
        "l = [int(x) for x in input().split()]\n",
        "i = 1\n",
        "count = 0\n",
        "a = []\n",
        "while count < 3:\n",
        "    if k-i in l:\n",
        "        a.append(k-i)\n",
        "        count += 1\n",
        "    if k+i in l and count < 3:\n",
        "        a.append(k+i)\n",
        "        count += 1\n",
        "    i += 1\n",
        "print(*a)\n"
      ],
      "metadata": {
        "id": "GvsGV6xQkpOy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Given a number N followed by N numbers.Find the smallest number and largest number and print both the indices(1 based indexing).\n",
        "Input Size : N <= 100000\n",
        "Sample Testcase :\n",
        "INPUT\n",
        "5\n",
        "1 2 3 4 5\n",
        "OUTPUT\n",
        "1 5\n",
        "'''\n",
        "n= int(input())\n",
        "b=list(map(int,input().split(' ')))\n",
        "l= min(b)\n",
        "m= max(b)\n",
        "x=b.index(l)+1\n",
        "y=b.index(m)+1\n",
        "\n",
        "fg=[x,y]\n",
        "print(*fg)"
      ],
      "metadata": {
        "id": "cq6ofEHjkpJv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Check whether the given 4 points form a square or not.\n",
        "Example:\n",
        "INPUT\n",
        "10 10\n",
        "10 20\n",
        "20 20\n",
        "20 10\n",
        "OUTPUT\n",
        "yes\n",
        "'''\n",
        "import math\n",
        "x1,y1=map(int,input().split(' '))#a\n",
        "x2,y2=map(int,input().split(' '))#b\n",
        "x3,y3=map(int,input().split(' '))#c\n",
        "x4,y4=map(int,input().split(' '))#d\n",
        "\n",
        "ab= (abs((x2-x1))^2) +(abs((y2-y1))^2)\n",
        "ab = math.sqrt(ab)\n",
        "bc= (abs((x3-x2))^2) +(abs((y3-y2))^2)\n",
        "bc = math.sqrt(bc)\n",
        "cd= (abs((x4-x3))^2) +(abs((y4-y3))^2)\n",
        "cd = math.sqrt(cd)\n",
        "da= (abs((x4-x1))^2) +(abs((y4-y1))^2)\n",
        "da = math.sqrt(da)\n",
        "\n",
        "\n",
        "d1= (abs((x3-x1))^2) +(abs((y3-y1))^2)#ac\n",
        "d1 = math.sqrt(d1)\n",
        "\n",
        "d2= (abs((x2-x4))^2) +(abs((y2-y4))^2)#bd\n",
        "d2 = math.sqrt(d2)\n",
        "\n",
        "if ab==bc==cd==da and d1==d2:\n",
        "    print(\"yes\")\n",
        "else:\n",
        "    print(\"no\")"
      ],
      "metadata": {
        "id": "dSIJ6xoxkpGT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Jack is fond of numbers. He has given an array.He has to find the maximum length of sub array such that sum of elements in that sub array gives output 0.He is in little trouble, help him in finding solution\n",
        "\n",
        "Input Description:\n",
        "You are given an integer ‘n’ denoting the number of elements in array.Next line contains n space separated integers\n",
        "\n",
        "Output Description:\n",
        "Print the max length of that array with sum 0 and print -1 if not possible\n",
        "\n",
        "Sample Input :\n",
        "6\n",
        "-4 3 1 0 0 6\n",
        "Sample Output :\n",
        "5\n",
        "'''\n",
        "n= int(input())\n",
        "arr=[int(x) for x in input().split()]\n",
        "lst=[]\n",
        "for i in range(n):\n",
        "    for j in range(i,n):\n",
        "        a=[]\n",
        "        for k in range(i,j+1):\n",
        "            a.append(arr[k])\n",
        "        lst.append(a)\n",
        "m=len(lst[0])\n",
        "flag=False\n",
        "for i in lst:\n",
        "    if sum(i)==0 and m<len(i):\n",
        "        m=len(i)\n",
        "        \n",
        "print(m)\n"
      ],
      "metadata": {
        "id": "bUTEiN-8kpBR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Gjh5apGEko-X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9k6wVlMgko7k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2x2CZ5Edko36"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1EIB1foykoyu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "0W0VK1h9kov-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gNlycPWakopn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "nRD2r6Q9kome"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aRtVegM3koOc"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}