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

Given an unsorted array of integers, find a subarray which adds to a given number. If there are more than one subarrays with the sum as 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
Explantion: 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
Explantion: 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
Explantion: There is no subarray with the given sum
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Note: We have discussed a solution that do not handles 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 for every index store the sum of elements upto that index hashmap. So to check if there is a subarray with sum equal to s, check for every index i, and sum upto that index as x. If there is a prefix with sum equal to x – s, then the subarray with given sum is found.

Algorithm:

1. create a Hashmap (hm) to store 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 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 sum is equal to s then print that the subarray with 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 given sum is from hm[sum – s] to i
6. Put the sum and index in the hashmap as key-value pair.

Dry-run of the above approach:

Implementation:

 `// 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[0]); ` `    ``int` `sum = -10; ` ` `  `    ``subArraySum(arr, n, sum); ` ` `  `    ``return` `0; ` `} `

 `// 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 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 `

 `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 `

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 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 a linear space.

Find subarray with given sum with negatives allowed in constant space