add python solutions for monotonic stack pattern

Author: ashishps1

python/daily-temperatures.md

@@ -0,0 +1,118 @@
+# Daily Temperatures
+Given a list of daily temperatures temperatures, return a list answer such that for each day in the input, answer[i] is the number of days you would have to wait until a warmer temperature. If there is no future day for which this is possible, put 0 instead.
+
+### Constraints:
+- 1 <= temperatures.length <= 10^5
+- 30 <= temperatures[i] <= 100
+
+### Examples
+```javascript
+Input: temperatures = [73,74,75,71,69,72,76,73]
+Output: [1,1,4,2,1,1,0,0]
+
+Input: temperatures = [30,40,50,60]
+Output: [1,1,1,0]
+
+Input: temperatures = [30,60,90]
+Output: [1,1,0]
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+The brute-force approach involves checking every temperature for each day to find the next warmer day. For each day i, scan the remaining days to find the first day where the temperature is higher.
+
+Steps:
+1. For each day i, start a nested loop to search through the following days j > i.
+2. If a day j is found where temperatures[j] > temperatures[i], calculate the difference j - i and store it in the result.
+3. If no warmer day is found, store 0 for that day.
+##### Time Complexity:
+O(n²), where n is the number of days. For each day, we search all the following days, making this approach inefficient for large inputs.
+##### Space Complexity:
+O(n) for storing the result array.
+##### Python Code:
+```python
+def dailyTemperatures(temperatures):
+    n = len(temperatures)
+    answer = [0] * n
+    
+    for i in range(n):
+        for j in range(i + 1, n):
+            if temperatures[j] > temperatures[i]:
+                answer[i] = j - i
+                break
+    
+    return answer
+```
+
+### Approach 2: Stack (Optimal Solution)
+##### Intuition: 
+A more efficient solution can be achieved using a monotonic decreasing stack. The idea is to traverse the array from left to right while maintaining a stack of indices of the temperatures. The stack helps keep track of temperatures that we haven't found a warmer day for yet. When we find a warmer temperature, we calculate the difference in days and store the result.
+
+- The stack stores indices of temperatures in decreasing order.
+- When a warmer temperature is found (i.e., temperatures[i] > temperatures[stack[-1]]), we pop the stack, calculate the difference, and store it in the result array.
+
+Steps:
+1. Initialize an empty stack and an array answer filled with 0's.
+2. Traverse the array from left to right.
+3. For each day i, check if the current temperature is higher than the temperature at the index stored in the stack.
+   - If true, pop the index from the stack, calculate i - stack[-1] as the number of days until a warmer temperature, and update the result.
+   - Repeat until the stack is empty or the temperature at the top of the stack is higher.
+4. Push the current index i onto the stack.
+5. Continue until the array is fully processed.
+### Visualization
+For temperatures = [73, 74, 75, 71, 69, 72, 76, 73]:
+
+```rust
+Start with empty stack.
+
+Step 1: 
+Index 0 (73): No warmer day yet → push 0 onto the stack.
+Stack: [0]
+
+Step 2: 
+Index 1 (74): Warmer than 73 → pop 0, set answer[0] = 1 → push 1 onto the stack.
+Stack: [1]
+
+Step 3: 
+Index 2 (75): Warmer than 74 → pop 1, set answer[1] = 1 → push 2 onto the stack.
+Stack: [2]
+
+...
+
+Final result: [1, 1, 4, 2, 1, 1, 0, 0]
+```
+##### Time Complexity:
+O(n), where n is the number of days. Each index is pushed and popped from the stack at most once.
+##### Space Complexity:
+O(n), for the stack and the result array.
+##### Python Code:
+```python
+def dailyTemperatures(temperatures):
+    n = len(temperatures)
+    answer = [0] * n
+    stack = []
+    
+    for i, temp in enumerate(temperatures):
+        # While the stack is not empty and we have found a warmer temperature
+        while stack and temperatures[stack[-1]] < temp:
+            prev_index = stack.pop()
+            answer[prev_index] = i - prev_index
+        
+        # Push the current index onto the stack
+        stack.append(i)
+    
+    return answer
+```
+### Edge Cases:
+1. Single Element: If the input array has only one element, the result should be [0], since there are no future days.
+2. All Decreasing Temperatures: If the temperatures are in strictly decreasing order, the result will be all 0's because there is no warmer day for any of the elements.
+3. All Increasing Temperatures: The result will be [1, 1, 1, ..., 0] since each day has the next day as a warmer day.
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                        | O(n²)      | O(n)             |
+| Stack (Optimal Solution)                          | O(n)            | O(n)             |
+
+The Stack approach is the most efficient solution, leveraging a monotonic stack to keep track of indices and efficiently calculate the number of days until a warmer temperature. This solution runs in linear time and is optimal for the input size constraints.

python/largest-rectangle-in-histogram.md

@@ -0,0 +1,125 @@
+# Largest Rectangle in Histogram
+Given an array of integers heights representing the histogram's bar heights where the width of each bar is 1, return the area of the largest rectangle in the histogram.
+
+### Constraints:
+- 1 <= heights.length <= 10^5
+- 0 <= heights[i] <= 10^4
+
+### Examples
+```javascript
+Input: heights = [2,1,5,6,2,3]
+Output: 10
+Explanation: The largest rectangle is formed by the bars of heights [5,6] with width 2, giving area 5 * 2 = 10.
+
+Input: heights = [2,4]
+Output: 4
+Explanation: The largest rectangle is the single bar of height 4 with width 1, giving area 4 * 1 = 4.
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+For every bar, we can try to expand the rectangle to the left and right until we hit a bar that is shorter. For each bar, calculate the maximum rectangle that can be formed using that bar as the shortest. This involves calculating the width that extends as far as we can to the left and right for each bar.
+
+Steps:
+1. For each bar at index i, check how far left and right you can extend while maintaining the rectangle height.
+2. For every bar, compute the rectangle area, then return the maximum area found.
+##### Time Complexity:
+O(n²), where n is the number of bars. For each bar, we iterate left and right to find the largest rectangle.
+##### Space Complexity:
+O(1), because we only use a few variables to track the maximum area.
+##### Python Code:
+```python
+def largestRectangleArea(heights):
+    n = len(heights)
+    max_area = 0
+    
+    for i in range(n):
+        height = heights[i]
+        left = i
+        right = i
+        
+        # Extend to the left
+        while left > 0 and heights[left - 1] >= height:
+            left -= 1
+        
+        # Extend to the right
+        while right < n - 1 and heights[right + 1] >= height:
+            right += 1
+        
+        # Calculate area with heights[i] as the smallest bar
+        max_area = max(max_area, height * (right - left + 1))
+    
+    return max_area
+```
+
+### Approach 2: Stack-based Monotonic Approach (Optimal Solution)
+##### Intuition: 
+The brute-force approach is inefficient because we repeatedly scan for the largest rectangle for each bar. Instead, we can optimize the process using a monotonic stack. The idea is to calculate the next smaller bar on both the left and right of each bar in the histogram, as this helps determine the largest possible rectangle that can be formed using each bar.
+
+A monotonic stack can help efficiently keep track of indices of bars in the histogram. As we iterate through the bars:
+- If the current bar is shorter than the bar at the top of the stack, we can calculate the area with the bar at the top as the height.
+- We continue popping from the stack until we find a shorter bar or the stack becomes empty.
+
+Steps:
+1. Initialize an empty stack to store indices of bars and a variable max_area to track the largest area.
+2. Traverse the array of heights.
+3. For each bar:
+   - While the stack is not empty and the current bar is smaller than the bar at the top of the stack:
+     - Pop the top index and calculate the area of the rectangle with the popped height as the smallest bar.
+     - Update max_area with the calculated area.
+4. After the loop, pop remaining bars from the stack and calculate their areas.
+5. Return max_area.
+### Visualization
+For heights = [2, 1, 5, 6, 2, 3]:
+
+```rust
+Stack process:
+- Day 0: 2 → push index 0 to the stack.
+- Day 1: 1 is smaller → pop index 0 (height 2), area = 2 × 1 → max_area = 2 → push index 1.
+- Day 2: 5 → push index 2 to the stack.
+- Day 3: 6 → push index 3 to the stack.
+- Day 4: 2 is smaller → pop index 3 (height 6), area = 6 × 1 → max_area = 6 → pop index 2 (height 5), area = 5 × 2 → max_area = 10 → push index 4.
+- Day 5: 3 → push index 5 to the stack.
+
+Final pops calculate the remaining areas.
+```
+##### Time Complexity:
+O(n), where n is the number of bars. Each bar is pushed and popped from the stack at most once.
+##### Space Complexity:
+O(n), for the stack that stores the indices of bars.
+##### Python Code:
+```python
+def largestRectangleArea(heights):
+    stack = []
+    max_area = 0
+    n = len(heights)
+    
+    for i in range(n):
+        while stack and heights[stack[-1]] > heights[i]:
+            h = heights[stack.pop()]
+            width = i if not stack else i - stack[-1] - 1
+            max_area = max(max_area, h * width)
+        stack.append(i)
+    
+    # Calculate areas for remaining bars in the stack
+    while stack:
+        h = heights[stack.pop()]
+        width = n if not stack else n - stack[-1] - 1
+        max_area = max(max_area, h * width)
+    
+    return max_area
+```
+### Edge Cases:
+1. Empty Array: If heights is empty, the largest rectangle area should be 0.
+2. Single Element: If heights has only one bar, the largest rectangle area is the height of that bar.
+3. All Bars of the Same Height: If all bars are the same height, the largest rectangle is the entire histogram with an area of height * number_of_bars.
+4. Decreasing Heights: If the heights are strictly decreasing, the stack will be emptied at each new bar, resulting in the largest rectangle being the first bar.
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                        | O(n²)      | O(1)             |
+| Stack-based Solution (Optimal)                          | O(n)            | O(n)             |
+
+The Stack-based Monotonic approach is the most efficient solution. It processes the bars in linear time by leveraging the stack to compute the largest rectangle that includes each bar as the shortest.

python/next-greater-element-1.md

@@ -0,0 +1,125 @@
+# Next Greater Element I
+You are given two arrays nums1 and nums2 where nums1 is a subset of nums2. For each element in nums1, find the next greater element in nums2. The Next Greater Element of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, return -1 for this number.
+
+### Constraints:
+- 1 <= nums1.length <= 1000
+- 1 <= nums2.length <= 1000
+- 0 <= nums1[i], nums2[i] <= 10^4
+- All elements in nums1 and nums2 are unique.
+- All the elements of nums1 also appear in nums2.
+
+### Examples
+```javascript
+Input: nums1 = [4,1,2], nums2 = [1,3,4,2]
+Output: [-1,3,-1]
+Explanation:
+For 4, there is no next greater number in nums2.
+For 1, the next greater number is 3.
+For 2, there is no next greater number.
+
+Input: nums1 = [2,4], nums2 = [1,2,3,4]
+Output: [3,-1]
+Explanation:
+For 2, the next greater number is 3.
+For 4, there is no next greater number.
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force
+##### Intuition:
+The brute-force solution involves iterating through each element in nums1 and searching for the next greater element in nums2. For each element in nums1, we find its position in nums2, then scan to the right to find the next greater element.
+
+Steps:
+1. For each element in nums1, find its position in nums2.
+2. Start from that position in nums2 and search to the right for the next greater element.
+3. If no greater element is found, return -1 for that element.
+##### Time Complexity:
+O(m * n), where m is the length of nums1 and n is the length of nums2. For each element in nums1, we may have to search through all of nums2.
+##### Space Complexity:
+O(1), as we only need a few variables to track indices and the current next greater element.
+##### Python Code:
+```python
+def nextGreaterElement(nums1, nums2):
+    result = []
+    
+    for num in nums1:
+        found = False
+        for i in range(len(nums2)):
+            if nums2[i] == num:
+                for j in range(i + 1, len(nums2)):
+                    if nums2[j] > num:
+                        result.append(nums2[j])
+                        found = True
+                        break
+                if not found:
+                    result.append(-1)
+                break
+                
+    return result
+```
+
+### Approach 2: Stack with Hash Map (Optimal)
+##### Intuition: 
+The brute-force approach is inefficient because it searches nums2 for the next greater element repeatedly. A more efficient approach is to use a monotonic stack and a hash map. The stack helps us keep track of elements in nums2 for which we haven't yet found the next greater element, and the hash map stores the next greater element for each number.
+
+1. Traverse nums2 from right to left.
+2. Use the stack to find the next greater element for each number:
+   - If the stack is non-empty and the top of the stack is less than or equal to the current number, pop the stack.
+   - The current number's next greater element is at the top of the stack.
+Push the current number onto the stack.
+3. After processing nums2, use the hash map to quickly find the next greater element for each number in nums1.
+
+Steps:
+1. Traverse nums2 from right to left.
+2. Use a stack to maintain the next greater element candidates.
+3. Use a hash map to store the next greater element for each number in nums2.
+4. For each element in nums1, look up the next greater element from the hash map.
+### Visualization
+For nums2 = [1, 3, 4, 2]:
+```rust
+Stack process:
+Start from the rightmost element: 2 → push 2 onto the stack.
+Move to 4 → no elements in the stack are greater than 4 → push 4 onto the stack.
+Move to 3 → next greater element is 4 → push 3 onto the stack.
+Move to 1 → next greater element is 3 → push 1 onto the stack.
+
+Hash map after processing: {2: -1, 4: -1, 3: 4, 1: 3}
+```
+##### Time Complexity:
+O(m + n), where m is the length of nums1 and n is the length of nums2. We traverse nums2 once and process nums1 in constant time using the hash map.
+##### Space Complexity:
+O(n), where n is the length of nums2. The stack and hash map both use space proportional to the size of nums2.
+##### Python Code:
+```python
+def nextGreaterElement(nums1, nums2):
+    # Dictionary to store the next greater element for each number in nums2
+    next_greater = {}
+    stack = []
+    
+    # Traverse nums2 from right to left
+    for num in reversed(nums2):
+        # Pop elements from the stack until we find a greater element or the stack is empty
+        while stack and stack[-1] <= num:
+            stack.pop()
+        
+        # If the stack is not empty, the top of the stack is the next greater element
+        next_greater[num] = stack[-1] if stack else -1
+        
+        # Push the current number onto the stack
+        stack.append(num)
+    
+    # Use the dictionary to find the next greater element for each number in nums1
+    return [next_greater[num] for num in nums1]
+```
+### Edge Cases:
+1. Empty Input: If either nums1 or nums2 is empty, the result should also be an empty list.
+2. No Greater Element: If a number in nums2 does not have a greater element to its right, the result should be -1 for that number.
+3. Single Element: If nums1 or nums2 has a single element, the result will either be -1 or the only element itself.
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                                | O(m * n)      | O(1)             |
+| Stack with Hash Map (Optimal)                          | O(m + n)            | O(n)             |
+
+The Stack with Hash Map approach is the most efficient and optimal solution. It uses a monotonic stack to keep track of elements that are waiting for their next greater element and processes the input arrays in linear time.