LeetCode_Problems.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "LeetCode Problems.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOPmSx45pMWbZkYYkWc7JIC",
      "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/DaudAhmad0303/LeetCode-Problems-Solution-colab/blob/master/LeetCode_Problems.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ckRKhbOJgsXz"
      },
      "source": [
        "# **Random Practise Codes**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eRLFK0GZgrwP",
        "outputId": "abbbb012-583e-496f-e685-b0ae5c72ee40"
      },
      "source": [
        "# for exchanging values \n",
        "a, b = 5, 4\n",
        "print(a, b)\n",
        "a, b = b, a\n",
        "print(a, b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n",
            "5 4\n",
            "4 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "75bkHHqxsKi2",
        "outputId": "b0ed399d-f401-4f0f-f479-9539a8525c8f"
      },
      "source": [
        "str1 = \"Pakistan\"\n",
        "str2 = 'Zindabad'\n",
        "res1 = str1 + str2\n",
        "res2 = str2 + str1\n",
        "print(res1)\n",
        "print(res2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PakistanZindabad\n",
            "ZindabadPakistan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rTU7ZKzPcflK"
      },
      "source": [
        "# **1. Two Sum**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4cOaHQQI-6mR"
      },
      "source": [
        "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\n",
        "\n",
        "You may assume that each input would have exactly one solution, and you may not use the same element twice.\n",
        "\n",
        "You can return the answer in any order.\n",
        "\n",
        " ```\n",
        "Example 1:\n",
        "Input: nums = [2,7,11,15], target = 9\n",
        "Output: [0,1]\n",
        "Output: Because nums[0] + nums[1] == 9,\n",
        "we return [0, 1].\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [3,2,4], target = 6\n",
        "Output: [1,2]\n",
        "```\n",
        "```\n",
        "Example 3:\n",
        "Input: nums = [3,3], target = 6\n",
        "Output: [0,1]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mkPAa0uKWFWz",
        "outputId": "1d65c9b9-e338-4da6-b226-fe00bef41480"
      },
      "source": [
        "class Solution:\n",
        "    def twoSum(self):\n",
        "        answer = []\n",
        "        target = 6\n",
        "        nums = [2,3,4]\n",
        "        # for x in range(len(nums)):\n",
        "        #     if(x < len(nums)-1):\n",
        "        #         if(nums[x] + nums[x+1] == target):\n",
        "        #             answer.append(x)\n",
        "        #             answer.append(x+1)\n",
        "        # print(answer)\n",
        "        # return answer\n",
        "        # t = 0-target\n",
        "        for x in range(len(nums)):\n",
        "            if(x < len(nums)):\n",
        "                print(str(x) + \" w\")    \n",
        "                if(nums[0] == 2):  #(nums[x] + nums[0])\n",
        "                  print(x)\n",
        "                  answer.append(x)\n",
        "        print(answer)\n",
        "        return answer\n",
        "                \n",
        "           \n",
        "p = Solution()\n",
        "print(p.twoSum())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 w\n",
            "0\n",
            "1 w\n",
            "1\n",
            "2 w\n",
            "2\n",
            "[0, 1, 2]\n",
            "[0, 1, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AzRRUGh9jAMs"
      },
      "source": [
        "class Solution:\n",
        "    def twoSum(self, nums: List[int], target: int) -> List[int]:\n",
        "        answer = []\n",
        "        for x in range(len(nums)):\n",
        "            for y in range(len(nums)):\n",
        "                if(x < len(nums)-1):\n",
        "                    if(nums[x] + nums[x+y] == target):\n",
        "                        answer.append(x)\n",
        "                        answer.append(x+y)\n",
        "            return answer\n",
        "        # t = 0-target\n",
        "#         for x in range(len(nums)):\n",
        "#             if(x < len(nums)-1):    \n",
        "#                 if(nums[x] + nums[0] == nums[0]):\n",
        "#                     answer.append(x)\n",
        "#         return answer"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LPf9GF2ynV4C"
      },
      "source": [
        "# **1365. How Many Numbers Are Smaller Than the Current Number**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ddeezG4p-00g"
      },
      "source": [
        "\n",
        "Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i].\n",
        "\n",
        "Return the answer in an array.\n",
        "```\n",
        "Example 1:\n",
        "Input: nums = [8,1,2,2,3]\n",
        "Output: [4,0,1,1,3]\n",
        "Explanation: \n",
        "For nums[0]=8 there exist four smaller numbers than it (1, 2, 2 and 3). \n",
        "For nums[1]=1 does not exist any smaller number than it.\n",
        "For nums[2]=2 there exist one smaller number than it (1). \n",
        "For nums[3]=2 there exist one smaller number than it (1). \n",
        "For nums[4]=3 there exist three smaller numbers than it (1, 2 and 2).\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [6,5,4,8]\n",
        "Output: [2,1,0,3]\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wrxHhfg4pA-J"
      },
      "source": [
        "Comment # First Traverse whole List, while considering each element\n",
        "Then we'll compare whole List for elements less than the considered element"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gOXtY3X0nszw",
        "outputId": "4a1d2c68-8163-402d-b732-ca65b07bfdc4"
      },
      "source": [
        "nums = [8,1,2,2,3]\n",
        "list = []\n",
        "\n",
        "for i in nums:\n",
        "  count = 0\n",
        "  for j in nums):\n",
        "    if i > j:\n",
        "      count += 1\n",
        "  list.append(count)\n",
        "\n",
        "print(ls_1)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[4, 0, 1, 1, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A10wnCHSHbU_",
        "outputId": "bc339255-84fa-425e-aa03-c2f0aba6f95c"
      },
      "source": [
        "x, y = [int(x) for x in input().split()] \n",
        "print(x)\n",
        "print(y)\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "34 62\n",
            "34\n",
            "62\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a-1k90IoHuOG",
        "outputId": "09c87b4f-a09e-4714-90dc-176ad86a74a6"
      },
      "source": [
        "x, y = input(),  input()\n",
        "print(x, y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "45\n",
            "34\n",
            "45 34\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WPVFskrLWex7",
        "outputId": "aace32e2-663c-4cff-a48b-1c76ca17a754"
      },
      "source": [
        "name = \"Daud\"\n",
        "print(name[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "d\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_94rWkpMq5ls"
      },
      "source": [
        "# **1108. Defanging an IP Address**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HfhkQ7iV-seZ"
      },
      "source": [
        "\n",
        "Given a valid (IPv4) IP address, return a defanged version of that IP address.\n",
        "\n",
        "A defanged IP address replaces every period \".\" with \"[.]\".\n",
        "\n",
        " \n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input: address = \"1.1.1.1\"\n",
        "Output: \"1[.]1[.]1[.]1\"\n",
        "```\n",
        "**Example 2:**\n",
        "```\n",
        "Input: address = \"255.100.50.0\"\n",
        "Output: \"255[.]100[.]50[.]0\"\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JcoHje2WrZ6K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "307f5010-1aa9-4298-da7d-238a9113de37"
      },
      "source": [
        "address = '1.1.1.1'\n",
        "newadd = ''\n",
        "for i in address:\n",
        "  if (i == '.'):\n",
        "    newadd += '[.]'\n",
        "  else:\n",
        "    newadd += i\n",
        "\n",
        "print('New Address: ',newadd)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "New Address:  1[.]1[.]1[.]1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F61QC539OLmQ"
      },
      "source": [
        "# **344. Reverse String**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6TK9cUrv-heA"
      },
      "source": [
        "\n",
        "Write a function that reverses a string. The input string is given as an array of characters s.\n",
        "\n",
        " \n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input: s = [\"h\",\"e\",\"l\",\"l\",\"o\"]\n",
        "Output: [\"o\",\"l\",\"l\",\"e\",\"h\"]\n",
        "```\n",
        "**Example 2:**\n",
        "```\n",
        "Input: s = [\"H\",\"a\",\"n\",\"n\",\"a\",\"h\"]\n",
        "Output: [\"h\",\"a\",\"n\",\"n\",\"a\",\"H\"]\n",
        "```\n",
        "**Follow up:** Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TE2YMBHsL9nh",
        "outputId": "75557cd7-6589-4c34-ce98-48532add4802"
      },
      "source": [
        "s = [\"h\",\"e\",\"l\",\"l\",\"o\"]\n",
        "for i in range(len(s)//2):\n",
        "  s[i],s[-i-1] = s[-i-1],s[i]\n",
        "  # s[i] = s[-i-1]\n",
        "  # s[-i-1] = s[i]\n",
        "\n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['o', 'l', 'l', 'e', 'h']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ji8rapJooKCJ",
        "outputId": "92f438c3-7218-4389-a02f-b7bb5ec7aa62"
      },
      "source": [
        "lists =[]  \n",
        "s = '(){[]'\n",
        "val = None\n",
        "dic ={\n",
        "    '}':'{',\n",
        "    ')':'(',\n",
        "    ']':'['\n",
        "}\n",
        "dic_values = dic.values()  # [ '{', '(',  '[' ]\n",
        "for i in s:  \n",
        "    if i in dic_values:\n",
        "        lists.append(i)\n",
        "    else:\n",
        "        if len(lists) > 0 and lists[-1] ==dic[i]:\n",
        "            lists.pop()\n",
        "        else:\n",
        "            val = False\n",
        "val = len(lists) == 0\n",
        "print(val)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QScOvN2bBAjQ",
        "outputId": "e8fda987-ed39-4b10-edf4-207e9e43fa03"
      },
      "source": [
        "nums = [0,1,2,2,3,0,4,2]\n",
        "val = 2\n",
        "x = []\n",
        "count = 0\n",
        "for i in range(len(nums)):\n",
        "    if val == nums[i]:\n",
        "        count = count+1\n",
        "for i in range(len(nums)):\n",
        "    if nums[i] != val:\n",
        "        x.append(nums[i])\n",
        "for j in range(3):\n",
        "    x.append(\"_\")\n",
        "lst = [i for i in x]\n",
        "print(lst)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 3, 0, 4, '_', '_', '_']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K_z8bKM6A4OF"
      },
      "source": [
        "# output is this  [0, 1, 3, 0, 4, '_', '_', '_'] , I need this output   [0,1,3,0, 4,_,_,_]  \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nXqT4fGeiGPb"
      },
      "source": [
        "class Solution:\n",
        "    def restoreString(self, s: str, indices) -> str:\n",
        "        string = s.split('')\n",
        "        temp = ''\n",
        "        for i in range(0,len(s)):\n",
        "            string[indices[i]] += s[i]\n",
        "\n",
        "        return string\n",
        "\n",
        "t1 = Solution()\n",
        "print(t1.restoreString('codeleet',45670213))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B8_xyYjXoua1"
      },
      "source": [
        "def restoreString(self, s: str, indices: List[int]) -> str:\n",
        "\t\tresult = [\"\"] * len(s)\n",
        "\n",
        "\t\tfor i, letter in enumerate(s):\n",
        "\t\t\tresult[indices[i]] = letter\n",
        "\n",
        "\t\treturn \"\".join(result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SDWb5fWnqT5Q",
        "outputId": "3e6e9743-f94b-4f3d-c6ba-68dcd1005b7b"
      },
      "source": [
        "list1 = list(\"sjdhj\")\n",
        "print(list1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['s', 'j', 'd', 'h', 'j']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_TY6FfKnT62"
      },
      "source": [
        "# **1160. Find Words That Can Be Formed by Characters**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfAvxSdp-WCX"
      },
      "source": [
        "\n",
        "You are given an array of strings **words** and a string chars.\n",
        "\n",
        "A string is good if it can be formed by characters from chars (each character can only be used once).\n",
        "\n",
        "Return the sum of lengths of all good strings in words.\n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input: words = [\"cat\",\"bt\",\"hat\",\"tree\"], chars = \"atach\"\n",
        "Output: 6\n",
        "Explanation: The strings that can be formed are \"cat\" and \"hat\" so the answer is 3 + 3 = 6.\n",
        "```\n",
        "**Example 2:**\n",
        "```\n",
        "Input: words = [\"hello\",\"world\",\"leetcode\"], chars = \"welldonehoneyr\"\n",
        "Output: 10\n",
        "Explanation: The strings that can be formed are \"hello\" and \"world\" so the answer is 5 + 5 = 10.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pPJjWAEonS3o",
        "outputId": "635dd4bf-3674-44cc-f3d9-03bb9878e051"
      },
      "source": [
        "# words = [\"cat\",\"bt\",\"hat\",\"tree\"]\n",
        "# chars = \"atach\"\n",
        "# -----------------------------------------\n",
        "words = [\"hello\",\"world\",\"leetcode\"]\n",
        "chars = \"welldonehoneyr\"\n",
        "# -----------------------------------------\n",
        "count = 0\n",
        "countw = 0\n",
        "lt_chars = list(chars)\n",
        "lf_chars = list(chars)\n",
        "chars_c = []\n",
        "for i in words:\n",
        "  for j in i:\n",
        "    if j in lf_chars:\n",
        "      count += 1\n",
        "      lt_chars.remove(j)\n",
        "      chars_c.add(j)\n",
        "    if count == len(i):\n",
        "      countw += count\n",
        "      lf_chars = lt_chars.copy()\n",
        "    else:\n",
        "      for k in chars_c:\n",
        "        \n",
        "\n",
        "      print(lf_chars)\n",
        "  count = 0\n",
        "\n",
        "print(countw)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['w', 'e', 'l', 'l', 'd', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['w', 'e', 'l', 'l', 'd', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rvvW02W0T2hX",
        "outputId": "e5feae7a-ed97-4a93-cbac-6c1a2dbac00f"
      },
      "source": [
        "chars = \"welldonehoneyr\"\n",
        "for ch in chars:\n",
        "  chars = chars.replace(ch, \"\")\n",
        "  print(chars)\n",
        "  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "elldonehoneyr\n",
            "lldonhonyr\n",
            "donhonyr\n",
            "donhonyr\n",
            "onhonyr\n",
            "nhnyr\n",
            "hyr\n",
            "hyr\n",
            "yr\n",
            "yr\n",
            "yr\n",
            "yr\n",
            "r\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7WnIerIkWGHx",
        "outputId": "7108f5b7-92e0-4915-8b73-7ca1a8ba7f77"
      },
      "source": [
        "chars = \"welldonehoneyr\"\n",
        "l_chars = list(chars)\n",
        "print(l_chars)\n",
        "for ch in chars:\n",
        "  l_chars.remove(ch)\n",
        "  print(l_chars)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['w', 'e', 'l', 'l', 'd', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['e', 'l', 'l', 'd', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['l', 'l', 'd', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['l', 'd', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['d', 'o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['o', 'n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['n', 'e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['e', 'h', 'o', 'n', 'e', 'y', 'r']\n",
            "['h', 'o', 'n', 'e', 'y', 'r']\n",
            "['o', 'n', 'e', 'y', 'r']\n",
            "['n', 'e', 'y', 'r']\n",
            "['e', 'y', 'r']\n",
            "['y', 'r']\n",
            "['r']\n",
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9cVJqYUo_ju"
      },
      "source": [
        "# **1929. Concatenation of Array**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZ7pyfcL-He4"
      },
      "source": [
        "\n",
        "Given an integer array nums of length n, you want to create an array ans of length 2n where ans[i] == nums[i] and ans[i + n] == nums[i] for 0 <= i < n (0-indexed).\n",
        "\n",
        "Specifically, ans is the **concatenation** of two nums arrays.\n",
        "\n",
        "Return the array ans.\n",
        "```\n",
        "**Example 1:**\n",
        "Input: nums = [1,2,1]\n",
        "Output: [1,2,1,1,2,1]\n",
        "Explanation: The array ans is formed as follows:\n",
        "- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]\n",
        "- ans = [1,2,1,1,2,1]\n",
        "```\n",
        "\n",
        "**Example 2:**\n",
        "```\n",
        "Input: nums = [1,3,2,1]\n",
        "Output: [1,3,2,1,1,3,2,1]\n",
        "Explanation: The array ans is formed as follows:\n",
        "- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]\n",
        "- ans = [1,3,2,1,1,3,2,1]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Yyh-6C0qYS9",
        "outputId": "a4391bf7-9420-4a67-8611-94a4296e3569"
      },
      "source": [
        "#Solution 1\n",
        "nums = [1,3,2,1]\n",
        "answer = nums\n",
        "for i in range(len(nums)):\n",
        "  answer.append(nums[i])\n",
        "print(answer)\n",
        "        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 2, 1, 1, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OXRuMi-Jstlp",
        "outputId": "37c26a40-e88f-4eb6-896b-3affab147416"
      },
      "source": [
        "# Solution 2\n",
        "nums = [1,3,2,1]\n",
        "print(nums + nums)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 2, 1, 1, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tsf66-tFiwO"
      },
      "source": [
        "# **5882. Grid Game Contest question** \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IWTyek0-FwYM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "06f3acd3-81e1-450b-a9b9-29c55f9fb22b"
      },
      "source": [
        "def index_2d(myList, val):\n",
        "    for i, x in enumerate(myList):\n",
        "        if val in x:\n",
        "            return (i, x.index(val))\n",
        "grid = [[2,5,4],[1,5,1]]\n",
        "# print(grid.index(max(grid)))\n",
        "# print(grid.index(max(max(grid,key=max))))\n",
        "# print(grid.index(grid.index(5)))\n",
        "print(index_2d(grid, max(max(x) for x in grid)))\n",
        "print(index_2d(grid, 1))\n",
        "print(max(grid[0]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 1)\n",
            "(1, 0)\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dD8oQPvS-8S0"
      },
      "source": [
        "# **287. Find the Duplicate Number**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "juPUh1EO-Bnx"
      },
      "source": [
        "Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive.\n",
        "\n",
        "There is only one repeated number in nums, return this repeated number.\n",
        "\n",
        "You must solve the problem without modifying the array nums and uses only constant extra space.\n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input: nums = [1,3,4,2,2]\n",
        "Output: 2\n",
        "```\n",
        "**Example 2:**\n",
        "```\n",
        "Input: nums = [3,1,3,4,2]\n",
        "Output: 3\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xQW-Tyms-7d9",
        "outputId": "1d40eb0e-6ad3-463c-952f-25f548fb2dea"
      },
      "source": [
        "nums = [3813, 15536,22271,14184,17895,3837,24294,23073,8515,21173,18958]\n",
        "for i in range(0, len(nums)):\n",
        "  for j in range(i+1, len(nums)):\n",
        "    if nums[i] == nums[j]:\n",
        "      print(nums[j])\n",
        "print(None)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "417GjGnYK7sK"
      },
      "source": [
        "# **1941. Check if All Characters Have Equal Number of Occurrences**\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ShT3ctz90OI"
      },
      "source": [
        "\n",
        "Given a string s, return true if s is a good string, or false otherwise.\n",
        "\n",
        "A string s is good if all the characters that appear in s have the same number of occurrences (i.e., the same frequency).\n",
        "```\n",
        "Example 1:\n",
        "Input: s = \"abacbc\"\n",
        "Output: true\n",
        "Explanation: The characters that appear in s are 'a', 'b', and 'c'. All characters occur 2 times in s.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "\n",
        "Input: s = \"aaabb\"\n",
        "Output: false\n",
        "Explanation: The characters that appear in s are 'a' and 'b'.\n",
        "'a' occurs 3 times while 'b' occurs 2 times, which is not the same number of times.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Q3-FiKoLQ6S",
        "outputId": "27b6d435-6673-4529-91b3-34cb4c71d32d"
      },
      "source": [
        "s = \"abacbc\"\n",
        "# s = \"aaabb\"\n",
        "dic = {}\n",
        "for i in s:\n",
        "    if i not in dic:\n",
        "        dic[i] = 1\n",
        "    else:\n",
        "        dic[i] += 1\n",
        "lst = list(dic.values())\n",
        "print(dic)\n",
        "val = lst[0]\n",
        "for i in range(len(lst)):\n",
        "    if lst[i] != val:\n",
        "        print(False)\n",
        "        break\n",
        "print(True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'a': 2, 'b': 2, 'c': 2}\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XWyh91I_mw4_"
      },
      "source": [
        "# **1704. Determine if String Halves Are Alike**\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_M9g9lt39qqQ"
      },
      "source": [
        "\n",
        "You are given a string s of even length. Split this string into two halves of equal lengths, and let a be the first half and b be the second half.\n",
        "\n",
        "Two strings are alike if they have the same number of vowels ('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'). Notice that s contains uppercase and lowercase letters.\n",
        "\n",
        "Return true if a and b are alike. Otherwise, return false.\n",
        "\n",
        "```\n",
        "Example 1:\n",
        "Input: s = \"book\"\n",
        "Output: true\n",
        "Explanation: a = \"bo\" and b = \"ok\". a has 1 vowel and b has 1 vowel. Therefore, they are alike.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: s = \"textbook\"\n",
        "Output: false\n",
        "Explanation: a = \"text\" and b = \"book\". a has 1 vowel whereas b has 2. Therefore, they are not alike.\n",
        "Notice that the vowel o is counted twice.\n",
        "```\n",
        "```\n",
        "Example 3:\n",
        "Input: s = \"AbCdEfGh\"\n",
        "Output: true\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5_kCdUQudk7C",
        "outputId": "9c22cbc6-a33a-44fa-a378-0867d10a6299"
      },
      "source": [
        "# Solution 1\n",
        "# s = \"book\"\n",
        "# s = \"textbook\"\n",
        "s = s.lower()\n",
        "l = int(len(s) / 2)\n",
        "a, b = '', ''\n",
        "count = 0\n",
        "vowels = ('a', 'e', 'i', 'o', 'u')\n",
        "print(l)\n",
        "for i in range(0, len(s)):\n",
        "    if i+1 <= l:\n",
        "        a += s[i]\n",
        "    else:\n",
        "        b += s[i]\n",
        "print(a,b)\n",
        "for i in range(0, l):\n",
        "    if a[i] in vowels:\n",
        "        count += 1\n",
        "    if b[i] in vowels:\n",
        "        count -= 1\n",
        "print(count == 0)\n",
        "            "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AbCd\n",
            "4\n",
            "abcd efgh\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OHuUbl2EnmfH",
        "outputId": "771c8702-cc8b-4af1-9c58-2ed8eab74cdf"
      },
      "source": [
        "# Solution 2\n",
        "s = \"book\"\n",
        "# s = \"textbook\"\n",
        "s = s.lower()\n",
        "l = len(s) // 2\n",
        "a, b = 0, 0\n",
        "vowels = ('a', 'e', 'i', 'o', 'u')\n",
        "for i in range(l):\n",
        "    if s[i] in vowels:\n",
        "        a += 1\n",
        "    if s[i+l] in vowels:\n",
        "        b += 1\n",
        "print(a == b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40bsEmXawPMJ"
      },
      "source": [
        "# **1470. Shuffle the Array**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SxA4l5N9fcA"
      },
      "source": [
        "\n",
        "Given the array nums consisting of 2n elements in the form ```[x1,x2,...,xn,y1,y2,...,yn].```\n",
        "\n",
        "Return the array in the form ```[x1,y1,x2,y2,...,xn,yn]```.\n",
        "```\n",
        "Example 1:\n",
        "Input: nums = [2,5,1,3,4,7], n = 3\n",
        "Output: [2,3,5,4,1,7] \n",
        "Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [1,2,3,4,4,3,2,1], n = 4\n",
        "Output: [1,4,2,3,3,2,4,1]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IHxY2N5Cw1qg",
        "outputId": "b6a2f0fc-6119-4b37-b843-081b48a2c956"
      },
      "source": [
        "nums = [1,2,3,4,4,3,2,1]\n",
        "n = 4\n",
        "# nums = [1,3,2,4]\n",
        "# n = 2\n",
        "l = len(nums)\n",
        "print('Result:', [1,4,2,3,3,2,4,1])\n",
        "for i in range(0, l, 2):\n",
        "  nums.insert(i+1, nums[i+n])\n",
        "  print('loop:',i,nums)\n",
        "del(nums[l:])\n",
        "print(nums)\n",
        "# --------------------------------------------------------------------"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Result: [1, 4, 2, 3, 3, 2, 4, 1]\n",
            "loop: 0 [1, 4, 2, 3, 4, 4, 3, 2, 1]\n",
            "loop: 2 [1, 4, 2, 3, 3, 4, 4, 3, 2, 1]\n",
            "loop: 4 [1, 4, 2, 3, 3, 2, 4, 4, 3, 2, 1]\n",
            "loop: 6 [1, 4, 2, 3, 3, 2, 4, 1, 4, 3, 2, 1]\n",
            "[1, 4, 2, 3, 3, 2, 4, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g-U_PLZs5IQr"
      },
      "source": [
        "# **2022. Convert 1D Array Into 2D Array**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6-Dagp949bVg"
      },
      "source": [
        "\n",
        "You are given a **0-indexed** 1-dimensional (1D) integer array ```original```, and two integers, ```m``` and ```n```. You are tasked with creating a 2-dimensional (2D) array with ```m``` rows and ```n``` columns using **all** the elements from ```original```.\n",
        "\n",
        "The elements from indices ```0``` to ```n - 1``` (**inclusive**) of original should form the first row of the constructed 2D array, the elements from indices ```n``` to ```2 * n - 1``` (**inclusive**) should form the second row of the constructed 2D array, and so on.\n",
        "\n",
        "Return an ```m x n``` *2D array constructed according to the above procedure, or an empty 2D array if it is impossible.*\n",
        "```\n",
        "Example 1:\n",
        "Input: original = [1,2,3,4], m = 2, n = 2\n",
        "Output: [[1,2],[3,4]]\n",
        "Explanation:\n",
        "The constructed 2D array should contain 2 rows and 2 columns.\n",
        "The first group of n=2 elements in original, [1,2], becomes the first row in the constructed 2D array.\n",
        "The second group of n=2 elements in original, [3,4], becomes the second row in the constructed 2D array.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: original = [1,2,3], m = 1, n = 3\n",
        "Output: [[1,2,3]]\n",
        "Explanation:\n",
        "The constructed 2D array should contain 1 row and 3 columns.\n",
        "Put all three elements in original into the first row of the constructed 2D array.\n",
        "```\n",
        "```\n",
        "Example 3:\n",
        "Input: original = [1,2], m = 1, n = 1\n",
        "Output: []\n",
        "Explanation:\n",
        "There are 2 elements in original.\n",
        "It is impossible to fit 2 elements in a 1x1 2D array, so return an empty 2D array.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BSbCvPiEbqgm",
        "outputId": "b05011f0-e175-48a8-b477-1fb2922d4e0e"
      },
      "source": [
        "original = [1,2,3,4]\n",
        "# m = 2\n",
        "# n = 2\n",
        "# original = [1,2]\n",
        "m = 2\n",
        "n = 2\n",
        "j = 0\n",
        "result = [[0]*n]*m\n",
        "if m * n != len(original):\n",
        "  print('Cannot do this')\n",
        "for i in range(m):\n",
        "    result[i] = original[j:j+n]\n",
        "    j += n\n",
        "print(result)\n",
        "print(len(result))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 2], [3, 4]]\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JJd5V5UN3KsF"
      },
      "source": [
        "# **2023. Number of Pairs of Strings With Concatenation Equal to Target**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G9WMTxyO9W6L"
      },
      "source": [
        "\n",
        "Given an array of digit strings ```nums``` and a digit string ```target```, return the number of pairs of indices ```(i, j)``` (where ```i != j```) such that the concatenation of ```nums[i] + nums[j]``` equals target.\n",
        "```\n",
        "Example 1:\n",
        "Input: nums = [\"777\",\"7\",\"77\",\"77\"], target = \"7777\"\n",
        "Output: 4\n",
        "Explanation: Valid pairs are:\n",
        "- (0, 1): \"777\" + \"7\"\n",
        "- (1, 0): \"7\" + \"777\"\n",
        "- (2, 3): \"77\" + \"77\"\n",
        "- (3, 2): \"77\" + \"77\"\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [\"123\",\"4\",\"12\",\"34\"], target = \"1234\"\n",
        "Output: 2\n",
        "Explanation: Valid pairs are:\n",
        "- (0, 1): \"123\" + \"4\"\n",
        "- (2, 3): \"12\" + \"34\"\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qPn1p2NsmeHj",
        "outputId": "01b69a0a-275d-4b4f-b92a-4c2dba6b5792"
      },
      "source": [
        "nums = [\"777\",\"7\",\"77\",\"77\"]\n",
        "target = \"7777\"\n",
        "answer = 0\n",
        "for i in range(len(nums)):\n",
        "  for j in range(len(nums)):\n",
        "    if (i != j and nums[i] + nums[j] == target):\n",
        "      answer += 1\n",
        "print(answer)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gONVDSvLQKbY",
        "outputId": "f114d2c1-bced-46c6-ed03-2f453c589e36"
      },
      "source": [
        "# s ='XXOX'\n",
        "# s = 'OOOO'\n",
        "# s = 'XXX'\n",
        "s = 'OXOX'\n",
        "ns = ''\n",
        "st = 0\n",
        "count = 0\n",
        "en = len(s) - 1\n",
        "l = len(s) // 3 + len(s) % 3\n",
        "lst = ['XOO','XOX','XXO','OXO','OXX','OOX']\n",
        "for i in range(l):\n",
        "  if s [i:i+3] in lst:\n",
        "    count += 1\n",
        "    s.replace(s[0:3],'OOO')\n",
        "    print(s[i:i+3],'  ',s)\n",
        "  if s[i:i+3] == 'XXX':\n",
        "    count += 1\n",
        "    print(count)\n",
        "  if s[i:i+3] == '000':\n",
        "    pass\n",
        "    s.replace(s[i:i+3],'OOO')\n",
        "# print(count)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OXO    OXOX\n",
            "XOX    OXOX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R0mQBxYRcjBP"
      },
      "source": [
        "# **2027. Minimum Moves to Convert String**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nxmftBEb80rQ"
      },
      "source": [
        "You are given a string s consisting of n characters which are either 'X' or 'O'.\n",
        "\n",
        "A move is defined as selecting three consecutive characters of s and converting them to 'O'. Note that if a move is applied to the character 'O', it will stay the same.\n",
        "\n",
        "Return the minimum number of moves required so that all the characters of s are converted to 'O'.\n",
        "```\n",
        "Example 1:\n",
        "Input: s = \"XXX\"\n",
        "Output: 1\n",
        "Explanation: XXX -> OOO\n",
        "We select all the 3 characters and convert them in one move.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: s = \"XXOX\"\n",
        "Output: 2\n",
        "Explanation: XXOX -> OOOX -> OOOO\n",
        "We select the first 3 characters in the first move, and convert them to 'O'.\n",
        "Then we select the last 3 characters and convert them so that the final string contains all 'O's.\n",
        "```\n",
        "```\n",
        "Example 3:\n",
        "Input: s = \"OOOO\"\n",
        "Output: 0\n",
        "Explanation: There are no 'X's in s to convert.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7ZSq1_6PY_Iv",
        "outputId": "cf71d7f7-b233-4b29-eaca-f2c1fbee245a"
      },
      "source": [
        "# s = 'OXOX'\n",
        "s ='XXOX'\n",
        "# s = 'OOOO'\n",
        "# s = 'XXX'\n",
        "count = 0\n",
        "l = len(s)\n",
        "i = 0\n",
        "while i < l:\n",
        "  if s[i] == 'X':\n",
        "    count += 1\n",
        "    i += 2\n",
        "  i += 1\n",
        "print(count)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQmx3Gl9qLvM"
      },
      "source": [
        "# **852. Peak Index in a Mountain Array**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojDNGffE8xFA"
      },
      "source": [
        "Let's call an array arr a mountain if the following properties hold:\n",
        "\n",
        "- arr.length >= 3\n",
        "- There exists some i with 0 < i < arr.length - 1 such that:\n",
        "  - arr[0] < arr[1] < ... arr[i-1] < arr[i]\n",
        "  - arr[i] > arr[i+1] > ... > arr[arr.length - 1]\n",
        "\n",
        "Given an integer array arr that is guaranteed to be a mountain, return any i such that arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1].\n",
        "```\n",
        "Example 1:\n",
        "Input: arr = [0,1,0]\n",
        "Output: 1\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: arr = [0,2,1,0]\n",
        "Output: 1\n",
        "```\n",
        "```\n",
        "Example 3:\n",
        "Input: arr = [0,10,5,2]\n",
        "Output: 1\n",
        "```\n",
        "```\n",
        "Example 4:\n",
        "Input: arr = [24,69,100,99,79,78,67,36,26,19]\n",
        "Output: 2\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HS7HsyWwq3bp",
        "outputId": "3d1317ed-b786-4ebb-9793-2645e1bc4472"
      },
      "source": [
        "# First Approch\n",
        "# arr = [0,2,1,0]\n",
        "arr = [24,69,100,99,79,78,67,36,26,19]\n",
        "i=0\n",
        "while(arr[i]<arr[i+1]):\n",
        "    i+=1\n",
        "print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VdUzetFV6nU5",
        "outputId": "1e1958af-82ac-4ec4-839b-e0d7e13e5c0e"
      },
      "source": [
        "# Second Approch\n",
        "print(arr.index(max(arr)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pw-MCG12-ErL"
      },
      "source": [
        "# **520. Detect Capital**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e8yKnnZj8qf4"
      },
      "source": [
        "We define the usage of capitals in a word to be right when one of the following cases holds:\n",
        "\n",
        "All letters in this word are capitals, like \"USA\".\n",
        "All letters in this word are not capitals, like \"leetcode\".\n",
        "Only the first letter in this word is capital, like \"Google\".\n",
        "\n",
        "Given a string word, return true if the usage of capitals in it is right.\n",
        "```\n",
        "Example 1:\n",
        "Input: word = \"USA\"\n",
        "Output: true\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: word = \"FlaG\"\n",
        "Output: false\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sdgO14eB-HQX",
        "outputId": "1ffd66f5-ca2c-4cc5-bc07-ff2fb52756a0"
      },
      "source": [
        "word = \"USA\"\n",
        "word = \"FlaG\"\n",
        "print(word==word.upper() or word==word.lower() or word==word.capitalize())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HetKzsVfJHw3"
      },
      "source": [
        "# **1390. Four Divisors**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IME9u8YB8mXA"
      },
      "source": [
        "Given an integer array nums, return the sum of divisors of the integers in that array that have exactly four divisors. If there is no such integer in the array, return 0.\n",
        "\n",
        " ```\n",
        "Example 1:\n",
        "Input: nums = [21,4,7]\n",
        "Output: 32\n",
        "Explanation: \n",
        "21 has 4 divisors: 1, 3, 7, 21\n",
        "4 has 3 divisors: 1, 2, 4\n",
        "7 has 2 divisors: 1, 7\n",
        "The answer is the sum of divisors of 21 only.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [21,21]\n",
        "Output: 64\n",
        "```\n",
        "```\n",
        "Example 3:\n",
        "Input: nums = [1,2,3,4,5]\n",
        "Output: 0\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ilOoVsG5JX40",
        "outputId": "39938d69-ddde-4410-917d-e0070642cd35"
      },
      "source": [
        "def divisors(nums):\n",
        "  count = 0\n",
        "  i = 1\n",
        "  while i <= nums:\n",
        "    if nums % i == 0:\n",
        "      count += i\n",
        "    i += 1\n",
        "  return count\n",
        "\n",
        "# nums = [21,21]\n",
        "nums = [21,4,7]\n",
        "count = 0\n",
        "for i in nums:\n",
        "  count = divisors(i)\n",
        "  # print(count)\n",
        "  if count == 4:\n",
        "    break\n",
        "print(count)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "32\n",
            "7\n",
            "8\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h7uECJLwbaSl",
        "outputId": "386e4e1d-eb1c-45de-b924-e75fb638edb6"
      },
      "source": [
        "def divisors(n):\n",
        "  count = 0\n",
        "  total = 0\n",
        "  i = 1\n",
        "  while i <= n:\n",
        "      if n % i == 0:\n",
        "          total += i\n",
        "          count += 1\n",
        "      i += 1\n",
        "  if count == 4:\n",
        "      return total\n",
        "  else:\n",
        "      return 0\n",
        "\n",
        "nums = [41803,23291,54272,48865,88774]\n",
        "\n",
        "d_sum = 0\n",
        "for i in nums:\n",
        "    d_sum += divisors(i)\n",
        "print(d_sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "44280\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1-3vRnxiik_x",
        "outputId": "56ae0d6a-d358-4e70-de4d-db847fa67c63"
      },
      "source": [
        "from math import *\n",
        "nums = [41803,23291,54272,48865,88774,73382]\n",
        "d_sum = 0\n",
        "for i in nums:\n",
        "    values = set()\n",
        "    j = 1\n",
        "    while j <= floor(sqrt(i) + 1):\n",
        "        if i % j == 0:\n",
        "            values.add(j)\n",
        "            values.add(i//j)\n",
        "        if len(values) > 4:\n",
        "            break\n",
        "        j += 1\n",
        "    if len(values) == 4:\n",
        "        d_sum += sum(values)       \n",
        "print(d_sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "154356\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f5oVl1m3bw-6"
      },
      "source": [
        "# **26. Remove Duplicates from Sorted Array**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L5VTSW7L8h1p"
      },
      "source": [
        "\n",
        "Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.\n",
        "\n",
        "Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.\n",
        "\n",
        "Return k after placing the final result in the first k slots of nums.\n",
        "\n",
        "Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.\n",
        "\n",
        "```\n",
        "Example 1:\n",
        "Input: nums = [1,1,2]\n",
        "Output: 2, nums = [1,2,_]\n",
        "Explanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.\n",
        "It does not matter what you leave beyond the returned k (hence they are underscores).\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [0,0,1,1,1,2,2,3,3,4]\n",
        "Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]\n",
        "Explanation: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.\n",
        "It does not matter what you leave beyond the returned k (hence they are underscores).\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d5jq60o3bYws",
        "outputId": "7847d56a-7468-4979-ed47-a7b27f949f30"
      },
      "source": [
        "nums = [0,0,1,1,1,2,2,3,3,4]\n",
        "nums[:] = sorted(set(nums))\n",
        "nums.remove\n",
        "print(nums)\n",
        "print(len(nums))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4]\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Rrzc9Jniz5s"
      },
      "source": [
        "# **58. Length of Last Word**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e_vLTelq8ck6"
      },
      "source": [
        "Given a string s consisting of some words separated by some number of spaces, return the length of the last word in the string.\n",
        "\n",
        "A word is a maximal substring consisting of non-space characters only.\n",
        "```\n",
        "Example 1:\n",
        "Input: s = \"Hello World\"\n",
        "Output: 5\n",
        "Explanation: The last word is \"World\" with length 5.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FfzKRXDuiKhw",
        "outputId": "26c115e1-b8e7-4a90-db67-cb49ca179c29"
      },
      "source": [
        "s = \"Hello World\"\n",
        "lst = s.split()\n",
        "print(len(lst[-1]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_fcAnT0FlQ6Y",
        "outputId": "081dba20-6640-484c-fa78-f8a0ee086f85"
      },
      "source": [
        "s = \"Hello   World   \"\n",
        "print(s.strip().split()[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "World\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnOpMHQ8qXUX"
      },
      "source": [
        "# **1408. String Matching in an Array**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w8NV2fd48XOQ"
      },
      "source": [
        "Given an array of string words. Return all strings in words which is substring of another word in any order. \n",
        "\n",
        "String words[i] is substring of words[j], if can be obtained removing some characters to left and/or right side of words[j].\n",
        "```\n",
        "Example 1:\n",
        "Input: words = [\"mass\",\"as\",\"hero\",\"superhero\"]\n",
        "Output: [\"as\",\"hero\"]\n",
        "Explanation: \"as\" is substring of \"mass\" and \"hero\" is substring of \"superhero\".\n",
        "[\"hero\",\"as\"] is also a valid answer.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mGlPc3l2qkrv",
        "outputId": "081d4a07-e9d4-41d4-c928-3d6971ac888e"
      },
      "source": [
        "words = [\"mass\",\"as\",\"hero\",\"superhero\"]\n",
        "ans = []\n",
        "for i in range(0,len(words)):\n",
        "  for j in range(0,len(words)):\n",
        "    if (words[j] in words[i] and words[i]!=words[j]):\n",
        "      ans.append(words[j])\n",
        "print(list(set(ans)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['as', 'hero']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kiLKrzQ1slkm"
      },
      "source": [
        "# **1662. Check If Two String Arrays are Equivalent**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jZ3f578Z8SOa"
      },
      "source": [
        "Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.\n",
        "\n",
        "A string is represented by an array if the array elements concatenated in order forms the string.\n",
        "```\n",
        "Example 1:\n",
        "Input: word1 = [\"ab\", \"c\"], word2 = [\"a\", \"bc\"]\n",
        "Output: true\n",
        "Explanation:\n",
        "word1 represents string \"ab\" + \"c\" -> \"abc\"\n",
        "word2 represents string \"a\" + \"bc\" -> \"abc\"\n",
        "The strings are the same, so return true.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: word1 = [\"a\", \"cb\"], word2 = [\"ab\", \"c\"]\n",
        "Output: false\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XrXCG67vsytA",
        "outputId": "278295d5-43eb-491a-80b8-709ed87aad13"
      },
      "source": [
        "word1 = [\"a\", \"cb\"]\n",
        "word2 = [\"ab\", \"c\"]\n",
        "# word1 = [\"ab\", \"c\"]\n",
        "# word2 = [\"a\", \"bc\"]\n",
        "print(''.join(word1) == ''.join(word2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fztSIYozmDg"
      },
      "source": [
        "# **1816. Truncate Sentence**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ng6Fi8j58LnA"
      },
      "source": [
        "A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of only uppercase and lowercase English letters (no punctuation).\n",
        "\n",
        "For example, \"Hello World\", \"HELLO\", and \"hello world hello world\" are all sentences.\n",
        "You are given a sentence s​​​​​​ and an integer k​​​​​​. You want to truncate s​​​​​​ such that it contains only the first k​​​​​​ words. Return s​​​​​​ after truncating it.\n",
        "\n",
        "```\n",
        "Example 1:\n",
        "\n",
        "Input: s = \"Hello how are you Contestant\", k = 4\n",
        "Output: \"Hello how are you\"\n",
        "Explanation:\n",
        "The words in s are [\"Hello\", \"how\" \"are\", \"you\", \"Contestant\"].\n",
        "The first 4 words are [\"Hello\", \"how\", \"are\", \"you\"].\n",
        "Hence, you should return \"Hello how are you\".\n",
        "\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3UBqVClKz1kA",
        "outputId": "7a516f56-41a3-4d23-b6f5-6bb6b1a1e1b5"
      },
      "source": [
        "s = \"Hello how are you Contestant\"\n",
        "k = 4\n",
        "s = s.split()\n",
        "arr = []\n",
        "for i in range(0, k):\n",
        "  arr.append(s[i])\n",
        "print(\" \".join(arr))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello how are you\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qHPe__qquXQp"
      },
      "source": [
        "# **1991. Find the Middle Index in Array**\n",
        "## **724. Find Pivot Index** (also has the same solution)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oZa-3Nqq8Glg"
      },
      "source": [
        "\n",
        "Given a 0-indexed integer array nums, find the leftmost middleIndex (i.e., the smallest amongst all the possible ones).\n",
        "\n",
        "A middleIndex is an index where nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1].\n",
        "\n",
        "If middleIndex == 0, the left side sum is considered to be 0. Similarly, if middleIndex == nums.length - 1, the right side sum is considered to be 0.\n",
        "\n",
        "Return the leftmost middleIndex that satisfies the condition, or -1 if there is no such index.\n",
        "```\n",
        "Example 1:\n",
        "Input: nums = [2,3,-1,8,4]\n",
        "Output: 3\n",
        "Explanation:\n",
        "The sum of the numbers before index 3 is: 2 + 3 + -1 = 4\n",
        "The sum of the numbers after index 3 is: 4 = 4\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: nums = [1,-1,4]\n",
        "Output: 2\n",
        "Explanation:\n",
        "The sum of the numbers before index 2 is: 1 + -1 = 0\n",
        "The sum of the numbers after index 2 is: 0\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cp0dA3wW8yTK",
        "outputId": "75974036-6ee3-40da-eb9f-bf8f518f3db5"
      },
      "source": [
        "nums = [2,3,-1,8,4]\n",
        "sum1 = sum(nums)\n",
        "sum2 = 0\n",
        "for i in range(len(nums)):\n",
        "  sum1 -= nums[i]\n",
        "  if sum1 == sum2: print(i)\n",
        "  sum2 += nums[i]\n",
        "print(-1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "-1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jyhyp7yF2Zya"
      },
      "source": [
        "# **2037. Minimum Number of Moves to Seat Everyone**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5lTVgc_Y74IC"
      },
      "source": [
        "\n",
        "There are n seats and n students in a room. You are given an array seats of length n, where seats[i] is the position of the ith seat. You are also given the array students of length n, where students[j] is the position of the jth student.\n",
        "\n",
        "You may perform the following move any number of times:\n",
        "\n",
        "Increase or decrease the position of the ith student by 1 (i.e., moving the ith student from position x to x + 1 or x - 1)\n",
        "Return the minimum number of moves required to move each student to a seat such that no two students are in the same seat.\n",
        "\n",
        "Note that there may be multiple seats or students in the same position at the beginning.\n",
        "```\n",
        "Example 1:\n",
        "Input: seats = [3,1,5], students = [2,7,4]\n",
        "Output: 4\n",
        "Explanation: The students are moved as follows:\n",
        "- The first student is moved from from position 2 to position 1 using 1 move.\n",
        "- The second student is moved from from position 7 to position 5 using 2 moves.\n",
        "- The third student is moved from from position 4 to position 3 using 1 move.\n",
        "In total, 1 + 2 + 1 = 4 moves were used.\n",
        "```\n",
        "```\n",
        "Example 2:\n",
        "Input: seats = [4,1,5,9], students = [1,3,2,6]\n",
        "Output: 7\n",
        "Explanation: The students are moved as follows:\n",
        "- The first student is not moved.\n",
        "- The second student is moved from from position 3 to position 4 using 1 move.\n",
        "- The third student is moved from from position 2 to position 5 using 3 moves.\n",
        "- The fourth student is moved from from position 6 to position 9 using 3 moves.\n",
        "In total, 0 + 1 + 3 + 3 = 7 moves were used.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bn5ar5XK2iuh",
        "outputId": "0fcd3a56-7ec6-451d-fd69-325f2e18a5df"
      },
      "source": [
        "seats, students = [4,1,5,9], [1,3,2,6]\n",
        "students = sorted(students)\n",
        "moves = 0\n",
        "for i in range(len(students)):\n",
        "  val = min(seats)\n",
        "  moves += abs(students[i] - val)\n",
        "  seats.remove(val)\n",
        "print(moves)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kGWpylqn5D3C",
        "outputId": "63516ca1-ccc4-4f92-c1fc-0ff7323b987d"
      },
      "source": [
        "seats , students = [3,1,5], [2,7,4]\n",
        "students = sorted(students)\n",
        "seats = sorted(seats)\n",
        "moves = 0\n",
        "for i in range(len(students)):\n",
        "  moves += abs(students[i] - seats[i])\n",
        "print(moves)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MCYtKQqJEiGd"
      },
      "source": [
        "# **Weekly contest 263** | **2042. Check if Numbers Are Ascending in a Sentence**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FyrhfjQoJbVl"
      },
      "source": [
        "A sentence is a list of **tokens** separated by a **single** space with no leading or trailing spaces. Every token is either a **positive number** consisting of digits 0-9 with no leading zeros, or a **word** consisting of lowercase English letters.\n",
        "\n",
        "* For example, `\"a puppy has 2 eyes 4 legs\"` is a sentence with seven tokens: `\"2\"` and `\"4\"` are numbers and the other tokens such as `\"puppy\"` are words.\n",
        "Given a string `s` representing a sentence, you need to check if **all** the numbers in s are **strictly increasing** from left to right (i.e., other than the last number, each number is **strictly smaller** than the number on its right in s).\n",
        "\n",
        "Return `true` if so, or `false` otherwise.\n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input: s = \"1 box has 3 blue 4 red 6 green and 12 yellow marbles\"\n",
        "Output: true\n",
        "Explanation: The numbers in s are: 1, 3, 4, 6, 12.\n",
        "They are strictly increasing from left to right: 1 < 3 < 4 < 6 < 12.\n",
        "```\n",
        "**Example 2:**\n",
        "```\n",
        "Input: s = \"sunset is at 7 51 pm overnight lows will be in the low 50 and 60 s\"\n",
        "Output: false\n",
        "Explanation: The numbers in s are: 7, 51, 50, 60. They are not strictly increasing.\n",
        "```\n",
        "**Example 3:**\n",
        "```\n",
        "Input: s = \"36 claim 37 38 39 39 41 hire final 42 43 twist shift young 44 miss 45 46 sad 47 48 dig 49 50 green 51 train 52 broad 53\"\n",
        "Output: true\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mC1XyTn0EtDF",
        "outputId": "6128f024-da15-431f-e6a5-038a08938e36"
      },
      "source": [
        "s = \"sunset is at 7 51 pm overnight lows will be in the low 50 and 60 s\"\n",
        "lst = s.split()\n",
        "int_lst = [ int(x) for x in lst if x.isdigit()]\n",
        "last_val = int_lst.pop()\n",
        "print(last_val)\n",
        "print(int_lst)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "60\n",
            "[7, 51, 50]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yhhgCs6sJeEc"
      },
      "source": [
        "# **2043. Simple Bank System**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iD4pHt8Wj8hG"
      },
      "source": [
        "You have been tasked with writing a program for a popular bank that will automate all its incoming transactions (transfer, deposit, and withdraw). The bank has n accounts numbered from 1 to n. The initial balance of each account is stored in a **0-indexed** integer array `balance`, with the `(i + 1)th` account having an initial balance of `balance[i]`.\n",
        "\n",
        "Execute all the valid transactions. A transaction is valid if:\n",
        "\n",
        "* The given account number(s) are between 1 and n, and\n",
        "* The amount of money withdrawn or transferred from is less than or equal to the balance of the account.\n",
        "Implement the Bank class:\n",
        "\n",
        "* `Bank(long[] balance)` Initializes the object with the **0-indexed** integer array `balance`.\n",
        "* `boolean transfer(int account1, int account2, long money)` Transfers `money` dollars from the account numbered `account1` to the account numbered `account2`. Return `true` if the transaction was successful, `false` otherwise.\n",
        "* `boolean deposit(int account, long money)` Deposit `money` dollars into the account numbered `account`. Return `true` if the transaction was successful, `false` otherwise.\n",
        "* `boolean withdraw(int account, long money)` Withdraw `money` dollars from the account numbered `account`. Return `true` if the transaction was successful, `false` otherwise.\n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input\n",
        "[\"Bank\", \"withdraw\", \"transfer\", \"deposit\", \"transfer\", \"withdraw\"]\n",
        "[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]\n",
        "Output\n",
        "[null, true, true, true, false, false]\n",
        "\n",
        "Explanation\n",
        "Bank bank = new Bank([10, 100, 20, 50, 30]);\n",
        "bank.withdraw(3, 10);    // return true, account 3 has a balance of $20, so it is valid to withdraw $10.\n",
        "                         // Account 3 has $20 - $10 = $10.\n",
        "bank.transfer(5, 1, 20); // return true, account 5 has a balance of $30, so it is valid to transfer $20.\n",
        "                         // Account 5 has $30 - $20 = $10, and account 1 has $10 + $20 = $30.\n",
        "bank.deposit(5, 20);     // return true, it is valid to deposit $20 to account 5.\n",
        "                         // Account 5 has $10 + $20 = $30.\n",
        "bank.transfer(3, 4, 15); // return false, the current balance of account 3 is $10,\n",
        "                         // so it is invalid to transfer $15 from it.\n",
        "bank.withdraw(10, 50);   // return false, it is invalid because account 10 does not exist.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g0Efw6rBJhm7",
        "outputId": "f27e6135-08d2-48d7-8d76-532009ee0863"
      },
      "source": [
        "class Bank:\n",
        "\n",
        "    def __init__(self, balance ):\n",
        "        self.balance = balance\n",
        "        self.t_accounts = len(balance)\n",
        "        return None\n",
        "\n",
        "    def transfer(self, account1, account2, money) -> bool:\n",
        "        if self.t_accounts < account1 or self.t_accounts < account2 or self.balance[account1-1] < money:\n",
        "            return False\n",
        "        self.balance[account1-1] -= money\n",
        "        self.balance[account2-1] += money\n",
        "        return True\n",
        "\n",
        "    def deposit(self, account, money) -> bool:\n",
        "        if self.t_accounts < account:\n",
        "            return False\n",
        "        self.balance[account-1] += money\n",
        "        return True\n",
        "        \n",
        "    def withdraw(self, account, money) -> bool:\n",
        "        if self.t_accounts < account or self.balance[account-1] < money:\n",
        "            return False\n",
        "        self.balance[account-1] -= money\n",
        "        return True\n",
        "\n",
        "\n",
        "obj = Bank([10, 100, 20, 50, 30])\n",
        "param_1 = obj.transfer(5, 1, 20)\n",
        "param_2 = obj.deposit(5, 20)\n",
        "param_3 = obj.withdraw(10, 50)\n",
        "print(obj ,param_1, param_2, param_3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Bank object at 0x7f767779f3d0> True True False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T3yX20jsS1JK"
      },
      "source": [
        "# **5926. Time Needed to Buy Tickets**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bsdR0qHWTDGR",
        "outputId": "4789ab7d-bb30-413c-c7dc-3b4ce77721ab"
      },
      "source": [
        "tickets = [5,1,1,1]     # 1,2,3,4\n",
        "lst = [0] * len(tickets)\n",
        "print(lst)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 0, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G4co7KpsWmiZ"
      },
      "source": [
        "tickets = [5,1,1,1]\n",
        "k = 0\n",
        "t_time = 0\n",
        "i = 0\n",
        "tot_time = [0] * len(tickets)\n",
        "while True:\n",
        "  if sum(tickets) == 0:\n",
        "    break\n",
        "  if tickets[i] > 0:\n",
        "    tickets[i] -= 1\n",
        "    tot_time[i] += 1\n",
        "    tot_time[i] = sum(tickets[0:i])\n",
        "  i += 1\n",
        "  if i == len(tickets) - 1:\n",
        "    i = 0\n",
        "print(tot_time[k])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HqlaH5R_ivyP",
        "outputId": "6e3bcb38-5655-444c-af75-35bc94116f1d"
      },
      "source": [
        "tickets = [5,1,1,1]\n",
        "# tickets = [2,3,2]\n",
        "k = 0\n",
        "num = 0\n",
        "t_time = 0\n",
        "i = 0\n",
        "tot_time = [0] * len(tickets)\n",
        "while True:\n",
        "  if sum(tickets) == 0:\n",
        "    break\n",
        "  if tickets[i] > 0:\n",
        "    tickets[i] -= 1\n",
        "    num += 1\n",
        "    tot_time[i] = num\n",
        "  i += 1\n",
        "  if i == len(tickets):\n",
        "    i = 0\n",
        "print(tot_time[k])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i9YGDmysZ69T"
      },
      "source": [
        "# **5930. Two Furthest Houses With Different Colors**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JZGyB7bSZ6gm",
        "outputId": "6602a9d4-dd82-41f8-bc2b-3b172cf47133"
      },
      "source": [
        "colors = [1,1,1,6,1,1,1]\n",
        "dis = 0\n",
        "for i in range(0, len(colors)-1):\n",
        "  if colors[i] != colors[i+1]:\n",
        "    dis = abs(0 - (i + 1))\n",
        "print(dis)\n",
        "        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lgwvVoyHcxRr",
        "outputId": "a426b8b5-12b2-4284-d691-92d4f0bd3137"
      },
      "source": [
        "colors = [1,1,1,6,1,1,1]\n",
        "temp_list = []\n",
        "max_dis = 0\n",
        "dis = 0\n",
        "for i in range(1, len(colors)):\n",
        "  if colors[i-1] not in temp_list:\n",
        "    temp_list.append(colors[i-1])\n",
        "  else:\n",
        "    continue\n",
        "  if colors[i-1] != colors[i]:\n",
        "    dis = abs(0 - (i))\n",
        "  if dis > max_dis:\n",
        "    max_dis = dis\n",
        "print(max_dis)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6meokEi0LIH"
      },
      "source": [
        "# **Biweekly Contest 66**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KVEP_drp0Xsz"
      },
      "source": [
        "## **5922. Count Common Words With One Occurrence**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RCqhl2lc0gS6",
        "outputId": "bb93510d-05e5-4d12-b4ee-f2fc2ccfb57f"
      },
      "source": [
        "lst = []\n",
        "list_to_remove = []\n",
        "lst1 = []\n",
        "list_to_remove1 = []\n",
        "words1 = [\"b\",\"bb\",\"bbb\"]\n",
        "words2 = [\"a\",\"aa\",\"aaa\"]\n",
        "# words1 = [\"a\",\"ab\"]\n",
        "# words2 = [\"a\",\"a\",\"a\",\"a\",\"a\",\"ab\"]\n",
        "count = 0\n",
        "for i in (words1):\n",
        "    if i not in lst and (i not in list_to_remove):\n",
        "      lst.append(i)\n",
        "    elif i in lst:\n",
        "      lst.remove(i)\n",
        "      list_to_remove.append(i)\n",
        "for i in (words2):\n",
        "    if i not in lst1 and (i not in list_to_remove1):\n",
        "      lst1.append(i)\n",
        "    elif i in lst1:\n",
        "      lst1.remove(i)\n",
        "      list_to_remove1.append(i)\n",
        "l = max(len(lst), len(lst1))\n",
        "if l != len(lst):\n",
        "  lst, lst1 = lst1, lst\n",
        "for i in range(l):\n",
        "  if lst[i] in lst1:\n",
        "    count += 1\n",
        "print(count)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujmMPPMnAEeD"
      },
      "source": [
        "## **5923. Minimum Number of Buckets Required to Collect Rainwater from Houses**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "drOooxdLABI8",
        "outputId": "2fdc4163-7e7a-4b83-d888-e19471eec2e0"
      },
      "source": [
        "import pyparsing as pp\n",
        "\n",
        "word = pp.Word(pp.alphanums)\n",
        "\n",
        "s = 'gfgfdAAA1234ZZZuijjk'\n",
        "rule = pp.nestedExpr('AAA', 'ZZZ')\n",
        "for match in rule.searchString(s):\n",
        "    print(match)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['1234']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EHk4mCASHOpC",
        "outputId": "897eb181-198c-40e7-8b33-510492eab654"
      },
      "source": [
        "import pyparsing as pp\n",
        "class Solution:\n",
        "    def minimumBuckets(self, street: str) -> int:\n",
        "        if \".\" not in street or street == \"H\":\n",
        "            return -1\n",
        "        elif \"H\" not in street:\n",
        "            return 0\n",
        "        elif \"HHH\" in street:\n",
        "            return -1\n",
        "        count = 0\n",
        "        for i in street:\n",
        "            if i == \"H\":\n",
        "                count += 1\n",
        "        word = pp.Word(pp.alphanums)\n",
        "        rule1 = pp.nestedExpr('H.H')\n",
        "        for match in rule.searchString(street):\n",
        "            count -= 1\n",
        "        return count\n",
        "obj1 = Solution()\n",
        "print(obj1.minimumBuckets(\".HHH.\"))\n",
        "print(obj1.minimumBuckets(\".H.H.\"))\n",
        "print(obj1.minimumBuckets(\"H..H\"))\n",
        "print(obj1.minimumBuckets(\".HHH.\"))\n",
        "print(obj1.minimumBuckets(\".HHH.H\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-1\n",
            "2\n",
            "2\n",
            "-1\n",
            "-1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P487iIkTOSuD",
        "outputId": "34fc78e5-f850-4edd-a100-91b9f785347b"
      },
      "source": [
        "from collections import Counter\n",
        " \n",
        "myList = [1,1,2,3,4,5,3,2,3,4,2,1,2,3]\n",
        "val = Counter(myList)\n",
        "print(val)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Counter({2: 4, 3: 4, 1: 3, 4: 2, 5: 1})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Biweekly Contest 67**"
      ],
      "metadata": {
        "id": "1E-4dEhU8Gnj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **5934. Find Subsequence of Length K With the Largest Sum**"
      ],
      "metadata": {
        "id": "cecb7SbV79kd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nums = [3,4,3,3]\n",
        "print(sorted(nums))\n",
        "print(nums[-4:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wz_xJjD97tKj",
        "outputId": "d84b3299-3700-4e03-bb9f-22ed30e6b525"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 3, 3, 4]\n",
            "[3, 4, 3, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nums = [3,4,3,3]\n",
        "num = nums.copy()\n",
        "k = 2\n",
        "l = len(nums) - k\n",
        "for i in range(0, l):\n",
        "  num.remove(min(num))\n",
        "print(num)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NaGgm2Px9L7T",
        "outputId": "35f45007-45c0-432b-b9c9-47a73d69d368"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **5935. Find Good Days to Rob the Bank**"
      ],
      "metadata": {
        "id": "5ugBLWr6-i7C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Not so clear totally this question\n",
        "\n",
        "security = [5,3,3,3,5,6,2]\n",
        "time = 2\n",
        "security = [1,1,1,1,1]\n",
        "time = 0\n",
        "A = security\n",
        "N = len(A)\n",
        "incr = [1] * N\n",
        "decr = [1] * N\n",
        "\n",
        "for i in range(1, N):\n",
        "    if A[i] <= A[i-1]:\n",
        "        decr[i] = decr[i - 1] + 1\n",
        "for i in range(N-2, -1, -1):\n",
        "    if A[i] <= A[i+1]:\n",
        "        incr[i] = incr[i+1] + 1\n",
        "\n",
        "ans = []\n",
        "for i in range(N):\n",
        "    if i-time >= 0 and i+time < N:\n",
        "        if incr[i] >= time+1 <= decr[i]:\n",
        "            ans.append(i)\n",
        "print(ans)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "adn1Tub--sKK",
        "outputId": "15ea1610-32f3-41df-b084-47b67a563a0c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Weekly Contest 272**"
      ],
      "metadata": {
        "id": "B8rpxshekQAm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **5956. Find First Palindromic String in the Array**\n",
        "Given an array of strings words, return the first palindromic string in the array. If there is no such string, return an empty string \"\".\n",
        "\n",
        "A string is palindromic if it reads the same forward and backward.\n",
        "\n",
        " \n",
        "\n",
        "**Example 1:**\n",
        "```\n",
        "Input: words = [\"abc\",\"car\",\"ada\",\"racecar\",\"cool\"]\n",
        "Output: \"ada\"\n",
        "Explanation: The first string that is palindromic is \"ada\".\n",
        "Note that \"racecar\" is also palindromic, but it is not the first.\n",
        "```"
      ],
      "metadata": {
        "id": "B2-j6MNFm54e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "temp = \"\"\n",
        "words = [\"abc\",\"car\",\"ada\",\"racecar\",\"cool\"]\n",
        "for i in range(len(words)):\n",
        "  val = int(len(words[i]) / 2)\n",
        "  word = words[i]\n",
        "  for j in range(val):\n",
        "    if word[j]\n",
        "    "
      ],
      "metadata": {
        "id": "G0YKP5IlkVrO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "words = [\"abc\",\"car\",\"ada\",\"racecar\",\"cool\"]\n",
        "for i in range(len(words)):\n",
        "  val = words[i]\n",
        "  if val[::-1] == val:\n",
        "    print(val)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cdbZ7Cp4lQ8-",
        "outputId": "05ce7c6d-3502-4e3b-e05a-8716782d0f6e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ada\n",
            "racecar\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **5957. Adding Spaces to a String**"
      ],
      "metadata": {
        "id": "tdtwsAUynFAe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"LeetcodeHelpsMeLearn\"\n",
        "spaces = [8,13,15]\n",
        "newstring = \"\"\n",
        "# i = spaces[0]\n",
        "i = 0\n",
        "# j = 1\n",
        "newstring += s[0:spaces[0]] + \" \"\n",
        "print(newstring)\n",
        "# while i < len(spaces):\n",
        "for i in range(len(spaces)-1):\n",
        "  newstring += s[spaces[i]:spaces[i+1]] + \" \"\n",
        "  # if len(spaces) ==  0:\n",
        "  #   print(newstring)\n",
        "  # i = spaces[j]\n",
        "  # j += 1\n",
        "  i += 1\n",
        "print(newstring)\n",
        "strin = newstring[:-1]\n",
        "print(strin)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YTGEb_axnLeX",
        "outputId": "84ee7857-140c-408c-997f-e89d7df3182f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Leetcode \n",
            "Leetcode Helps Me \n",
            "Leetcode Helps Me\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **5958. Number of Smooth Descent Periods of a Stock**"
      ],
      "metadata": {
        "id": "D0e5eud8t7JE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def getDescentPeriods(self, prices) -> int:\n",
        "        k = 0\n",
        "        periods = len(prices)\n",
        "        for i in range(1, len(prices)):\n",
        "            local_period = 0\n",
        "            for j in range(k, i):\n",
        "                if j < len(prices):\n",
        "                    if prices[j] - prices[j+1] == 1:\n",
        "                        local_period += 1\n",
        "                if local_period == 0:\n",
        "                    k = i\n",
        "            periods += local_period\n",
        "        return periods\n",
        "obj1 = Solution()\n",
        "print(obj1.getDescentPeriods(prices = [3,2,1,4]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "89R8ykRut6y1",
        "outputId": "32b18b5c-f2cc-45b8-ed4b-b53222d55708"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Biweekly Contest 68**\n"
      ],
      "metadata": {
        "id": "8WJTfNqZh20T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **2114. Maximum Number of Words Found in Sentences**"
      ],
      "metadata": {
        "id": "TscmmJK2h_0q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Test-1\n",
        "recipes = [\"ju\",\"fzjnm\",\"x\",\"e\",\"zpmcz\",\"h\",\"q\"]\n",
        "ingredients = [[\"d\"],[\"hveml\",\"f\",\"cpivl\"],[\"cpivl\",\"zpmcz\",\"h\",\"e\",\"fzjnm\",\"ju\"],[\"cpivl\",\"hveml\",\"zpmcz\",\"ju\",\"h\"],[\"h\",\"fzjnm\",\"e\",\"q\",\"x\"],[\"d\",\"hveml\",\"cpivl\",\"q\",\"zpmcz\",\"ju\",\"e\",\"x\"],[\"f\",\"hveml\",\"cpivl\"]]\n",
        "supplies = [\"f\",\"hveml\",\"cpivl\",\"d\"]\n",
        "# [\"ju\",\"fzjnm\",\"q\"]     # Expected\n",
        "# Input-1\n",
        "# recipes = [\"bread\",\"sandwich\",\"burger\"]\n",
        "# ingredients = [[\"yeast\",\"flour\"],[\"bread\",\"meat\"],[\"sandwich\",\"meat\",\"bread\"]]\n",
        "# supplies = [\"yeast\",\"flour\",\"meat\"]\n",
        "# Input-2\n",
        "# recipes = [\"bread\",\"sandwich\"]\n",
        "# ingredients = [[\"yeast\",\"flour\"],[\"bread\",\"meat\"]] \n",
        "# supplies = [\"yeast\",\"flour\",\"meat\"]\n",
        "# Input-3\n",
        "# recipes = [\"bread\"]\n",
        "# ingredients = [[\"yeast\",\"flour\"]]\n",
        "# supplies = [\"yeast\",\"flour\",\"corn\"]\n",
        "made = []\n",
        "cannot = set()\n",
        "for x, recip_ingred in enumerate(ingredients):\n",
        "  for i in recip_ingred:\n",
        "    if i not in supplies:\n",
        "      if i not in recipes or recipes.index(i) >= x:\n",
        "        cannot.add(recipes[ingredients.index(recip_ingred)])\n",
        "        print(\"cannot made\")\n",
        "  # if recipes.index(i) <= x:\n",
        "  #   print(x, recipes.index(recipes[ingredients.index(recip_ingred)]) , recipes[ingredients.index(recip_ingred)], end = \" \")\n",
        "  made.append(recipes[ingredients.index(recip_ingred)])\n",
        "print(made)\n",
        "# print(cannot)\n",
        "print(set(made)-cannot)\n",
        "# print(cannot.intersection(set(made)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yJmhO_btHkv5",
        "outputId": "293bd2d4-caf4-40f2-a77b-6580f6c9b53b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cannot made\n",
            "cannot made\n",
            "cannot made\n",
            "cannot made\n",
            "cannot made\n",
            "cannot made\n",
            "cannot made\n",
            "cannot made\n",
            "['ju', 'fzjnm', 'x', 'e', 'zpmcz', 'h', 'q']\n",
            "{'ju', 'fzjnm', 'q'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test-1\n",
        "# recipes = [\"ju\",\"fzjnm\",\"x\",\"e\",\"zpmcz\",\"h\",\"q\"]\n",
        "# ingredients = [[\"d\"],[\"hveml\",\"f\",\"cpivl\"],[\"cpivl\",\"zpmcz\",\"h\",\"e\",\"fzjnm\",\"ju\"],[\"cpivl\",\"hveml\",\"zpmcz\",\"ju\",\"h\"],[\"h\",\"fzjnm\",\"e\",\"q\",\"x\"],[\"d\",\"hveml\",\"cpivl\",\"q\",\"zpmcz\",\"ju\",\"e\",\"x\"],[\"f\",\"hveml\",\"cpivl\"]]\n",
        "# supplies = [\"f\",\"hveml\",\"cpivl\",\"d\"]\n",
        "# Input-1\n",
        "recipes = [\"bread\",\"sandwich\",\"burger\"]\n",
        "ingredients = [[\"yeast\",\"flour\"],[\"bread\",\"meat\"],[\"sandwich\",\"meat\",\"bread\"]]\n",
        "supplies = [\"yeast\",\"flour\",\"meat\"]\n",
        "supplies = set(supplies)\n",
        "made = []\n",
        "for i in range(len(recipes)):\n",
        "  for j in range(len(recipes)):\n",
        "    ok = True\n",
        "    for w in ingredients[j]:\n",
        "      if w not in supplies:\n",
        "        ok = False\n",
        "        break\n",
        "    if ok:\n",
        "      made.append(recipes[j])\n",
        "      supplies.add(recipes[j])\n",
        "print(set(made))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VN1zWt1tg0MT",
        "outputId": "25202122-9fad-4973-c940-ef6f9bacb176"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'sandwich', 'bread', 'burger'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Weekly Contest 273**"
      ],
      "metadata": {
        "id": "J4_CNDOD7dRm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **2119. A Number After a Double Reversal**"
      ],
      "metadata": {
        "id": "kxLp3Z5E7f8_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = 526\n",
        "temp = str(num)[::-1]\n",
        "# temp1 = temp[::-1]\n",
        "temp1 = int(temp)\n",
        "temp2 = str(temp1)[::-1]\n",
        "if int(temp2) == num:\n",
        "  print(True)\n",
        "else :\n",
        "  print(False)\n",
        "print(temp1)\n",
        "print(temp2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N4t3vt9KpLMF",
        "outputId": "d283cbf0-c02a-49ce-c47d-d19176f0ded5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "625\n",
            "526\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **2120. Execution of All Suffix Instructions Staying in a Grid**"
      ],
      "metadata": {
        "id": "paF-CPyR74j2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "positions = set()\n",
        "for i in range(3):\n",
        "  for j in range(3):\n",
        "    positions.add((i, j))\n",
        "print(positions)\n",
        "\n",
        "print((1,2+1))\n",
        "startPost = (2, 1)\n",
        "startPost1 = startPost[0] - 1, startPost[1]\n",
        "print(startPost, startPost1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "53SZvl3LrNIH",
        "outputId": "b569683e-9f15-4cd4-efb2-2d9f691f8511"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{(0, 1), (1, 2), (0, 0), (2, 1), (2, 0), (1, 1), (2, 2), (1, 0), (0, 2)}\n",
            "(1, 3)\n",
            "(2, 1) (1, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Solution:\n",
        "    def executeInstructions(self, n, startPos, s):\n",
        "        s = s + 'F'\n",
        "        positions = set()\n",
        "        count = 0\n",
        "        answer = []\n",
        "        fir = 0\n",
        "        sec = 1\n",
        "        startPos1 = startPos.copy()\n",
        "        for i in range(n):\n",
        "            for j in range(n):\n",
        "                positions.add((i, j))\n",
        "        \n",
        "        for i in range(len(s)):\n",
        "            for j in range(i, len(s)):\n",
        "                if s[j] == 'L':\n",
        "                    startPos1 = startPos1[fir], startPos1[sec]-1\n",
        "                    if startPos1 in positions:\n",
        "                        count += 1\n",
        "                    else:\n",
        "                        answer.append(count)\n",
        "                        break\n",
        "                elif s[j] == 'R':\n",
        "                    startPos1 = startPos1[fir], startPos1[sec] + 1\n",
        "                    if startPos1 in positions:\n",
        "                        count += 1\n",
        "                    else:\n",
        "                        answer.append(count)\n",
        "                        break\n",
        "                elif s[j] == 'U':\n",
        "                    startPos1 = startPos1[fir] - 1, startPos1[sec]\n",
        "                    if startPos1 in positions:\n",
        "                        count += 1\n",
        "                    else:\n",
        "                        answer.append(count)\n",
        "                        break\n",
        "                elif s[j] == 'D':\n",
        "                    startPos1 = startPos1[fir] + 1, startPos1[sec]\n",
        "                    if startPos1 in positions:\n",
        "                        count += 1\n",
        "                    else:\n",
        "                        answer.append(count)\n",
        "                        break\n",
        "                else:\n",
        "                    answer.append(count)\n",
        "                    break\n",
        "            startPos1 = startPos.copy()\n",
        "            count = 0\n",
        "        return answer[:-1]\n"
      ],
      "metadata": {
        "id": "ygiLtIh7z-qX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = 2\n",
        "startPos = [1,1]\n",
        "s = \"LURD\"\n",
        "obj1 = Solution()\n",
        "print(obj1.executeInstructions(n, startPos, s))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wQZEuK2k0W6G",
        "outputId": "611937e8-bd15-4a37-b53f-508daedb11bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 1, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Another best possible found Solution\n",
        "class Solution:\n",
        "    def executeInstructions(self, n, startPos, s):\n",
        "        m = len(s)\n",
        "        r = [0] * m\n",
        "        for i in range(m):\n",
        "            x, y = startPos\n",
        "            for j in range(i, m):\n",
        "                x += {'L':0, 'R':0, 'D':1, 'U':-1}[s[j]]\n",
        "                y += {'L':-1, 'R':1, 'D':0, 'U':0}[s[j]]\n",
        "                if x<0 or y<0 or x>=n or y>=n:\n",
        "                    break\n",
        "                r[i] += 1\n",
        "        return r"
      ],
      "metadata": {
        "id": "VErctJFjTUV1"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = 3\n",
        "startPos = [0,1]\n",
        "s = \"RRDDLU\"\n",
        "obj2 = Solution()\n",
        "print(obj2.executeInstructions(n, startPos, s))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4jA1lmAxSdPM",
        "outputId": "586fc198-5688-47ab-fb4d-6f334fbeddd6"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 5, 4, 3, 1, 0]\n"
          ]
        }
      ]
    }
  ]
}