Longest Subarray having sum of elements atmost ‘k’

Given an array of integers, our goal is to find the length of the largest subarray having the sum of its elements at most ‘k’ where k>0.

Examples:

Input : arr[] = {1, 2, 1, 0, 1, 1, 0}, k = 4
Output : 5
Explanation:
 {1, 2, 1} => sum = 4, length = 3
 {1, 2, 1, 0}, {2, 1, 0, 1} => sum = 4, length = 4
 {1, 0, 1, 1, 0} =>5 sum = 3, length = 5

Method 1 (Brute Force): Find all the subarrays whose sum is less than or equal to k and return the one with the largest length. 

C++

// A C++ program to find longest subarray with
// sum of elements at-least k.
#include <bits/stdc++.h>
using namespace std;

// function to find the length of largest subarray
// having sum atmost k.
int atMostSum(int arr[], int n, int k)
{
    int result = INT_MIN;

    for (int i = 0; i < n; i++) {
        int sum = 0;

        for (int j = i; j < n; j++) {
            sum += arr[j];

            if (sum <= k) {
                result = max(result, (j - i + 1));
            }
            else {
                break;
            }
        }
    }

    return result;
}

// Driver function
int main()
{
    int arr[] = { 1, 2, 1, 0, 1, 1, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 4;

    int result = atMostSum(arr, n, k);

    if (result == INT_MIN) {
        cout << "No such subarray found";
    }
    else {
        cout << "The length of largest subarray having sum "
                "atmost k: "
             << result << endl;
    }
    return 0;
}

Java

import java.util.Arrays;

class Main
{

  // function to find the length of largest subarray
  // having sum atmost k.
  public static int atMostSum(int[] arr, int n, int k)
  {
    int result = Integer.MIN_VALUE;

    // Iterate over the array
    for (int i = 0; i < n; i++) {
      int sum = 0;

      // Find sum of every subarray
      for (int j = i; j < n; j++) {
        sum += arr[j];

        // Check if sum of subarray is at least k
        if (sum <= k) {

          // Maximise the result
          result = Math.max(result, (j - i + 1));
        }
        else {
          break;
        }
      }
    }

    // Return the result
    return result;
  }

  public static void main(String[] args)
  {
    int[] arr = { 1, 2, 1, 0, 1, 1, 0 };
    int n = arr.length;
    int k = 4;

    int result = atMostSum(arr, n, k);

    if (result == Integer.MIN_VALUE) {
      System.out.println("No such subarray found");
    }
    else {
      System.out.println(
        "The length of largest subarray having sum "
        + "atmost k: " + result);
    }
  }
}

// This code is contributed by divya_p123.

Python3

# Python program to find the length of the largest subarray
# having sum at most k

def atMostSum(arr, n, k):
    result = float('-inf') # initialize result with negative infinity

    # Iterate over the array
    for i in range(n):
        sum = 0 # initialize the sum for each subarray
        # Find sum of every subarray
        for j in range(i, n):
            sum += arr[j] # add the current element to the sum
            # Check if sum of subarray is at most k
            if sum <= k:
                # Maximize the result
                result = max(result, (j - i + 1))
            else:
                break # if sum becomes greater than k, break the loop
    # Return the result
    return result

# Driver code
arr = [1, 2, 1, 0, 1, 1, 0]
n = len(arr)
k = 4
result = atMostSum(arr, n, k)

if result == float('-inf'):
    print("No such subarray found")
else:
    print("The length of largest subarray having sum at most k:", result)

C#

using System;

class Gfg {
    // Function to find the length of largest subarray
    // having sum at most k
    public static int AtMostSum(int[] arr, int n, int k)
    {
        int result = int.MinValue;

        // Iterate over the array
        for (int i = 0; i < n; i++) {
            int sum = 0;

            // Find sum of every subarray
            for (int j = i; j < n; j++) {
                sum += arr[j];

                // Check if sum of subarray is at most k
                if (sum <= k) {
                    // Maximize the result
                    result = Math.Max(result, (j - i + 1));
                }
                else {
                    break;
                }
            }
        }

        // Return the result
        return result;
    }

    public static void Main(string[] args)
    {
        int[] arr = { 1, 2, 1, 0, 1, 1, 0 };
        int n = arr.Length;
        int k = 4;

        int result = AtMostSum(arr, n, k);

        if (result == int.MinValue) {
            Console.WriteLine("No such subarray found");
        }
        else {
            Console.WriteLine(
                "The length of largest subarray having sum at most k: "
                + result);
        }
    }
}

Javascript

// JavaScript program to find the length of the largest subarray
// having sum at most k

function atMostSum(arr, n, k) {
    let result = -Infinity; // initialize result with negative infinity

    // Iterate over the array
    for (let i = 0; i < n; i++)
    {
        let sum = 0; // initialize the sum for each subarray
        // Find sum of every subarray
        for (let j = i; j < n; j++)
        {
            sum += arr[j]; // add the current element to the sum
            // Check if sum of subarray is at most k
            if (sum <= k)
            {

                // Maximize the result
                result = Math.max(result, (j - i + 1));
            } else {
                break; // if sum becomes greater than k, break the loop
            }
        }
    }

    // Return the result
    return result;
}

// Driver code
let arr = [1, 2, 1, 0, 1, 1, 0];
let n = arr.length;
let k = 4;
let result = atMostSum(arr, n, k);

if (result == -Infinity) {
    console.log("No such subarray found");
} else {
    console.log("The length of largest subarray having sum at most k:", result);
}

// This code is contributed by Prajwal Kandekar

Output

The length of largest subarray having sum atmost k: 5

Time Complexity : O(n^2) 
Auxiliary space: O(1)

Method 2 (Efficient): An efficient approach is to use the sliding window technique. 

1. Traverse the array and check if on adding the current element its sum is less than or equal to k.
2. If it’s less than k then add it to the sum and increase the count.
3. Keep track of Maximum count.

Implementation:

C++

// A C++ program to find longest subarray with
// sum of elements at-least k.
#include <bits/stdc++.h>
using namespace std;

// function to find the length of largest subarray
// having sum atmost k.
int atMostSum(int arr[], int n, int k)
{
    int sum = 0;
    int cnt = 0, maxcnt = 0;

    for (int i = 0; i < n; i++) {

        // If adding current element doesn't
        // cross limit add it to current window
        if ((sum + arr[i]) <= k) {
            sum += arr[i];
            cnt++;
        }

        // Else, remove first element of current
        // window and add the current element
        else if(sum!=0)
        {
            sum = sum - arr[i - cnt] + arr[i];
        }

        // keep track of max length.
        maxcnt = max(cnt, maxcnt);
    }
    return maxcnt;
}

// Driver function
int main()
{
    int arr[] = {1, 2, 1, 0, 1, 1, 0};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 4;

    cout << atMostSum(arr, n, k);
    return 0;
}

Java

// Java program to find longest subarray with
// sum of elements at-least k.
import java.util.*;

class GFG {

    // function to find the length of largest
    // subarray having sum atmost k.
    public static int atMostSum(int arr[], int n,
                                        int k)
    {
        int sum = 0;
        int cnt = 0, maxcnt = 0;

        for (int i = 0; i < n; i++) {

            // If adding current element doesn't
            // cross limit add it to current window
            if ((sum + arr[i]) <= k) {
                sum += arr[i];
                cnt++;
            }

            // Else, remove first element of current
            // window.
            else if(sum!=0)
           {
            sum = sum - arr[i - cnt] + arr[i];
           }

            // keep track of max length.
            maxcnt = Math.max(cnt, maxcnt);
        }
        return maxcnt;
    }

    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 1, 0, 1, 1, 0 };
        int n = arr.length;
        int k = 4;

        System.out.print(atMostSum(arr, n, k));

    }
}
// This code is contributed by Arnav Kr. Mandal.

Python3

# Python3 program to find longest subarray
# with sum of elements at-least k.

# function to find the length of largest
# subarray having sum atmost k.
def atMostSum(arr, n, k):
    _sum = 0
    cnt = 0
    maxcnt = 0

    for i in range(n):

        # If adding current element doesn't
        # Cross limit add it to current window
        if ((_sum + arr[i]) <= k):
            _sum += arr[i]
            cnt += 1

        # Else, remove first element of current
        # window and add the current element
        else if(sum != 0):
            _sum = _sum - arr[i - cnt] + arr[i]

        # keep track of max length.
        maxcnt = max(cnt, maxcnt)

    return maxcnt

# Driver function
arr = [1, 2, 1, 0, 1, 1, 0]
n = len(arr)
k = 4
print(atMostSum(arr, n, k))

# This code is contributed by "Abhishek Sharma 44"

C#

// C# program to find longest subarray
// with sum of elements at-least k.
using System;

class GFG {

    // function to find the length of largest
    // subarray having sum atmost k.
    public static int atMostSum(int []arr, int n,
                                           int k)
    {
        int sum = 0;
        int cnt = 0, maxcnt = 0;

        for (int i = 0; i < n; i++) {

            // If adding current element doesn't
            // cross limit add it to current window
            if ((sum + arr[i]) <= k) {
                sum += arr[i];
                cnt++;
            }

            // Else, remove first element
            // of current window.
            else if(sum!=0)
            {
                sum = sum - arr[i - cnt] + arr[i];
            }

            // keep track of max length.
            maxcnt = Math.Max(cnt, maxcnt);
        }
        return maxcnt;
    }

    // Driver Code
    public static void Main()
    {
        int []arr = {1, 2, 1, 0, 1, 1, 0};
        int n = arr.Length;
        int k = 4;

        Console.Write(atMostSum(arr, n, k));

    }
}

// This code is contributed by Nitin Mittal

PHP

<?php
// A PHP program to find longest
// subarray with sum of elements
// at-least k.

// function to find the length
// of largest subarray having
// sum atmost k.
function atMostSum(&$arr, $n, $k)
{
    $sum = 0;
    $cnt = 0;
    $maxcnt = 0;

    for($i = 0; $i < $n; $i++)
    {
        // If adding current element
        // doesn't cross limit add
        // it to current window
        if (($sum + $arr[$i]) <= $k)
        {
            $sum += $arr[$i] ;
            $cnt += 1 ;
        }

        // Else, remove first element
        // of current window and add
        // the current element
        else if($sum != 0)
            $sum = $sum - $arr[$i - $cnt] +
                               $arr[$i];

        // keep track of max length.
        $maxcnt = max($cnt, $maxcnt);
    }
    return $maxcnt;
}

// Driver Code
$arr = array(1, 2, 1, 0, 1, 1, 0);
$n = sizeof($arr);
$k = 4;

print(atMostSum($arr, $n, $k));

// This code is contributed
// by ChitraNayal
?>

Javascript

<script>
// A Javascript program to find longest subarray with
// sum of elements at-least k.

// function to find the length of largest subarray
// having sum atmost k.
function atMostSum(arr, n, k)
{
    let sum = 0;
    let cnt = 0, maxcnt = 0;

    for (let i = 0; i < n; i++) {

        // If adding current element doesn't
        // cross limit add it to current window
        if ((sum + arr[i]) <= k) {
            sum += arr[i];
            cnt++;
        }

        // Else, remove first element of current
        // window and add the current element
        else if(sum!=0)
        {
            sum = sum - arr[i - cnt] + arr[i];
        }

        // keep track of max length.
        maxcnt = Math.max(cnt, maxcnt);
    }
    return maxcnt;
}

// Driver function
    let arr = [1, 2, 1, 0, 1, 1, 0];
    let n = arr.length;
    let k = 4;

    document.write(atMostSum(arr, n, k));

</script>

Output

5

Time Complexity : O(n), where n represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

This article is contributed by Kshitiz gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.