Added tasks 53-104

Author: javadev

g0001_0100/s0053_maximum_subarray/readme.md

@@ -0,0 +1,79 @@
+53\. Maximum Subarray
+
+Easy
+
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return _its sum_.
+
+A **subarray** is a **contiguous** part of an array.
+
+**Example 1:**
+
+**Input:** nums = [-2,1,-3,4,-1,2,1,-5,4]
+
+**Output:** 6
+
+**Explanation:** [4,-1,2,1] has the largest sum = 6. 
+
+**Example 2:**
+
+**Input:** nums = [1]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** nums = [5,4,-1,7,8]
+
+**Output:** 23 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+**Follow up:** If you have figured out the `O(n)` solution, try coding another solution using the **divide and conquer** approach, which is more subtle.
+
+To solve the Maximum Subarray problem, we can use the Kadane's algorithm, which efficiently finds the maximum subarray sum in linear time. Here are the steps to solve the task:
+
+1. **Initialize Variables:** 
+   - Initialize two variables `max_sum` and `current_sum` to keep track of the maximum sum found so far and the sum of the current subarray, respectively.
+   - Set `max_sum` and `current_sum` to the value of the first element in the array `nums`.
+
+2. **Iterate Through the Array:**
+   - Start iterating through the array `nums` from the second element (index 1).
+   - For each element `num` in `nums`, do the following:
+     - Update `current_sum` to be the maximum of either `num` or `current_sum + num`. This step ensures that we consider either starting a new subarray or extending the current subarray.
+     - Update `max_sum` to be the maximum of either `max_sum` or `current_sum`. This step ensures that we keep track of the maximum subarray sum found so far.
+
+3. **Return the Result:**
+   - After iterating through the entire array, `max_sum` will contain the maximum subarray sum.
+   - Return `max_sum` as the result.
+
+### Python Implementation:
+
+```python
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        # Initialize variables
+        max_sum = current_sum = nums[0]
+
+        # Iterate through the array
+        for num in nums[1:]:
+            current_sum = max(num, current_sum + num)
+            max_sum = max(max_sum, current_sum)
+
+        return max_sum
+
+# Example Usage:
+solution = Solution()
+nums1 = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+print(solution.maxSubArray(nums1))  # Output: 6
+
+nums2 = [1]
+print(solution.maxSubArray(nums2))  # Output: 1
+
+nums3 = [5, 4, -1, 7, 8]
+print(solution.maxSubArray(nums3))  # Output: 23
+```
+
+This algorithm has a time complexity of O(n), where n is the length of the input array `nums`. Therefore, it efficiently finds the maximum subarray sum.

g0001_0100/s0055_jump_game/readme.md

@@ -0,0 +1,72 @@
+55\. Jump Game
+
+Medium
+
+You are given an integer array `nums`. You are initially positioned at the array's **first index**, and each element in the array represents your maximum jump length at that position.
+
+Return `true` _if you can reach the last index, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,1,4]
+
+**Output:** true
+
+**Explanation:** Jump 1 step from index 0 to 1, then 3 steps to the last index. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,1,0,4]
+
+**Output:** false
+
+**Explanation:** You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>
+
+To solve the "Jump Game" problem, you can follow these steps:
+
+1. **Initialize Variables:** Start by initializing a variable `max_reach` to store the maximum reachable index. Initially, set `max_reach` to `0`, as you are at the first index.
+   
+2. **Iterate through the Array:** Traverse through the array `nums` starting from index `0` to `n-1`, where `n` is the length of the array.
+
+3. **Update Maximum Reach:** At each index `i`, update `max_reach` to be the maximum of `max_reach` and `i + nums[i]`. This indicates the farthest index you can reach from the current position `i`.
+
+4. **Check for End Reachability:** While traversing the array, if at any point `max_reach` becomes greater than or equal to the last index (i.e., `n - 1`), return `True`, indicating that you can reach the end of the array.
+
+5. **Handle Zero Reach:** If the current index `i` is greater than `max_reach`, it means you cannot progress further, and thus, return `False`.
+
+6. **Return Result:** After iterating through the entire array, if you haven't reached the end of the array, return `False`, as you cannot reach the last index.
+
+Here's a Python function implementing the above steps:
+
+```python
+from typing import List
+
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        max_reach = 0
+        n = len(nums)
+        
+        for i in range(n):
+            if i > max_reach:
+                return False
+            max_reach = max(max_reach, i + nums[i])
+            if max_reach >= n - 1:
+                return True
+        
+        return False
+
+# Example usage:
+nums1 = [2, 3, 1, 1, 4]
+nums2 = [3, 2, 1, 0, 4]
+
+sol = Solution()
+print(sol.canJump(nums1))  # Output: True
+print(sol.canJump(nums2))  # Output: False
+```
+
+You can then test this function with different input arrays to verify its correctness.

g0001_0100/s0056_merge_intervals/readme.md

@@ -0,0 +1,64 @@
+56\. Merge Intervals
+
+Medium
+
+Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return _an array of the non-overlapping intervals that cover all the intervals in the input_.
+
+**Example 1:**
+
+**Input:** intervals = [[1,3],[2,6],[8,10],[15,18]]
+
+**Output:** [[1,6],[8,10],[15,18]]
+
+**Explanation:** Since intervals [1,3] and [2,6] overlaps, merge them into [1,6]. 
+
+**Example 2:**
+
+**Input:** intervals = [[1,4],[4,5]]
+
+**Output:** [[1,5]]
+
+**Explanation:** Intervals [1,4] and [4,5] are considered overlapping. 
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>
+
+Here are the steps to solve the task using the `Solution` class:
+
+1. Define the `Solution` class with a method named `merge` that takes in a list of intervals.
+2. Inside the `merge` method, sort the intervals based on their start times.
+3. Initialize an empty list called `merged_intervals` to store the merged intervals.
+4. Iterate through the sorted intervals.
+5. For each interval, if the `merged_intervals` list is empty or if the current interval's start time is greater than the end time of the last interval in the `merged_intervals` list, append the current interval to `merged_intervals`.
+6. Otherwise, merge the current interval with the last interval in the `merged_intervals` list by updating the end time of the last interval if the current interval's end time is greater.
+7. After iterating through all intervals, return the `merged_intervals` list.
+
+Here's the implementation:
+
+```python
+from typing import List
+
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        intervals.sort(key=lambda x: x[0])
+        merged_intervals = []
+        
+        for interval in intervals:
+            if not merged_intervals or interval[0] > merged_intervals[-1][1]:
+                merged_intervals.append(interval)
+            else:
+                merged_intervals[-1][1] = max(merged_intervals[-1][1], interval[1])
+        
+        return merged_intervals
+
+# Example usage:
+intervals1 = [[1, 3], [2, 6], [8, 10], [15, 18]]
+intervals2 = [[1, 4], [4, 5]]
+
+sol = Solution()
+print(sol.merge(intervals1))  # Output: [[1, 6], [8, 10], [15, 18]]
+print(sol.merge(intervals2))  # Output: [[1, 5]]
+```

g0001_0100/s0062_unique_paths/readme.md

@@ -0,0 +1,89 @@
+62\. Unique Paths
+
+Medium
+
+A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+How many possible unique paths are there?
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+**Input:** m = 3, n = 7
+
+**Output:** 28 
+
+**Example 2:**
+
+**Input:** m = 3, n = 2
+
+**Output:** 3
+
+**Explanation:**
+
+    From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+    1. Right -> Down -> Down
+    2. Down -> Down -> Right
+    3. Down -> Right -> Down 
+
+**Example 3:**
+
+**Input:** m = 7, n = 3
+
+**Output:** 28 
+
+**Example 4:**
+
+**Input:** m = 3, n = 3
+
+**Output:** 6 
+
+**Constraints:**
+
+*   `1 <= m, n <= 100`
+*   It's guaranteed that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+To solve this task using Python with a `Solution` class, you can follow these steps:
+
+1. Define a class named `Solution`.
+2. Inside the class, define a method named `uniquePaths` that takes `m` and `n` as input parameters.
+3. Implement the logic to calculate the number of unique paths using dynamic programming.
+4. Create a grid of size `m x n` to store the number of unique paths to each cell.
+5. Initialize the first row and first column of the grid to 1, as there is only one way to reach any cell in the first row or column.
+6. Iterate through the grid and calculate the number of unique paths to each cell using the formula `grid[i][j] = grid[i-1][j] + grid[i][j-1]`.
+7. Return the number of unique paths to the bottom-right corner of the grid (`grid[m-1][n-1]`).
+
+Here's the implementation:
+
+```python
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        # Create a grid to store the number of unique paths to each cell
+        grid = [[0] * n for _ in range(m)]
+        
+        # Initialize the first row and first column to 1
+        for i in range(m):
+            grid[i][0] = 1
+        for j in range(n):
+            grid[0][j] = 1
+        
+        # Calculate the number of unique paths to each cell
+        for i in range(1, m):
+            for j in range(1, n):
+                grid[i][j] = grid[i-1][j] + grid[i][j-1]
+        
+        # Return the number of unique paths to the bottom-right corner
+        return grid[m-1][n-1]
+
+# Example usage:
+solution = Solution()
+print(solution.uniquePaths(3, 7))  # Output: 28
+print(solution.uniquePaths(3, 2))  # Output: 3
+print(solution.uniquePaths(7, 3))  # Output: 28
+print(solution.uniquePaths(3, 3))  # Output: 6
+```
+
+This implementation uses dynamic programming to efficiently calculate the number of unique paths. It iterates through the grid only once, so the time complexity is O(m * n), where m is the number of rows and n is the number of columns.

g0001_0100/s0064_minimum_path_sum/readme.md

@@ -0,0 +1,75 @@
+64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = [[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum. 
+
+**Example 2:**
+
+**Input:** grid = [[1,2,3],[4,5,6]]
+
+**Output:** 12 
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`
+
+To solve this task using Python with a `Solution` class, you can follow these steps:
+
+1. Define a class named `Solution`.
+2. Inside the class, define a method named `minPathSum` that takes `grid` as an input parameter.
+3. Implement the logic to calculate the minimum path sum using dynamic programming.
+4. Create a 2D grid of size `m x n` to store the minimum path sum to each cell.
+5. Initialize the first row and first column of the grid with cumulative sums.
+6. Iterate through the grid starting from the second row and second column.
+7. For each cell, update its value to the minimum of the values to its left and above plus the current cell's value.
+8. Return the value in the bottom-right cell of the grid, which represents the minimum path sum.
+
+Here's the implementation:
+
+```python
+class Solution:
+    def minPathSum(self, grid: List[List[int]]) -> int:
+        # Get the dimensions of the grid
+        m, n = len(grid), len(grid[0])
+        
+        # Create a grid to store the minimum path sum to each cell
+        dp = [[0] * n for _ in range(m)]
+        
+        # Initialize the first row and first column
+        dp[0][0] = grid[0][0]
+        for i in range(1, m):
+            dp[i][0] = dp[i-1][0] + grid[i][0]
+        for j in range(1, n):
+            dp[0][j] = dp[0][j-1] + grid[0][j]
+        
+        # Calculate the minimum path sum for each cell
+        for i in range(1, m):
+            for j in range(1, n):
+                dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
+        
+        # Return the minimum path sum in the bottom-right cell
+        return dp[m-1][n-1]
+
+# Example usage:
+solution = Solution()
+print(solution.minPathSum([[1,3,1],[1,5,1],[4,2,1]]))  # Output: 7
+print(solution.minPathSum([[1,2,3],[4,5,6]]))        # Output: 12
+```
+
+This implementation uses dynamic programming to efficiently calculate the minimum path sum. It iterates through the grid only once, so the time complexity is O(m * n), where m is the number of rows and n is the number of columns.