# Solving Leetcode Interviews in Seconds with AI: Number of Subarrays with Bounded Maximum


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "795" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an integer array nums and two integers left and right, return the number of contiguous non-empty subarrays such that the value of the maximum array element in that subarray is in the range [left, right]. The test cases are generated so that the answer will fit in a 32-bit integer.   Example 1:  Input: nums = [2,1,4,3], left = 2, right = 3 Output: 3 Explanation: There are three subarrays that meet the requirements: [2], [2, 1], [3].  Example 2:  Input: nums = [2,9,2,5,6], left = 2, right = 8 Output: 7    Constraints:  1 <= nums.length <= 105 0 <= nums[i] <= 109 0 <= left <= right <= 109  

	# Explanation
	Here's the breakdown of the solution:

*   **Sliding Window Approach:** The core idea is to use a sliding window technique. We maintain two pointers, `start` and `end`, and iterate through the array. The goal is to count subarrays ending at `end` that satisfy the condition.
*   **Two Cases:** We consider two scenarios: 1) `nums[end]` is within the range `[left, right]`. In this case, all subarrays ending at `end` and starting after the last element exceeding `right` are valid. 2) `nums[end]` is greater than `right`. This resets the valid subarray count.
*   **Efficient Counting:** We need to keep track of the index of the last element that exceeded `right` to calculate the valid subarrays efficiently.

*   **Runtime Complexity:** O(n) & **Storage Complexity:** O(1)

	
	# Code
	```python
	def numSubarrayBoundedMax(nums, left, right):
    """
    Counts the number of contiguous non-empty subarrays such that the value of the maximum
    array element in that subarray is in the range [left, right].

    Args:
        nums (List[int]): The input array of integers.
        left (int): The lower bound of the range.
        right (int): The upper bound of the range.

    Returns:
        int: The number of subarrays that meet the requirements.
    """
    count = 0
    valid_subarray_count = 0
    last_invalid = -1

    for i in range(len(nums)):
        if left <= nums[i] <= right:
            valid_subarray_count = i - last_invalid
            count += valid_subarray_count
        elif nums[i] < left:
            count += valid_subarray_count
        else:
            valid_subarray_count = 0
            last_invalid = i

    return count
	```