Related Articles

# Find subarray with given sum | Set 2 (Handles Negative Numbers)

• Difficulty Level : Medium
• Last Updated : 22 Oct, 2021

Given an unsorted array of integers, find a subarray that adds to a given number. If there is more than one subarray with the sum of the given number, print any of them.

Examples:

```Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33
Output: Sum found between indexes 2 and 4
Explanation: Sum of elements between indices
2 and 4 is 20 + 3 + 10 = 33

Input: arr[] = {10, 2, -2, -20, 10}, sum = -10
Output: Sum found between indexes 0 to 3
Explanation: Sum of elements between indices
0 and 3 is 10 + 2 - 2 - 20 = -10

Input: arr[] = {-10, 0, 2, -2, -20, 10}, sum = 20
Output: No subarray with given sum exists
Explanation: There is no subarray with the given sum```

Note: We have discussed a solution that does not handle negative integers here. In this post, negative integers are also handled.

Approach: The idea is to store the sum of elements of every prefix of the array in a hashmap, i.e, every index stores the sum of elements up to that index hashmap. So to check if there is a subarray with a sum equal to s, check for every index i, and sum up to that index as x. If there is a prefix with a sum equal to x – s, then the subarray with the given sum is found.

Algorithm:

1. Create a Hashmap (hm) to store a key-value pair, i.e, key = prefix sum and value = its index, and a variable to store the current sum (sum = 0) and the sum of the subarray as s
2. Traverse through the array from start to end.
3. For every element update the sum, i.e sum = sum + array[i]
4. If the sum is equal to s then print that the subarray with the given sum is from 0 to i
5. If there is any key in the HashMap which is equal to sum – s then print that the subarray with the given sum is from hm[sum – s] to i
6. Put the sum and index in the hashmap as a key-value pair.

Dry-run of the above approach: Implementation:

## C++

 `// C++ program to print subarray with sum as given sum``#include``using` `namespace` `std;` `// Function to print subarray with sum as given sum``void` `subArraySum(``int` `arr[], ``int` `n, ``int` `sum)``{``    ``// create an empty map``    ``unordered_map<``int``, ``int``> map;` `    ``// Maintains sum of elements so far``    ``int` `curr_sum = 0;` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// add current element to curr_sum``        ``curr_sum = curr_sum + arr[i];` `        ``// if curr_sum is equal to target sum``        ``// we found a subarray starting from index 0``        ``// and ending at index i``        ``if` `(curr_sum == sum)``        ``{``            ``cout << ``"Sum found between indexes "``                 ``<< 0 << ``" to "` `<< i << endl;``            ``return``;``        ``}` `        ``// If curr_sum - sum already exists in map``        ``// we have found a subarray with target sum``        ``if` `(map.find(curr_sum - sum) != map.end())``        ``{``            ``cout << ``"Sum found between indexes "``                 ``<< map[curr_sum - sum] + 1``                 ``<< ``" to "` `<< i << endl;``            ``return``;``        ``}` `        ``map[curr_sum] = i;``    ``}` `    ``// If we reach here, then no subarray exists``    ``cout << ``"No subarray with given sum exists"``;``}` `// Driver program to test above function``int` `main()``{``    ``int` `arr[] = {10, 2, -2, -20, 10};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``int` `sum = -10;` `    ``subArraySum(arr, n, sum);` `    ``return` `0;``}`

## Java

 `// Java program to print subarray with sum as given sum``import` `java.util.*;` `class` `GFG {` `    ``public` `static` `void` `subArraySum(``int``[] arr, ``int` `n, ``int` `sum) {``        ``//cur_sum to keep track of cummulative sum till that point``        ``int` `cur_sum = ``0``;``        ``int` `start = ``0``;``        ``int` `end = -``1``;``        ``HashMap hashMap = ``new` `HashMap<>();` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``cur_sum = cur_sum + arr[i];``            ``//check whether cur_sum - sum = 0, if 0 it means``            ``//the sub array is starting from index 0- so stop``            ``if` `(cur_sum - sum == ``0``) {``                ``start = ``0``;``                ``end = i;``                ``break``;``            ``}``            ``//if hashMap already has the value, means we already``            ``// have subarray with the sum - so stop``            ``if` `(hashMap.containsKey(cur_sum - sum)) {``                ``start = hashMap.get(cur_sum - sum) + ``1``;``                ``end = i;``                ``break``;``            ``}``            ``//if value is not present then add to hashmap``            ``hashMap.put(cur_sum, i);` `        ``}``        ``// if end is -1 : means we have reached end without the sum``        ``if` `(end == -``1``) {``            ``System.out.println(``"No subarray with given sum exists"``);``        ``} ``else` `{``            ``System.out.println(``"Sum found between indexes "``                            ``+ start + ``" to "` `+ end);``        ``}` `    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = {``10``, ``2``, -``2``, -``20``, ``10``};``        ``int` `n = arr.length;``        ``int` `sum = -``10``;``        ``subArraySum(arr, n, sum);` `    ``}``}`

## Python3

 `# Python3 program to print subarray with sum as given sum` `# Function to print subarray with sum as given sum``def` `subArraySum(arr, n, ``Sum``):`` ` `    ``# create an empty map``    ``Map` `=` `{}``  ` `    ``# Maintains sum of elements so far``    ``curr_sum ``=` `0``  ` `    ``for` `i ``in` `range``(``0``,n):``     ` `        ``# add current element to curr_sum``        ``curr_sum ``=` `curr_sum ``+` `arr[i]``  ` `        ``# if curr_sum is equal to target sum``        ``# we found a subarray starting from index 0``        ``# and ending at index i``        ``if` `curr_sum ``=``=` `Sum``:``         ` `            ``print``(``"Sum found between indexes 0 to"``, i)``            ``return``         ` `  ` `        ``# If curr_sum - sum already exists in map``        ``# we have found a subarray with target sum``        ``if` `(curr_sum ``-` `Sum``) ``in` `Map``:``         ` `            ``print``(``"Sum found between indexes"``, \``                   ``Map``[curr_sum ``-` `Sum``] ``+` `1``, ``"to"``, i)``            ` `            ``return``  ` `        ``Map``[curr_sum] ``=` `i``  ` `    ``# If we reach here, then no subarray exists``    ``print``(``"No subarray with given sum exists"``)`` ` `  ` `# Driver program to test above function``if` `__name__ ``=``=` `"__main__"``:`` ` `    ``arr ``=` `[``10``, ``2``, ``-``2``, ``-``20``, ``10``]``    ``n ``=` `len``(arr)``    ``Sum` `=` `-``10``  ` `    ``subArraySum(arr, n, ``Sum``)``  ` `# This code is contributed by Rituraj Jain`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// C# program to print subarray with sum as given sum` `public` `class` `GFG``{` `    ``public` `static` `void` `subArraySum(``int``[] arr, ``int` `n, ``int` `sum)``    ``{``        ``//cur_sum to keep track of cummulative sum till that point``        ``int` `cur_sum = 0;``        ``int` `start = 0;``        ``int` `end = -1;``        ``Dictionary<``int``, ``int``> hashMap = ``new` `Dictionary<``int``, ``int``>();` `        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``cur_sum = cur_sum + arr[i];``            ``//check whether cur_sum - sum = 0, if 0 it means``            ``//the sub array is starting from index 0- so stop``            ``if` `(cur_sum - sum == 0)``            ``{``                ``start = 0;``                ``end = i;``                ``break``;``            ``}``            ``//if hashMap already has the value, means we already ``            ``// have subarray with the sum - so stop``            ``if` `(hashMap.ContainsKey(cur_sum - sum))``            ``{``                ``start = hashMap[cur_sum - sum] + 1;``                ``end = i;``                ``break``;``            ``}``            ``//if value is not present then add to hashmap``            ``hashMap[cur_sum] = i;` `        ``}``        ``// if end is -1 : means we have reached end without the sum``        ``if` `(end == -1)``        ``{``            ``Console.WriteLine(``"No subarray with given sum exists"``);``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"Sum found between indexes "` `+ start + ``" to "` `+ end);``        ``}` `    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = ``new` `int``[] {10, 2, -2, -20, 10};``        ``int` `n = arr.Length;``        ``int` `sum = -10;``        ``subArraySum(arr, n, sum);` `    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

`Sum found between indexes 0 to 3`

Complexity Analysis:

• Time complexity: O(N).
If hashing is performed with the help of an array, then this is the time complexity. In case the elements cannot be hashed in an array a hash map can also be used as shown in the above code.
• Auxiliary space: O(n).
As a HashMap is needed, this takes linear space.

Find subarray with given sum with negatives allowed in constant space