Skip to content
Related Articles

Related Articles

Longest sub-array having sum k
  • Difficulty Level : Hard
  • Last Updated : 24 Sep, 2019

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.

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 contibuted 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 contibuted by PrinciRaj1992


Output:
Length = 4

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :