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

Examples:

Input:arr[] = {1, 4, 20, 3, 10, 5}, sum = 33Ouptut:Sum found between indexes 2 and 4Input:arr[] = {10, 2, -2, -20, 10}, sum = -10Ouptut:Sum found between indexes 0 to 3Input:arr[] = {-10, 0, 2, -2, -20, 10}, sum = 20Ouptut:No subarray with given sum exists

We have discussed a solution that do not handles negative integers here. In this post, negative integers are also handled.

A simple solution is to consider all subarrays one by one and check if sum of every subarray is equal to given sum or not. The complexity of this solution would be O(n^2).

An efficient way is to use a map. The idea is to maintain sum of elements encountered so far in a variable (say curr_sum). Let the given number is sum. Now for each element, we check if curr_sum – sum exists in the map or not. If we found it in the map that means, we have a subarray present with given sum, else we insert curr_sum into the map and proceed to next element. If all elements of the array are processed and we didn’t find any subarray with given sum, then subarray doesn’t exists.

Below is C++ implementation of above idea –

`// C++ program to print subarray with sum as given sum ` `#include<bits/stdc++.h> ` `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; ` `} ` |

Output:

Sum found between indexes 0 to 3

**Time complexity** of above solution is O(n) as we are doing only one traversal of the array.

**
Auxiliary space** used by the program is O(n).

This article is contributed by **Aditya Goel**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Find subarray with given sum | Set 1 (Nonnegative Numbers)
- Print all subarrays with 0 sum
- Find smallest range containing elements from k lists
- Find the length of largest subarray with 0 sum
- Find if there is a subarray with 0 sum
- Sort an array of 0s, 1s and 2s
- Implementing our Own Hash Table with Separate Chaining in Java
- Number of subarrays having sum exactly equal to k
- Pair with given product | Set 1 (Find if any pair exists)
- Given an array A[] and a number x, check for pair in A[] with sum as x
- Largest subarray with equal number of 0s and 1s
- Vertical Sum in a given Binary Tree | Set 1
- Largest Sum Contiguous Subarray
- Count pairs with given sum
- Equilibrium index of an array