# Longest Subarray having sum of elements atmost ‘k’

Given an array of integers, our goal is to find the length of largest subarray having sum of its elements atmost ‘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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

Method 2 (Efficient):
An efficient approach is to use 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 sum and increase the count.
• Else
Remove the first element of subarray and decrease the count.
Again check if on adding the current element its sum is less than or equal to k.
If it’s less than k then add it to sum and increase the count.
3. Keep track of Maximum count.
4. .

## C++

 `// A C++ program to find longest subarray with ` `// sum of elements at-least k. ` `#include ` `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); ` `    ``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 ` `        ``elif``(``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

 ` `

Output:

```5
```

Time Complexity : O(n)

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

My Personal Notes arrow_drop_up

Improved By : nitin mittal, chitranayal

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.