Added tasks 131-200

Author: javadev

README.md

@@ -0,0 +1,26 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
+# #Backtracking #Big_O_Time_O(N*2^N)_Space_O(2^N*N)
+# #2024_06_09_Time_444_ms_(93.43%)_Space_32.1_MB_(84.45%)
+
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        res = []
+        self.backtracking(res, [], s, 0)
+        return res
+
+    def backtracking(self, res, curr_arr, s, start):
+        if start == len(s):
+            res.append(list(curr_arr))
+            return
+        for end in range(start, len(s)):
+            if not self.is_palindrome(s, start, end):
+                continue
+            curr_arr.append(s[start:end + 1])
+            self.backtracking(res, curr_arr, s, end + 1)
+            curr_arr.pop()
+
+    def is_palindrome(self, s, start, end):
+        while start < end and s[start] == s[end]:
+            start += 1
+            end -= 1
+        return start >= end

src/main/python/g0101_0200/s0131_palindrome_partitioning/Solution.py

@@ -0,0 +1,64 @@
+131\. Palindrome Partitioning
+
+Medium
+
+Given a string `s`, partition `s` such that every substring of the partition is a **palindrome**. Return all possible palindrome partitioning of `s`.
+
+A **palindrome** string is a string that reads the same backward as forward.
+
+**Example 1:**
+
+**Input:** s = "aab"
+
+**Output:** [["a","a","b"],["aa","b"]] 
+
+**Example 2:**
+
+**Input:** s = "a"
+
+**Output:** [["a"]] 
+
+**Constraints:**
+
+*   `1 <= s.length <= 16`
+*   `s` contains only lowercase English letters.
+
+To solve this task, we can use a backtracking approach. Here are the steps to solve the problem using the `Solution` class:
+
+1. Define the `Solution` class with a method `partition` that takes a string `s` as input and returns a list of lists containing all possible palindrome partitions of `s`.
+2. Within the `partition` method, initialize an empty list to store the result.
+3. Define a helper function, let's name it `dfs`, which will perform depth-first search to generate all possible partitions.
+4. In the `dfs` function, if the current partition `start` is equal to the length of the string `s`, append the current partition to the result list.
+5. Otherwise, iterate through each possible end index of the substring starting from `start` to the end of the string.
+6. Check if the substring from `start` to the current end index is a palindrome. If it is, recursively call the `dfs` function with the updated start index and add the current palindrome substring to the current partition.
+7. After exploring all possible partitions, backtrack by removing the last added substring to explore other possibilities.
+8. Finally, return the result list containing all possible palindrome partitions.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        result = []
+        
+        def dfs(start, partition):
+            if start == len(s):
+                result.append(partition[:])
+                return
+            
+            for end in range(start + 1, len(s) + 1):
+                if s[start:end] == s[start:end][::-1]:
+                    partition.append(s[start:end])
+                    dfs(end, partition)
+                    partition.pop()
+        
+        dfs(0, [])
+        return result
+
+# Example usage:
+solution = Solution()
+print(solution.partition("aab"))  # Output: [["a","a","b"],["aa","b"]]
+print(solution.partition("a"))     # Output: [["a"]]
+```
+
+This solution utilizes backtracking to efficiently generate all possible palindrome partitions of the given string `s`.

src/main/python/g0101_0200/s0131_palindrome_partitioning/readme.md

@@ -0,0 +1,10 @@
+# #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Bit_Manipulation
+# #Data_Structure_II_Day_1_Array #Algorithm_I_Day_14_Bit_Manipulation #Udemy_Integers
+# #Big_O_Time_O(N)_Space_O(1) #2024_06_09_Time_98_ms_(96.80%)_Space_19_MB_(89.40%)
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        res = 0
+        for num in nums:
+            res ^= num
+        return res

src/main/python/g0101_0200/s0136_single_number/Solution.py

@@ -0,0 +1,59 @@
+136\. Single Number
+
+Easy
+
+Given a **non-empty** array of integers `nums`, every element appears _twice_ except for one. Find that single one.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,1]
+
+**Output:** 1 
+
+**Example 2:**
+
+**Input:** nums = [4,1,2,1,2]
+
+**Output:** 4 
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-3 * 10<sup>4</sup> <= nums[i] <= 3 * 10<sup>4</sup></code>
+*   Each element in the array appears twice except for one element which appears only once.
+
+To solve this problem with the `Solution` class, which requires linear runtime complexity and constant extra space, we can utilize the bitwise XOR operation. Here are the steps:
+
+1. Define the `Solution` class with a method `singleNumber` that takes a list of integers `nums` as input and returns the single number that appears only once.
+2. Within the `singleNumber` method, initialize a variable `result` to 0.
+3. Iterate through each element in the `nums` list.
+4. Perform bitwise XOR operation between `result` and the current element.
+5. After iterating through all elements, `result` will contain the single number that appears only once due to the properties of XOR operation.
+6. Finally, return the `result`.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        result = 0
+        for num in nums:
+            result ^= num
+        return result
+
+# Example usage:
+solution = Solution()
+print(solution.singleNumber([2, 2, 1]))      # Output: 1
+print(solution.singleNumber([4, 1, 2, 1, 2]))# Output: 4
+print(solution.singleNumber([1]))            # Output: 1
+```
+
+This solution leverages the bitwise XOR operation to find the single number that appears only once in the array, achieving linear runtime complexity and constant extra space usage.

src/main/python/g0101_0200/s0136_single_number/readme.md

@@ -0,0 +1,44 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Hash_Table #Linked_List
+# #Programming_Skills_II_Day_14 #Udemy_Linked_List #Big_O_Time_O(N)_Space_O(N)
+# #2024_06_09_Time_36_ms_(72.10%)_Space_17.3_MB_(95.85%)
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+"""
+
+class Solution:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        if head is None:
+            return None
+        
+        # First pass: create the cloned nodes and insert them right after the original nodes
+        curr = head
+        while curr:
+            cloned_node = Node(curr.val)
+            cloned_node.next = curr.next
+            curr.next = cloned_node
+            curr = cloned_node.next
+        
+        # Second pass: update the random pointers of the cloned nodes
+        curr = head
+        while curr:
+            if curr.random:
+                curr.next.random = curr.random.next
+            curr = curr.next.next
+        
+        # Third pass: separate the cloned list from the original list
+        curr = head
+        new_head = head.next
+        while curr:
+            cloned_node = curr.next
+            curr.next = cloned_node.next
+            if cloned_node.next:
+                cloned_node.next = cloned_node.next.next
+            curr = curr.next
+        
+        return new_head

src/main/python/g0101_0200/s0138_copy_list_with_random_pointer/Solution.py

@@ -0,0 +1,94 @@
+138\. Copy List with Random Pointer
+
+Medium
+
+A linked list of length `n` is given such that each node contains an additional random pointer, which could point to any node in the list, or `null`.
+
+Construct a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) of the list. The deep copy should consist of exactly `n` **brand new** nodes, where each new node has its value set to the value of its corresponding original node. Both the `next` and `random` pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. **None of the pointers in the new list should point to nodes in the original list**.
+
+For example, if there are two nodes `X` and `Y` in the original list, where `X.random --> Y`, then for the corresponding two nodes `x` and `y` in the copied list, `x.random --> y`.
+
+Return _the head of the copied linked list_.
+
+The linked list is represented in the input/output as a list of `n` nodes. Each node is represented as a pair of `[val, random_index]` where:
+
+*   `val`: an integer representing `Node.val`
+*   `random_index`: the index of the node (range from `0` to `n-1`) that the `random` pointer points to, or `null` if it does not point to any node.
+
+Your code will **only** be given the `head` of the original linked list.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/12/18/e1.png)
+
+**Input:** head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+
+**Output:** [[7,null],[13,0],[11,4],[10,2],[1,0]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2019/12/18/e2.png)
+
+**Input:** head = [[1,1],[2,1]]
+
+**Output:** [[1,1],[2,1]] 
+
+**Example 3:**
+
+**![](https://assets.leetcode.com/uploads/2019/12/18/e3.png)**
+
+**Input:** head = [[3,null],[3,0],[3,null]]
+
+**Output:** [[3,null],[3,0],[3,null]] 
+
+**Example 4:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Explanation:** The given linked list is empty (null pointer), so return null. 
+
+**Constraints:**
+
+*   `0 <= n <= 1000`
+*   `-10000 <= Node.val <= 10000`
+*   `Node.random` is `null` or is pointing to some node in the linked list.
+
+To solve this problem with the `Solution` class, we can use a hashmap to keep track of the mapping between original nodes and their corresponding copied nodes. Here are the steps:
+
+1. Define the `Solution` class with a method `copyRandomList` that takes the head of the original linked list as input and returns the head of the copied linked list.
+2. Within the `copyRandomList` method, if the input `head` is `None`, return `None` as the copied list is empty.
+3. Initialize an empty hashmap to store the mapping between original nodes and copied nodes.
+4. Iterate through the original linked list and create a copied node for each original node. Set the value of the copied node to be the same as the original node and set both `next` and `random` pointers of the copied node to `None`.
+5. Store the mapping between original nodes and copied nodes in the hashmap.
+6. Iterate through the original linked list again and update the `next` and `random` pointers of copied nodes according to the mapping stored in the hashmap.
+7. Finally, return the head of the copied linked list.
+
+Here's how the `Solution` class would look like in Python:
+
+```python
+class Solution:
+    def copyRandomList(self, head: 'Node') -> 'Node':
+        if not head:
+            return None
+        
+        mapping = {}
+        
+        # Create copies of nodes without pointers
+        current = head
+        while current:
+            mapping[current] = Node(current.val)
+            current = current.next
+        
+        # Assign pointers for each copied node
+        current = head
+        while current:
+            mapping[current].next = mapping.get(current.next)
+            mapping[current].random = mapping.get(current.random)
+            current = current.next
+        
+        return mapping[head]
+```
+
+Make sure to define the `Node` class before using it in the `copyRandomList` method. This solution constructs a deep copy of the original linked list while maintaining the relationships between nodes as specified.

src/main/python/g0101_0200/s0138_copy_list_with_random_pointer/readme.md

@@ -0,0 +1,25 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table
+# #Dynamic_Programming #Trie #Memoization #Algorithm_II_Day_15_Dynamic_Programming
+# #Dynamic_Programming_I_Day_9 #Udemy_Dynamic_Programming #Big_O_Time_O(M+max*N)_Space_O(M+N+max)
+# #2024_06_09_Time_41_ms_(50.55%)_Space_16.6_MB_(88.23%)
+
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        n = len(s)
+        dp = [-1] * n
+
+        def solve(i, s):
+            if i < 0:
+                return True
+            if dp[i] != -1:
+                return dp[i] == 1
+            for w in wordDict:
+                sz = len(w)
+                if i - sz + 1 >= 0 and s[i - sz + 1 : i + 1] == w:
+                    if solve(i - sz, s):
+                        dp[i] = 1
+                        return True
+            dp[i] = 0
+            return False
+
+        return solve(n - 1, s)