Python_Questions_Set3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "33703877-1fa9-4016-aaf2-4e235f507183",
      "metadata": {
        "id": "33703877-1fa9-4016-aaf2-4e235f507183"
      },
      "source": [
        "# Set 3: Data Sense Presents: Python Zero to Hero Question Series (200 Questions)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b5666594-39ae-4bd5-8040-a2646cf40878",
      "metadata": {
        "id": "b5666594-39ae-4bd5-8040-a2646cf40878"
      },
      "source": [
        "**10 Questions**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6c1c25db-6de6-4f58-9733-52c6b48684c8",
      "metadata": {
        "id": "6c1c25db-6de6-4f58-9733-52c6b48684c8"
      },
      "source": [
        "**Question 1**\n",
        "\n",
        "Given an integer array nums sorted in non-decreasing order, remove some duplicates in-place such that each unique element appears at most twice. 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",
        "**Example 1:**\n",
        "\n",
        "Input: nums = [1,1,1,2,2,3]\n",
        "\n",
        "Output: 5, nums = [1,1,2,2,3,_]\n",
        "\n",
        "Explanation: Your function should return k = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.\n",
        "\n",
        "It does not matter what you leave beyond the returned k (hence they are underscores).\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: nums = [0,0,1,1,1,1,2,3,3]\n",
        "\n",
        "Output: 7, nums = [0,0,1,1,2,3,3,_,_]\n",
        "\n",
        "Explanation: Your function should return k = 7, with the first seven elements of nums being 0, 0, 1, 1, 2, 3 and 3 respectively.\n",
        "\n",
        "It does not matter what you leave beyond the returned k (hence they are underscores).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "422349f4-bfba-44e3-8435-23b27fc1a061",
      "metadata": {
        "id": "422349f4-bfba-44e3-8435-23b27fc1a061",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0e327d8a-8b99-43ff-aa4c-cb626a0228bd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "First 5 elements from [1, 1, 1, 2, 2, 3] after removing some duplicates (at most twice appearance is allowed) are:\n",
            "[1, 1, 2, 2, 3]\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "First 7 elements from [0, 0, 1, 1, 1, 1, 2, 3, 3] after removing some duplicates (at most twice appearance is allowed) are:\n",
            "[0, 0, 1, 1, 2, 3, 3]\n",
            "Test Case 2 Passed!\n"
          ]
        }
      ],
      "source": [
        "def return_k_elements_from_new_nums(N, x):\n",
        "\n",
        "  # iterating over every-element in N\n",
        "  for num in N:\n",
        "    # getting count of each element in N\n",
        "    count_num = N.count(num)\n",
        "    # if any element has a count over twice, then simply remove it\n",
        "    for i in range(count_num - 2):\n",
        "      N.remove(num)\n",
        "  # if the length of N is lesser than the 'x' (number of elements to be returned), then simply append '_' (underscore) to the N\n",
        "  if(len(N) < x):\n",
        "    for i in range(abs(len(N) - x)):\n",
        "      N.append('_')\n",
        "\n",
        "  return N #return N[:x] also works!\n",
        "\n",
        "\n",
        "# main() code\n",
        "print(\"Test Case 1 Running...\")\n",
        "nums = [1,1,1,2,2,3]\n",
        "k = 5\n",
        "print(f\"First {k} elements from {nums} after removing some duplicates (at most twice appearance is allowed) are:\\n{return_k_elements_from_new_nums(nums, k)}\")\n",
        "print(\"Test Case 1 Passed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "print(\"Test Case 2 Running...\")\n",
        "nums = [0,0,1,1,1,1,2,3,3]\n",
        "k = 7\n",
        "print(f\"First {k} elements from {nums} after removing some duplicates (at most twice appearance is allowed) are:\\n{return_k_elements_from_new_nums(nums, k)}\")\n",
        "print(\"Test Case 2 Passed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a65d407e-6ad4-4759-9677-93b1a111bac9",
      "metadata": {
        "id": "a65d407e-6ad4-4759-9677-93b1a111bac9"
      },
      "source": [
        "**Question 2**\n",
        "\n",
        "Given a string s, return true if the s can be palindrome after deleting at most one character from it.\n",
        "\n",
        "\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "Input: s = \"aba\"\n",
        "Output: true\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: s = \"abca\"\n",
        "Output: true\n",
        "Explanation: You could delete the character 'c'.\n",
        "\n",
        "**Example 3:**\n",
        "\n",
        "Input: s = \"abc\"\n",
        "Output: false\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7bb5ddc0-4b6e-4ffc-b26f-9c9277c32f5c",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7bb5ddc0-4b6e-4ffc-b26f-9c9277c32f5c",
        "outputId": "a6f2830e-91fb-471a-a04a-d82952967528"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "For aba: True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "For abca: True\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "For abc: False\n",
            "Test Case 3 Passed!\n"
          ]
        }
      ],
      "source": [
        "def check_palindrome_even_after_removing_atmost_one_character(sentence):\n",
        "  i = 0\n",
        "  j = len(sentence) - 1\n",
        "  count_to_remove_atmost_one_character = 0\n",
        "  while (i < j):\n",
        "    if (sentence[i] == sentence[j]):\n",
        "      i += 1\n",
        "      j -= 1\n",
        "    else:\n",
        "      if (count_to_remove_atmost_one_character >= 1):\n",
        "        return False\n",
        "      i += 1\n",
        "      count_to_remove_atmost_one_character += 1\n",
        "\n",
        "  return True\n",
        "\n",
        "\n",
        "# main() code\n",
        "print(\"Test Case 1 Running...\")\n",
        "s = \"aba\"\n",
        "print(f\"For {s}: {check_palindrome_even_after_removing_atmost_one_character(s)}\")\n",
        "print(\"Test Case 1 Passed!\")\n",
        "print()\n",
        "print(\"Test Case 2 Running...\")\n",
        "s = \"abca\"\n",
        "print(f\"For {s}: {check_palindrome_even_after_removing_atmost_one_character(s)}\")\n",
        "print(\"Test Case 2 Passed!\")\n",
        "print()\n",
        "print(\"Test Case 3 Running...\")\n",
        "s = \"abc\"\n",
        "print(f\"For {s}: {check_palindrome_even_after_removing_atmost_one_character(s)}\")\n",
        "print(\"Test Case 3 Passed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f9a8df18-38e8-4f42-a57b-549a5383e22e",
      "metadata": {
        "id": "f9a8df18-38e8-4f42-a57b-549a5383e22e"
      },
      "source": [
        "**Question 3** You are given an integer array nums and an integer k.\n",
        "\n",
        "In one operation, you can pick two numbers from the array whose sum equals k and remove them from the array.\n",
        "\n",
        "Return the maximum number of operations you can perform on the array.\n",
        "\n",
        "\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "Input: nums = [1,2,3,4], k = 5\n",
        "Output: 2\n",
        "Explanation: Starting with nums = [1,2,3,4]:\n",
        "- Remove numbers 1 and 4, then nums = [2,3]\n",
        "- Remove numbers 2 and 3, then nums = []\n",
        "There are no more pairs that sum up to 5, hence a total of 2 operations.\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: nums = [3,1,3,4,3], k = 6\n",
        "\n",
        "Output: 1\n",
        "\n",
        "Explanation: Starting with nums = [3,1,3,4,3]:\n",
        "\n",
        "- Remove the first two 3's, then nums = [1,4,3]\n",
        "-\n",
        "There are no more pairs that sum up to 6, hence a total of 1 operation.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "99171067-e51a-4d44-a96f-4cbea46c5231",
      "metadata": {
        "id": "99171067-e51a-4d44-a96f-4cbea46c5231",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b15c20d-dacb-4a81-ccf3-51775905b4bf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Total number of operations performed on [1, 2, 3, 4] to get target 5 are : 2\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Total number of operations performed on [3, 1, 3, 4, 3] to get target 6 are : 1\n",
            "Test Case 2 Passed!\n"
          ]
        }
      ],
      "source": [
        "def count_operations_to_get_target_in_nums(N, x):\n",
        "  left_pointer = 0\n",
        "  right_pointer = len(N) - 1\n",
        "  operation_count = 0\n",
        "\n",
        "  while (left_pointer < right_pointer):\n",
        "\n",
        "    if ((N[left_pointer] + N[right_pointer]) == x):\n",
        "      operation_count += 1\n",
        "      left_pointer += 1\n",
        "      right_pointer -= 1\n",
        "    elif ((N[left_pointer] + N[right_pointer]) < x):\n",
        "      left_pointer += 1\n",
        "    else:\n",
        "      right_pointer -= 1\n",
        "\n",
        "  return operation_count\n",
        "\n",
        "# main() code\n",
        "print(\"Test Case 1 Running...\")\n",
        "nums = [1,2,3,4]\n",
        "k = 5\n",
        "\n",
        "print(f\"Total number of operations performed on {nums} to get target {k} are : {count_operations_to_get_target_in_nums(nums, k)}\")\n",
        "print(\"Test Case 1 Passed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "print(\"Test Case 2 Running...\")\n",
        "nums = [3,1,3,4,3]\n",
        "k = 6\n",
        "\n",
        "print(f\"Total number of operations performed on {nums} to get target {k} are : {count_operations_to_get_target_in_nums(nums, k)}\")\n",
        "print(\"Test Case 2 Passed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f81513d3-f88b-4840-a4b6-c7871eefa566",
      "metadata": {
        "id": "f81513d3-f88b-4840-a4b6-c7871eefa566"
      },
      "source": [
        "**Question 4** Given a string str, find the length of the longest substring without repeating characters.\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "Input: “ABCDEFGABEF”\n",
        "\n",
        "Output: 7\n",
        "\n",
        "Explanation: The longest substring without repeating characters are “ABCDEFG”, “BCDEFGA”, and “CDEFGAB” with lengths of 7\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: “GEEKSFORGEEKS”\n",
        "\n",
        "Output: 7\n",
        "\n",
        "Explanation: The longest substrings without repeating characters are “EKSFORG” and “KSFORGE”, with lengths of 7\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7788bd0f-b73a-43b8-b3e2-a4368be5ed3c",
      "metadata": {
        "id": "7788bd0f-b73a-43b8-b3e2-a4368be5ed3c"
      },
      "outputs": [],
      "source": [
        "#in-processing..."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ec290f1f-1ba1-45b4-8918-1c41a5f3caaa",
      "metadata": {
        "id": "ec290f1f-1ba1-45b4-8918-1c41a5f3caaa"
      },
      "source": [
        "**Question 5**  Product of Array except itself\n",
        "\n",
        "Given an array arr[] of n integers, construct a Product Array prod[] (of the same size) such that prod[i] is equal to the product of all the elements of arr[] except arr[i].\n",
        "\n",
        "**Example 1**\n",
        "\n",
        "Input: arr[]  = {10, 3, 5, 6, 2}\n",
        "\n",
        "Output: prod[]  = {180, 600, 360, 300, 900}\n",
        "\n",
        "3 * 5 * 6 * 2 product of other array\n",
        "elements except 10 is 180\n",
        "\n",
        "10 * 5 * 6 * 2 product of other array\n",
        "elements except 3 is 600\n",
        "\n",
        "10 * 3 * 6 * 2 product of other array\n",
        "elements except 5 is 360\n",
        "\n",
        "10 * 3 * 5 * 2 product of other array\n",
        "elements except 6 is 300\n",
        "\n",
        "10 * 3 * 6 * 5 product of other array\n",
        "elements except 2 is 900\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7552e59a-ba9c-44cb-83f0-177d556b6f8b",
      "metadata": {
        "id": "7552e59a-ba9c-44cb-83f0-177d556b6f8b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a32fdcd7-7e74-426f-f6e6-d3da5bb2aa4a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[120, 60, 40, 30, 24]\n"
          ]
        }
      ],
      "source": [
        "def product_of_all_elements_except_itself(N):\n",
        "  all_element_product = 1\n",
        "  for value in N:\n",
        "    all_element_product *= value\n",
        "\n",
        "  return [int(all_element_product/x) for x in N]\n",
        "\n",
        "\n",
        "# main() code\n",
        "nums= [1,2,3,4,5]\n",
        "\n",
        "print(f\"{product_of_all_elements_except_itself(nums)}\")\n",
        "#output [120,60,40,30,24]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "33567d47-6b62-4f08-901f-72a6754dde62",
      "metadata": {
        "id": "33567d47-6b62-4f08-901f-72a6754dde62"
      },
      "source": [
        "**Question 6** Check whether two Strings are anagram of each other\n",
        "\n",
        "Given two strings s1 and s2 consisting of lowercase characters, the task is to check whether the two given strings are anagrams of each other or not. An anagram of a string is another string that contains the same characters, only the order of characters can be different. For example, “act” and “tac” are anagrams of each other.\n",
        "\n",
        "**Example 1**\n",
        "\n",
        "Input: str1 = “listen”  str2 = “silent”\n",
        "\n",
        "Output: “Anagram”\n",
        "\n",
        "Explanation: All characters of “listen” and “silent” are the same.\n",
        "\n",
        "**Example 2**\n",
        "\n",
        "Input: str1 = “gram”  str2 = “arm”\n",
        "\n",
        "Output: “Not Anagram”\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4976875c-bebb-4513-9d71-eeb844141f69",
      "metadata": {
        "id": "4976875c-bebb-4513-9d71-eeb844141f69",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b255da68-05e0-4697-96bf-e8a5c8466c59"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "listen and silent are Anagram\n"
          ]
        }
      ],
      "source": [
        "def check_whether_strings_are_anagram(S1, S2):\n",
        "\n",
        "  if (len(S1) != len(S2)):\n",
        "    return \"Not Anagram\"\n",
        "\n",
        "  LIST_S1, LIST_S2  = list(S1), list(S2)\n",
        "\n",
        "  LIST_S1.sort()\n",
        "  LIST_S2.sort()\n",
        "\n",
        "  for i in range(len(LIST_S1)):\n",
        "    if LIST_S1[i] != LIST_S2[i]:\n",
        "      return \"Not Anagram\"\n",
        "\n",
        "  return \"Anagram\"\n",
        "\n",
        "\n",
        "# main() code\n",
        "str1, str2 = \"listen\", \"silent\"\n",
        "\n",
        "print(f\"{str1} and {str2} are {check_whether_strings_are_anagram(str1, str2)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f51973d8-faa1-4647-887b-77892430b6c9",
      "metadata": {
        "id": "f51973d8-faa1-4647-887b-77892430b6c9"
      },
      "source": [
        "**Question 7** Maximum Product Subarray\n",
        "\n",
        "Given an array that contains both positive and negative integers, the task is to find the product of the maximum product subarray.\n",
        "\n",
        "**Examples:**\n",
        "\n",
        "Input: arr[] = {6, -3, -10, 0, 2}\n",
        "Output:  180\n",
        "Explanation: The subarray is {6, -3, -10}\n",
        "\n",
        "Input: arr[] = {-1, -3, -10, 0, 60}\n",
        "Output:   60\n",
        "Explanation: The subarray is {60}\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "475b8dc6-aacc-4f1f-9031-85fa708b6b96",
      "metadata": {
        "id": "475b8dc6-aacc-4f1f-9031-85fa708b6b96"
      },
      "outputs": [],
      "source": [
        "#in-processing..."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9596219d-5b30-425e-bb9d-3820c7dce60a",
      "metadata": {
        "id": "9596219d-5b30-425e-bb9d-3820c7dce60a"
      },
      "source": [
        "**Question 8** Search Insert Position\n",
        "\n",
        "Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.\n",
        "\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "Input: nums = [1,3,5,6], target = 5\n",
        "Output: 2\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: nums = [1,3,5,6], target = 2\n",
        "Output: 1\n",
        "\n",
        "**Example 3:**\n",
        "\n",
        "Input: nums = [1,3,5,6], target = 7\n",
        "Output: 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4f35cdd0-9b24-4963-8060-d149c4ea3d61",
      "metadata": {
        "id": "4f35cdd0-9b24-4963-8060-d149c4ea3d61"
      },
      "outputs": [],
      "source": [
        "#in-processing..."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "afbba251-1fa9-4afd-bcef-dfd2add5939e",
      "metadata": {
        "id": "afbba251-1fa9-4afd-bcef-dfd2add5939e"
      },
      "source": [
        "**Question 9**  Remove Duplicates from Sorted Array\n",
        "\n",
        "Given a sorted array nums, remove the duplicates in-place such that each element appears only once and returns the new length. 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",
        "**Constraints:** nums is sorted in non-decreasing order.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "93641e9a-f44a-4264-b2a8-f3b016089121",
      "metadata": {
        "id": "93641e9a-f44a-4264-b2a8-f3b016089121"
      },
      "outputs": [],
      "source": [
        "#in-processing..."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "62a2ece8-e8c5-436d-8a13-eff53e9e507e",
      "metadata": {
        "id": "62a2ece8-e8c5-436d-8a13-eff53e9e507e"
      },
      "source": [
        "**Question 10** Pair with given Sum (Two Sum)\n",
        "\n",
        "Given an array A[] of n numbers and another number x, the task is to check whether or not there exist two elements in A[] whose sum is exactly x.\n",
        "\n",
        "**Examples:**\n",
        "\n",
        "Input: arr[] = {0, -1, 2, -3, 1}, x= -2\n",
        "Output: Yes\n",
        "Explanation: If we calculate the sum of the output,1 + (-3) = -2\n",
        "\n",
        "Input: arr[] = {1, -2, 1, 0, 5}, x = 0\n",
        "Output: No"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0d37f079-8db9-43c2-ac65-9f34fe05cff4",
      "metadata": {
        "id": "0d37f079-8db9-43c2-ac65-9f34fe05cff4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "381589ba-5572-4cae-8e8d-5ab74d584648"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Yes\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "No\n",
            "Test Case 2 Passed!\n"
          ]
        }
      ],
      "source": [
        "def does_there_exist_two_numbers_whose_sum_equals_target(N, target):\n",
        "  i = 0\n",
        "  j = len(N) - 1\n",
        "\n",
        "  while (i < j):\n",
        "\n",
        "    if ((N[i] + N[j]) == target):\n",
        "      return \"Yes\"\n",
        "    elif ((N[i] + N[j]) < target):\n",
        "      i += 1\n",
        "    else:\n",
        "      j -= 1\n",
        "\n",
        "  return \"No\"\n",
        "\n",
        "# main() code\n",
        "\n",
        "print(\"Test Case 1 Running...\")\n",
        "arr = [0, -1, 2, -3, 1]\n",
        "x = -2\n",
        "arr.sort()\n",
        "print(does_there_exist_two_numbers_whose_sum_equals_target(arr, x))\n",
        "print(\"Test Case 1 Passed!\")\n",
        "print()\n",
        "print(\"Test Case 2 Running...\")\n",
        "arr = [1, -2, 1, 0, 5]\n",
        "x = 0\n",
        "arr.sort()\n",
        "print(does_there_exist_two_numbers_whose_sum_equals_target(arr, x))\n",
        "print(\"Test Case 2 Passed!\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.4"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}