Related Articles
Find subarray with given sum | Set 2 (Handles Negative Numbers)
• Difficulty Level : Medium
• Last Updated : 09 May, 2020

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

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

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