# Length of longest subarray having sum in given range [L, R]

• Last Updated : 17 Dec, 2021

Given an array arr[] of N integers, find the length of the longest subarray having sum in the range [L, R].

Examples:

Input: arr[] = {1, 4, 6}, L = 3, R = 8
Output: 2
Explanation: The valid subarrays with there sum in range [3, 8] are {1, 4}, {4}, {6}. Longest subarray among them is {1, 4} having its length as 2.

Input: arr[] = {15, 2, 4, 8, 9, 5, 10, 23}, L = 10, R = 23
Output: 4

Approach: The given problem can be solved using the sliding window technique. Initially, create a window from the starting elements of the array such that its sum is greater than L. Maintain two variables i and j representing the starting and the ending index of the current window. If the sum of the current window is more than R, increment the value of i and if the sum is less than L, increment the value of j. For the windows with their sum in the range [L, R], maintain their maximum length in a variable len, which is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach``#include ``using` `namespace` `std;` `// Function to find the length of``// the longest subarray having its``// sum in the given range [L, R]``int` `largestSubArraySum(``int` `arr[], ``int` `N,``                       ``int` `L, ``int` `R)``{``    ``// Store sum of current window``    ``int` `sum = 0;` `    ``// Stores indices of current window``    ``int` `i = 0, j = 0;` `    ``// Stores the maximum length``    ``int` `len = 0;` `    ``// Calculating initial window``    ``while` `(sum < L && j < N) {``        ``sum += arr[j];``        ``j++;``    ``}` `    ``// Loop to iterate over all windows``    ``// of having sum in range [L, R]``    ``while` `(i < N && j < N) {` `        ``// If sum of window is less than L``        ``if` `(sum < L) {``            ``sum += arr[j];``            ``j++;``        ``}` `        ``// If sum of window is more than R``        ``else` `if` `(sum > R) {``            ``sum -= arr[i];``            ``i++;``        ``}` `        ``// If sum is in the range [L, R]``        ``else` `{` `            ``// Update length``            ``len = max(len, j - i);``            ``sum += arr[j];``            ``j++;``        ``}``    ``}` `    ``// Return Answer``    ``return` `len;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 15, 2, 4, 8, 9, 5, 10, 23 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `L = 10, R = 23;` `    ``cout << largestSubArraySum(arr, N, L, R);` `    ``return` `0;``}`

## Java

 `// Java program of the above approach``class` `GFG {` `    ``// Function to find the length of``    ``// the longest subarray having its``    ``// sum in the given range [L, R]``    ``static` `int` `largestSubArraySum(``int``[] arr, ``int` `N, ``int` `L,``                                  ``int` `R)``    ``{``        ``// Store sum of current window``        ``int` `sum = ``0``;` `        ``// Stores indices of current window``        ``int` `i = ``0``, j = ``0``;` `        ``// Stores the maximum length``        ``int` `len = ``0``;` `        ``// Calculating initial window``        ``while` `(sum < L && j < N) {``            ``sum += arr[j];``            ``j++;``        ``}` `        ``// Loop to iterate over all windows``        ``// of having sum in range [L, R]``        ``while` `(i < N && j < N) {` `            ``// If sum of window is less than L``            ``if` `(sum < L) {``                ``sum += arr[j];``                ``j++;``            ``}` `            ``// If sum of window is more than R``            ``else` `if` `(sum > R) {``                ``sum -= arr[i];``                ``i++;``            ``}` `            ``// If sum is in the range [L, R]``            ``else` `{` `                ``// Update length``                ``len = Math.max(len, j - i);``                ``sum += arr[j];``                ``j++;``            ``}``        ``}` `        ``// Return Answer``        ``return` `len;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int``[] arr = { ``15``, ``2``, ``4``, ``8``, ``9``, ``5``, ``10``, ``23` `};``        ``int` `N = arr.length;``        ``int` `L = ``10``, R = ``23``;` `        ``System.out.println(largestSubArraySum(arr, N, L, R));``    ``}``}` `// This code is contributed by Saurabh Jaiswal`

## Python3

 `# Python 3 program of the above approach` `# Function to find the length of``# the longest subarray having its``# sum in the given range [L, R]``def` `largestSubArraySum(arr, N, L, R):` `    ``# Store sum of current window``    ``sum` `=` `0` `    ``# Stores indices of current window``    ``i ``=` `0``    ``j ``=` `0` `    ``# Stores the maximum length``    ``len` `=` `0` `    ``# Calculating initial window``    ``while` `(``sum` `< L ``and` `j < N):``        ``sum` `+``=` `arr[j]``        ``j ``+``=` `1` `    ``# Loop to iterate over all windows``    ``# of having sum in range [L, R]``    ``while` `(i < N ``and` `j < N):` `        ``# If sum of window is less than L``        ``if` `(``sum` `< L):``            ``sum` `+``=` `arr[j]``            ``j ``+``=` `1` `        ``# If sum of window is more than R``        ``elif` `(``sum` `> R):``            ``sum` `-``=` `arr[i]``            ``i ``+``=` `1` `        ``# If sum is in the range [L, R]``        ``else``:` `            ``# Update length``            ``len` `=` `max``(``len``, j ``-` `i)``            ``sum` `+``=` `arr[j]``            ``j ``+``=` `1` `    ``# Return Answer``    ``return` `len` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``15``, ``2``, ``4``, ``8``, ``9``, ``5``, ``10``, ``23``]``    ``N ``=` `len``(arr)``    ``L ``=` `10``    ``R ``=` `23` `    ``print``(largestSubArraySum(arr, N, L, R))` `    ``# This code is contributed by gaurav01.`

## C#

 `// C# program of the above approach``using` `System;``class` `GFG {` `    ``// Function to find the length of``    ``// the longest subarray having its``    ``// sum in the given range [L, R]``    ``static` `int` `largestSubArraySum(``int``[] arr, ``int` `N, ``int` `L,``                                  ``int` `R)``    ``{``        ``// Store sum of current window``        ``int` `sum = 0;` `        ``// Stores indices of current window``        ``int` `i = 0, j = 0;` `        ``// Stores the maximum length``        ``int` `len = 0;` `        ``// Calculating initial window``        ``while` `(sum < L && j < N) {``            ``sum += arr[j];``            ``j++;``        ``}` `        ``// Loop to iterate over all windows``        ``// of having sum in range [L, R]``        ``while` `(i < N && j < N) {` `            ``// If sum of window is less than L``            ``if` `(sum < L) {``                ``sum += arr[j];``                ``j++;``            ``}` `            ``// If sum of window is more than R``            ``else` `if` `(sum > R) {``                ``sum -= arr[i];``                ``i++;``            ``}` `            ``// If sum is in the range [L, R]``            ``else` `{` `                ``// Update length``                ``len = Math.Max(len, j - i);``                ``sum += arr[j];``                ``j++;``            ``}``        ``}` `        ``// Return Answer``        ``return` `len;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 15, 2, 4, 8, 9, 5, 10, 23 };``        ``int` `N = arr.Length;``        ``int` `L = 10, R = 23;` `        ``Console.WriteLine(largestSubArraySum(arr, N, L, R));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output
`4`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up