> For the complete documentation index, see [llms.txt](https://mayanktyagi3111.gitbook.io/interview-prep/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mayanktyagi3111.gitbook.io/interview-prep/strings-arrays-and-2-pointers/number-of-subarrays-with-bounded-maximum.md).

# Number of Subarrays with Bounded Maximum

We are given an array `A` of positive integers, and two positive integers `L` and `R` (`L <= R`).

Return the number of (contiguous, non-empty) subarrays such that the value of the maximum array element in that subarray is at least `L` and at most `R`.

```
Example :
Input: 
A = [2, 1, 4, 3]
L = 2
R = 3
Output: 3
Explanation: There are three subarrays that meet the requirements: [2], [2, 1], [3].
```

**Note:**

* L, R  and `A[i]` will be an integer in the range `[0, 10^9]`.
* The length of `A` will be in the range of `[1, 50000]`.

```java
/*
The condition A[i]>=L && A[i]<=R,means that A[j:i] is a valid subarray and thus we can have (i-j+1) valid subarrays,
count is the valid subarrays between j to i at this point.
The condition A[i]<L means that A[j:i] is still a valid subarray but we need the last element (>=L and <=R) which is within A[j:i],
thus adding last valid number of subarrays which is count.
Else just move the back pointer forward 
*/
class Solution {
    public int numSubarrayBoundedMax(int[] A, int L, int R) {
        int start = 0, count = 0, res = 0;

        for (int end = 0; end < A.length; end++) {
            if (A[end] >= L && A[end] <= R) {
                res += end - start + 1;
                count = end - start + 1;
            } else if (A[end] < L)
                res += count;
            else {
                start = end + 1;
                count = 0;
            }
        }
        return res;
    }
}
```