Added tasks 416-1143

Author: javadev

README.md

@@ -0,0 +1,15 @@
+# #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Level_2_Day_13_Dynamic_Programming
+# #Big_O_Time_O(n*sums)_Space_O(n*sums) #2024_06_07_Time_550_ms_(64.93%)_Space_16.6_MB_(92.89%)
+
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        sums = sum(nums)
+        if sums % 2 == 1:
+            return False
+        sums //= 2
+        dp = [False] * (sums + 1)
+        dp[0] = True
+        for num in nums:
+            for i in range(sums, num - 1, -1):
+                dp[i] = dp[i] or dp[i - num]
+        return dp[sums]

src/main/python/g0401_0500/s0416_partition_equal_subset_sum/Solution.py

@@ -0,0 +1,26 @@
+416\. Partition Equal Subset Sum
+
+Medium
+
+Given a **non-empty** array `nums` containing **only positive integers**, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.
+
+**Example 1:**
+
+**Input:** nums = [1,5,11,5]
+
+**Output:** true
+
+**Explanation:** The array can be partitioned as [1, 5, 5] and [11]. 
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,5]
+
+**Output:** false
+
+**Explanation:** The array cannot be partitioned into equal sum subsets. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   `1 <= nums[i] <= 100`

src/main/python/g0401_0500/s0416_partition_equal_subset_sum/readme.md

@@ -0,0 +1,31 @@
+# #Medium #Depth_First_Search #Tree #Binary_Tree #Level_2_Day_7_Tree #Big_O_Time_O(n)_Space_O(n)
+# #2024_06_07_Time_264_ms_(30.25%)_Space_16.8_MB_(98.67%)
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def __init__(self):
+        self.count = 0
+
+    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
+        if root is None:
+            return 0
+        self.helper(root, targetSum, 0)
+        self.pathSum(root.left, targetSum)
+        self.pathSum(root.right, targetSum)
+        return self.count
+
+    def helper(self, node: TreeNode, targetSum: int, currSum: int) -> None:
+        if node is None:
+            return
+        currSum += node.val
+        if targetSum == currSum:
+            self.count += 1
+        if node.left is not None:
+            self.helper(node.left, targetSum, currSum)
+        if node.right is not None:
+            self.helper(node.right, targetSum, currSum)

src/main/python/g0401_0500/s0437_path_sum_iii/Solution.py

@@ -0,0 +1,29 @@
+437\. Path Sum III
+
+Medium
+
+Given the `root` of a binary tree and an integer `targetSum`, return _the number of paths where the sum of the values along the path equals_ `targetSum`.
+
+The path does not need to start or end at the root or a leaf, but it must go downwards (i.e., traveling only from parent nodes to child nodes).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/09/pathsum3-1-tree.jpg)
+
+**Input:** root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
+
+**Output:** 3
+
+**Explanation:** The paths that sum to 8 are shown. 
+
+**Example 2:**
+
+**Input:** root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
+
+**Output:** 3 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 1000]`.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   `-1000 <= targetSum <= 1000`

src/main/python/g0401_0500/s0437_path_sum_iii/readme.md

@@ -0,0 +1,38 @@
+# #Medium #Top_100_Liked_Questions #String #Hash_Table #Sliding_Window
+# #Algorithm_II_Day_5_Sliding_Window #Programming_Skills_II_Day_12
+# #Level_1_Day_12_Sliding_Window/Two_Pointer #Big_O_Time_O(n+m)_Space_O(1)
+# #2024_06_07_Time_100_ms_(50.22%)_Space_17.6_MB_(97.85%)
+
+from collections import defaultdict
+
+class Solution:
+    def findAnagrams(self, s: str, p: str) -> List[int]:
+        map = [0] * 26
+        for char in p:
+            map[ord(char) - ord('a')] += 1
+        
+        res = []
+        i, j = 0, 0
+        
+        while i < len(s):
+            idx = ord(s[i]) - ord('a')
+            # add the new character
+            map[idx] -= 1
+            # if the length is greater than windows length, pop the left character in the window
+            if i >= len(p):
+                map[ord(s[j]) - ord('a')] += 1
+                j += 1
+            
+            finish = True
+            for k in range(26):
+                # if it is not an anagram of string p
+                if map[k] != 0:
+                    finish = False
+                    break
+            
+            if i >= len(p) - 1 and finish:
+                res.append(j)
+            
+            i += 1
+        
+        return res

src/main/python/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.py

@@ -0,0 +1,35 @@
+438\. Find All Anagrams in a String
+
+Medium
+
+Given two strings `s` and `p`, return _an array of all the start indices of_ `p`_'s anagrams in_ `s`. You may return the answer in **any order**.
+
+An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+**Example 1:**
+
+**Input:** s = "cbaebabacd", p = "abc"
+
+**Output:** [0,6]
+
+**Explanation:**
+
+    The substring with start index = 0 is "cba", which is an anagram of "abc".
+    The substring with start index = 6 is "bac", which is an anagram of "abc". 
+
+**Example 2:**
+
+**Input:** s = "abab", p = "ab"
+
+**Output:** [0,1,2]
+
+**Explanation:**
+
+    The substring with start index = 0 is "ab", which is an anagram of "ab".
+    The substring with start index = 1 is "ba", which is an anagram of "ab".
+    The substring with start index = 2 is "ab", which is an anagram of "ab". 
+
+**Constraints:**
+
+*   <code>1 <= s.length, p.length <= 3 * 10<sup>4</sup></code>
+*   `s` and `p` consist of lowercase English letters.

src/main/python/g0401_0500/s0438_find_all_anagrams_in_a_string/readme.md

@@ -0,0 +1,30 @@
+# #Medium #Array #Dynamic_Programming #Backtracking #Big_O_Time_O(n*(sum+s))_Space_O(n*(sum+s))
+# #2024_06_07_Time_105_ms_(86.96%)_Space_16.7_MB_(80.93%)
+
+class Solution:
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        total_sum = sum(nums)
+        s = abs(target)
+        
+        # Invalid s, just return 0
+        if s > total_sum or (total_sum + s) % 2 != 0:
+            return 0
+        
+        target = (total_sum + s) // 2
+        dp = [[0] * (len(nums) + 1) for _ in range(target + 1)]
+        dp[0][0] = 1
+        
+        # empty knapsack must be processed specially
+        for i in range(len(nums)):
+            if nums[i] == 0:
+                dp[0][i + 1] = dp[0][i] * 2
+            else:
+                dp[0][i + 1] = dp[0][i]
+        
+        for i in range(1, target + 1):
+            for j in range(len(nums)):
+                dp[i][j + 1] += dp[i][j]
+                if nums[j] <= i:
+                    dp[i][j + 1] += dp[i - nums[j]][j]
+        
+        return dp[target][len(nums)]

src/main/python/g0401_0500/s0494_target_sum/Solution.py

@@ -0,0 +1,39 @@
+494\. Target Sum
+
+Medium
+
+You are given an integer array `nums` and an integer `target`.
+
+You want to build an **expression** out of nums by adding one of the symbols `'+'` and `'-'` before each integer in nums and then concatenate all the integers.
+
+*   For example, if `nums = [2, 1]`, you can add a `'+'` before `2` and a `'-'` before `1` and concatenate them to build the expression `"+2-1"`.
+
+Return the number of different **expressions** that you can build, which evaluates to `target`.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1,1,1], target = 3
+
+**Output:** 5
+
+**Explanation:**
+
+    There are 5 ways to assign symbols to make the sum of nums be target 3.
+    -1 + 1 + 1 + 1 + 1 = 3
+    +1 - 1 + 1 + 1 + 1 = 3
+    +1 + 1 - 1 + 1 + 1 = 3
+    +1 + 1 + 1 - 1 + 1 = 3
+    +1 + 1 + 1 + 1 - 1 = 3 
+
+**Example 2:**
+
+**Input:** nums = [1], target = 1
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 20`
+*   `0 <= nums[i] <= 1000`
+*   `0 <= sum(nums[i]) <= 1000`
+*   `-1000 <= target <= 1000`

src/main/python/g0401_0500/s0494_target_sum/readme.md

@@ -0,0 +1,26 @@
+# #Easy #Top_100_Liked_Questions #Depth_First_Search #Tree #Binary_Tree #Level_2_Day_7_Tree
+# #Udemy_Tree_Stack_Queue #Big_O_Time_O(n)_Space_O(n)
+# #2024_06_07_Time_51_ms_(36.84%)_Space_19.2_MB_(86.39%)
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def __init__(self):
+        self.diameter = 0
+
+    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        self.diameter = 0
+        self.diameterOfBinaryTreeUtil(root)
+        return self.diameter
+
+    def diameterOfBinaryTreeUtil(self, root: TreeNode) -> int:
+        if root is None:
+            return 0
+        leftLength = 1 + self.diameterOfBinaryTreeUtil(root.left) if root.left else 0
+        rightLength = 1 + self.diameterOfBinaryTreeUtil(root.right) if root.right else 0
+        self.diameter = max(self.diameter, leftLength + rightLength)
+        return max(leftLength, rightLength)