From 98998132815600d1dc89dd84eb35bee0731fbc82 Mon Sep 17 00:00:00 2001 From: Prad Nukala Date: Thu, 1 Oct 2026 16:40:53 -0400 Subject: [PATCH] feat(work): add solutions for problems 42, 209, and 34 --- work/1/Hard/Array/42.trapping-rain-water.py | 56 ++++++++++++++++ .../Array/209.minimum-size-subarray-sum.py | 63 ++++++++++++++++++ ...ast-position-of-element-in-sorted-array.py | 65 +++++++++++++++++++ 3 files changed, 184 insertions(+) create mode 100644 work/1/Hard/Array/42.trapping-rain-water.py create mode 100644 work/1/Medium/Array/209.minimum-size-subarray-sum.py create mode 100644 work/1/Medium/Array/34.find-first-and-last-position-of-element-in-sorted-array.py diff --git a/work/1/Hard/Array/42.trapping-rain-water.py b/work/1/Hard/Array/42.trapping-rain-water.py new file mode 100644 index 0000000..1a033ee --- /dev/null +++ b/work/1/Hard/Array/42.trapping-rain-water.py @@ -0,0 +1,56 @@ +""" +42. Trapping Rain Water +Difficulty: Hard +https://leetcode.com/problems/trapping-rain-water/ + +────────────────────────────────────────────────── + +Given n non-negative integers representing an elevation map where the +width of each bar is 1, compute how much water it can trap after +raining. + + + +Example 1: + +Input: height = [0,1,0,2,1,0,1,3,2,1,2,1] +Output: 6 +Explanation: The above elevation map (black section) is represented +by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain +water (blue section) are being trapped. + +Example 2: + +Input: height = [4,2,0,3,2,5] +Output: 9 + + + +Constraints: + + • n == height.length + + • 1 <= n <= 2 * 10^4 + + • 0 <= height[i] <= 10^5 +""" + + +class Solution: + def trap(self, height: list[int]) -> int: + left, right = 0, len(height) - 1 + leftMax, rightMax = 0, 0 + total = 0 + + while left < right: + leftMax = max(leftMax, height[left]) + rightMax = max(rightMax, height[right]) + + if height[left] < height[right]: + total += leftMax - height[left] + left += 1 + else: + total += rightMax - height[right] + right -= 1 + + return total diff --git a/work/1/Medium/Array/209.minimum-size-subarray-sum.py b/work/1/Medium/Array/209.minimum-size-subarray-sum.py new file mode 100644 index 0000000..79be845 --- /dev/null +++ b/work/1/Medium/Array/209.minimum-size-subarray-sum.py @@ -0,0 +1,63 @@ +""" +209. Minimum Size Subarray Sum +Difficulty: Medium +https://leetcode.com/problems/minimum-size-subarray-sum/ + +────────────────────────────────────────────────── + +Given an array of positive integers nums and a positive integer +target, return the minimal length of a subarray whose sum is greater +than or equal to target. If there is no such subarray, return 0 +instead. + + + +Example 1: + +Input: target = 7, nums = [2,3,1,2,4,3] +Output: 2 +Explanation: The subarray [4,3] has the minimal length under the +problem constraint. + +Example 2: + +Input: target = 4, nums = [1,4,4] +Output: 1 + +Example 3: + +Input: target = 11, nums = [1,1,1,1,1,1,1,1] +Output: 0 + + + +Constraints: + + • 1 <= target <= 10^9 + + • 1 <= nums.length <= 10^5 + + • 1 <= nums[i] <= 10^4 + + + +Follow up: If you have figured out the O(n) solution, try coding +another solution of which the time complexity is O(n log(n)). +""" + + +class Solution: + def minSubArrayLen(self, target: int, nums: list[int]) -> int: + window_sum = 0 + length = len(nums) + 1 + left = 0 + + for right in range(len(nums)): + window_sum += nums[right] + while window_sum >= target: + length = min(length, right - left + 1) + window_sum -= nums[left] + left += 1 + if length > len(nums): + return 0 + return length diff --git a/work/1/Medium/Array/34.find-first-and-last-position-of-element-in-sorted-array.py b/work/1/Medium/Array/34.find-first-and-last-position-of-element-in-sorted-array.py new file mode 100644 index 0000000..6d562e9 --- /dev/null +++ b/work/1/Medium/Array/34.find-first-and-last-position-of-element-in-sorted-array.py @@ -0,0 +1,65 @@ +""" +34. Find First and Last Position of Element in Sorted Array +Difficulty: Medium +https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/ + +────────────────────────────────────────────────── + +Given an array of integers nums sorted in non-decreasing order, find +the starting and ending position of a given target value. + +If target is not found in the array, return [-1, -1]. + +You must write an algorithm with O(log n) runtime complexity. + + + +Example 1: + +Input: nums = [5,7,7,8,8,10], target = 8 +Output: [3,4] + +Example 2: + +Input: nums = [5,7,7,8,8,10], target = 6 +Output: [-1,-1] + +Example 3: + +Input: nums = [], target = 0 +Output: [-1,-1] + + + +Constraints: + + • 0 <= nums.length <= 10^5 + + • -10^9 <= nums[i] <= 10^9 + + • nums is a non-decreasing array. + + • -10^9 <= target <= 10^9 +""" + + +class Solution: + def searchRange(self, nums: list[int], target: int) -> list[int]: + def find(first): + result = -1 + left, right = 0, len(nums) - 1 + while left <= right: + mid = (left + right) // 2 + if nums[mid] == target: + result = mid + if first: + right = mid - 1 + else: + left = mid + 1 + elif nums[mid] < target: + left = mid + 1 + else: + right = mid - 1 + return result + + return [find(True), find(False)]