Skip to content
Related Articles

Related Articles

Longest sub-array having sum k

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 28 Jul, 2022

Given an array arr[] of size n containing integers. The problem is to find the length of the longest sub-array having sum equal to the given value k.

Examples: 

Input : arr[] = { 10, 5, 2, 7, 1, 9 }, 
            k = 15
Output : 4
The sub-array is {5, 2, 7, 1}.

Input : arr[] = {-5, 8, -14, 2, 4, 12},
            k = -5
Output : 5

Naive Approach: Consider the sum of all the sub-arrays and return the length of the longest sub-array having sum ‘k’. Time Complexity is of O(n^2).

Efficient Approach: 

Following are the steps:

  1. Initialize sum = 0 and maxLen = 0.
  2. Create a hash table having (sum, index) tuples.
  3. For i = 0 to n-1, perform the following steps:
    1. Accumulate arr[i] to sum.
    2. If sum == k, update maxLen = i+1.
    3. Check whether sum is present in the hash table or not. If not present, then add it to the hash table as (sum, i) pair.
    4. Check if (sum-k) is present in the hash table or not. If present, then obtain index of (sum-k) from the hash table as index. Now check if maxLen < (i-index), then update maxLen = (i-index).
  4. Return maxLen.

Implementation:

C++




// C++ implementation to find the length
// of longest subarray having sum k
#include <bits/stdc++.h>
using namespace std;
 
// function to find the length of longest
// subarray having sum k
int lenOfLongSubarr(int arr[],
                    int n,
                    int k)
{
 
    // unordered_map 'um' implemented
    // as hash table
    unordered_map<int, int> um;
    int sum = 0, maxLen = 0;
 
    // traverse the given array
    for (int i = 0; i < n; i++) {
 
        // accumulate sum
        sum += arr[i];
 
        // when subarray starts from index '0'
        if (sum == k)
            maxLen = i + 1;
 
        // make an entry for 'sum' if it is
        // not present in 'um'
        if (um.find(sum) == um.end())
            um[sum] = i;
 
        // check if 'sum-k' is present in 'um'
        // or not
        if (um.find(sum - k) != um.end()) {
 
            // update maxLength
            if (maxLen < (i - um[sum - k]))
                maxLen = i - um[sum - k];
        }
    }
 
    // required maximum length
    return maxLen;
}
 
// Driver Code
int main()
{
    int arr[] = {10, 5, 2, 7, 1, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 15;
    cout << "Length = "
         << lenOfLongSubarr(arr, n, k);
    return 0;
}

Java




// Java implementation to find the length
// of longest subarray having sum k
import java.io.*;
import java.util.*;
 
class GFG {
 
      // function to find the length of longest
      // subarray having sum k
      static int lenOfLongSubarr(int[] arr, int n, int k)
      {
             // HashMap to store (sum, index) tuples
             HashMap<Integer, Integer> map = new HashMap<>();
             int sum = 0, maxLen = 0;
 
             // traverse the given array
             for (int i = 0; i < n; i++) {
                 
                  // accumulate sum
                  sum += arr[i];
                 
                  // when subarray starts from index '0'
                  if (sum == k)
                      maxLen = i + 1;
 
                  // make an entry for 'sum' if it is
                  // not present in 'map'
                  if (!map.containsKey(sum)) {
                      map.put(sum, i);
                  }
 
                  // check if 'sum-k' is present in 'map'
                  // or not
                  if (map.containsKey(sum - k)) {
                       
                      // update maxLength
                      if (maxLen < (i - map.get(sum - k)))
                          maxLen = i - map.get(sum - k);
                  }
             }
              
             return maxLen;            
      }
 
      // Driver code
      public static void main(String args[])
      {
             int[] arr = {10, 5, 2, 7, 1, 9};
             int n = arr.length;
             int k = 15;
             System.out.println("Length = " +
                                lenOfLongSubarr(arr, n, k));
      }
}
 
// This code is contributed by rachana soma

Python3




# Python3 implementation to find the length
# of longest subArray having sum k
 
# function to find the longest
# subarray having sum k
def lenOfLongSubarr(arr, n, k):
 
    # dictionary mydict implemented
    # as hash map
    mydict = dict()
 
    # Initialize sum and maxLen with 0
    sum = 0
    maxLen = 0
 
    # traverse the given array
    for i in range(n):
 
        # accumulate the sum
        sum += arr[i]
 
        # when subArray starts from index '0'
        if (sum == k):
            maxLen = i + 1
 
        # check if 'sum-k' is present in
        # mydict or not
        elif (sum - k) in mydict:
            maxLen = max(maxLen, i - mydict[sum - k])
 
        # if sum is not present in dictionary
        # push it in the dictionary with its index
        if sum not in mydict:
            mydict[sum] = i
 
    return maxLen
 
# Driver Code
if __name__ == '__main__':
    arr = [10, 5, 2, 7, 1, 9]
    n = len(arr)
    k = 15
    print("Length =", lenOfLongSubarr(arr, n, k))
 
# This code is contributed by
# chaudhary_19 (Mayank Chaudhary)

C#




// C# implementation to find the length
// of longest subarray having sum k
using System;
using System.Collections.Generic;
 
class GFG
{
 
// function to find the length of longest
// subarray having sum k
static int lenOfLongSubarr(int[] arr,
                           int n, int k)
{
    // HashMap to store (sum, index) tuples
    Dictionary<int,
               int> map = new Dictionary<int,
                                         int>();
    int sum = 0, maxLen = 0;
 
    // traverse the given array
    for (int i = 0; i < n; i++)
    {
         
        // accumulate sum
        sum += arr[i];
         
        // when subarray starts from index '0'
        if (sum == k)
            maxLen = i + 1;
 
        // make an entry for 'sum' if it is
        // not present in 'map'
        if (!map.ContainsKey(sum))
        {
            map.Add(sum, i);
        }
 
        // check if 'sum-k' is present in 'map'
        // or not
        if (map.ContainsKey(sum - k))
        {
                 
            // update maxLength
            if (maxLen < (i - map[sum - k]))
                maxLen = i - map[sum - k];
        }
    }
     
    return maxLen;        
}
 
// Driver code
public static void Main()
{
    int[] arr = {10, 5, 2, 7, 1, 9};
    int n = arr.Length;
    int k = 15;
    Console.WriteLine("Length = " +
                       lenOfLongSubarr(arr, n, k));
}
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
 
// JavaScript implementation to find the length
// of longest subarray having sum k
 
// function to find the length of longest
// subarray having sum k
function lenOfLongSubarr(arr, n, k)
{
 
    // unordered_map 'um' implemented
    // as hash table
    var um = new Map();
    var sum = 0, maxLen = 0;
 
    // traverse the given array
    for (var i = 0; i < n; i++) {
 
        // accumulate sum
        sum += arr[i];
 
        // when subarray starts from index '0'
        if (sum == k)
            maxLen = i + 1;
 
        // make an entry for 'sum' if it is
        // not present in 'um'
        if (!um.has(sum))
            um.set(sum, i);
 
        // check if 'sum-k' is present in 'um'
        // or not
        if (um.has(sum - k)) {
 
            // update maxLength
            if (maxLen < (i - um.get(sum - k)))
                maxLen = i - um.get(sum - k);
        }
    }
 
    // required maximum length
    return maxLen;
}
 
// Driver Code
var arr = [10, 5, 2, 7, 1, 9];
var n = arr.length;
var k = 15;
document.write( "Length = "
      + lenOfLongSubarr(arr, n, k));
 
</script>

Output

Length = 4

Time Complexity: O(n). 
Auxiliary Space: O(n).

Another Approach

This approach won’t work for negative numbers

The approach is to use the concept of the variable-size sliding window using 2 pointers

Initialize i, j and sum = k .If the sum is less than k just increment j, if the sum is equal to k compute the max

and if the sum is greater than k subtract ith element while the sum is less than k.

Implementation:

C++




// C++ implementation to find the length
// of longest subarray having sum k
#include <bits/stdc++.h>
using namespace std;
 
// function to find the length of longest
// subarray having sum k
int lenOfLongSubarr(int A[], int N, int K)
{
 
    int i = 0, j = 0, sum = 0;
    int maxLen = INT_MIN;
   
    while (j < N) {
        sum += A[j];
        if (sum < K) {
            j++;
        }
        else if (sum == K) {
            maxLen = max(maxLen, j-i+1);
            j++;
        }
        else if (sum > K) {
            while (sum > K) {
                sum -= A[i];
                 i++;
            }
              if(sum == K){
              maxLen = max(maxLen, j-i+1);
            }
            j++;
        }
    }
    return maxLen;
}
 
// Driver Code
int main()
{
    int arr[] = { 10, 5, 2, 7, 1, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 15;
    cout << "Length = " << lenOfLongSubarr(arr, n, k);
    return 0;
}

Java




/*package whatever //do not write package name here */
 
import java.io.*;
 
class GFG {
  // Java implementation to find the length
  // of longest subarray having sum k
 
 
  // function to find the length of longest
  // subarray having sum k
  static int lenOfLongSubarr(int A[], int N, int K)
  {
 
    int i = 0, j = 0, sum = 0;
    int maxLen = Integer.MIN_VALUE;
 
    while (j < N) {
      sum += A[j];
      if (sum < K) {
        j++;
      }
      else if (sum == K) {
        maxLen = Math.max(maxLen, j-i+1);
        j++;
      }
      else if (sum > K) {
        while (sum > K) {
          sum -= A[i];
          i++;
        }
        if(sum == K){
          maxLen = Math.max(maxLen, j-i+1);
        }
        j++;
      }
    }
    return maxLen;
  }
 
 
  // Driver code
  public static void main(String args[])
  {
    int arr[] = { 10, 5, 2, 7, 1, 9 };
    int n = arr.length;
    int k = 15;
    System.out.printf("Length = %d",lenOfLongSubarr(arr, n, k));
  }
}
 
// This code is contributed by shinjanpatra.

Python3




# Python implementation to find the length
# of longest subarray having sum k
 
# function to find the length of longest
# subarray having sum k
import sys
 
def lenOfLongSubarr(A, N, K):
 
    i, j, sum = 0, 0, 0
    maxLen = -sys.maxsize -1
   
    while (j < N):
        sum += A[j]
        if (sum < K):
            j += 1
        elif (sum == K):
            maxLen = max(maxLen, j - i + 1)
            j += 1
        elif (sum > K):
            while (sum > K):
                sum -= A[i]
                i += 1
            if (sum == K):
                  maxLen = max(maxLen, j - i + 1)
            j += 1
    return maxLen
 
# Driver Code
arr = [ 10, 5, 2, 7, 1, 9 ]
n = len(arr)
k = 15
print("Length = "+ str(lenOfLongSubarr(arr, n, k)))
 
# This code is contributed by shinjanpatra

C#




// C# code for the above approach
 
using System;
 
public class GFG {
 
    // function to find the length of longest subarray
    // having sum k
    static int lenOfLongSubarr(int[] A, int N, int K)
    {
 
        int i = 0, j = 0, sum = 0;
        int maxLen = Int32.MinValue;
 
        while (j < N) {
            sum += A[j];
            if (sum < K) {
                j++;
            }
            else if (sum == K) {
                maxLen = Math.Max(maxLen, j - i + 1);
                j++;
            }
            else if (sum > K) {
                while (sum > K) {
                    sum -= A[i];
                    i++;
                }
                if (sum == K) {
                    maxLen = Math.Max(maxLen, j - i + 1);
                }
                j++;
            }
        }
        return maxLen;
    }
 
    static public void Main()
    {
 
        // Code
        int[] arr = { 10, 5, 2, 7, 1, 9 };
        int n = arr.Length;
        int k = 15;
 
        Console.Write("Length = "
                      + lenOfLongSubarr(arr, n, k));
    }
}
 
// This code is contributed by lokesh (lokeshmvs21).

Javascript




<script>
 
// JavaScript implementation to find the length
// of longest subarray having sum k
 
// function to find the length of longest
// subarray having sum k
function lenOfLongSubarr(A, N, K)
{
 
    let i = 0, j = 0, sum = 0;
    let maxLen = Number.MIN_VALUE;
   
    while (j < N) {
        sum += A[j];
        if (sum < K) {
            j++;
        }
        else if (sum == K) {
            maxLen = Math.max(maxLen, j-i+1);
            j++;
        }
        else if (sum > K) {
            while (sum > K) {
                sum -= A[i];
                 i++;
            }
            if(sum == K){
                maxLen = Math.max(maxLen, j-i+1);
            }
            j++;
        }
    }
    return maxLen;
}
 
// Driver Code
 
let arr = [ 10, 5, 2, 7, 1, 9 ]
let n = arr.length
let k = 15
document.write("Length = ",lenOfLongSubarr(arr, n, k))
 
// This code is contributed by shinjanpatra
 
</script>

Output

Length = 4

Time Complexity: O(n). 
Auxiliary Space: O(1).


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!