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

Last Updated : 20 Sep, 2022

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

Recommended Practice

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

Naive Approach: To solve the problem follow the below idea:

A simple solution is to consider all subarrays one by one and check the sum of every subarray. The following program implements the simple solution. Run two loops: the outer loop picks a starting point I and the inner loop tries all subarrays starting from i.

Follow the given steps to solve the problem:

• Traverse the array from start to end.
• From every index start another loop from i to the end of the array to get all subarrays starting from i, and keep a variable sum to calculate the sum. For every index in the inner loop update sum = sum + array[j]If the sum is equal to the given sum then print the subarray.
• For every index in the inner loop update sum = sum + array[j]
• If the sum is equal to the given sum then print the subarray.

Below is the implementation of the above approach:

C++

 `/* A simple program to print subarray` `with sum as given sum */` `#include ` `using` `namespace` `std;`   `/* Returns true if the there is a subarray` `of arr[] with sum equal to 'sum' otherwise` `returns false. Also, prints the result */` `int` `subArraySum(``int` `arr[], ``int` `n, ``int` `sum)` `{` `    ``int` `curr_sum, i, j;`   `    ``// Pick a starting point` `    ``for` `(i = 0; i < n; i++) {` `        ``curr_sum = 0;`   `        ``// try all subarrays starting with 'i'` `        ``for` `(j = i; j < n; j++) {` `            ``curr_sum = curr_sum + arr[j];`   `            ``if` `(curr_sum == sum) {` `                ``cout << ``"Sum found between indexes "` `<< i` `                     ``<< ``" and "` `<< j;` `                ``return` `1;` `            ``}` `        ``}` `    ``}`   `    ``cout << ``"No subarray found"``;` `    ``return` `0;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 15, 2, 4, 8, 9, 5, 10, 23 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `sum = 23;`   `    ``// Function call` `    ``subArraySum(arr, n, sum);` `    ``return` `0;` `}`

Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG {`   `    ``/* Returns true if the there is a subarray` `    ``of arr[] with sum equal to 'sum' otherwise` `    ``returns false. Also, prints the result */` `    ``static` `int` `subArraySum(``int` `arr[], ``int` `n, ``int` `sum)` `    ``{` `        ``int` `curr_sum, i, j;`   `        ``// Pick a starting point` `        ``for` `(i = ``0``; i < n; i++) {` `            ``curr_sum = ``0``;`   `            ``// try all subarrays starting with 'i'` `            ``for` `(j = i; j < n; j++) {` `                ``curr_sum = curr_sum + arr[j];`   `                ``if` `(curr_sum == sum) {` `                    ``System.out.print(` `                        ``"Sum found between indexes "` `+ i` `                        ``+ ``" and "` `+ j);` `                    ``return` `1``;` `                ``}` `            ``}` `        ``}`   `        ``System.out.print(``"No subarray found"``);` `        ``return` `0``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``15``, ``2``, ``4``, ``8``, ``9``, ``5``, ``10``, ``23` `};` `        ``int` `n = arr.length;` `        ``int` `sum = ``23``;`   `        ``// Function call` `        ``subArraySum(arr, n, sum);` `    ``}` `}`   `// This code is contributed by code_hunt.`

Python3

 `# Python3 program to print subarray` `# with sum as given sum`     `# Returns true if the there is a subarray` `# of arr[] with sum equal to 'sum' otherwise` `# returns false. Also, prints the result */` `def` `subArraySum(arr, n, ``sum``):`   `    ``# Pick a starting point` `    ``for` `i ``in` `range``(n):` `        ``curr_sum ``=` `0` `        ``# try all subarrays starting with 'i'` `        ``for` `j ``in` `range``(i, n):` `            ``curr_sum ``+``=` `arr[j]` `            ``if` `(curr_sum ``=``=` `sum``):` `                ``print``(``"Sum found between indexes"``, i, ``"and"``, j)` `                ``return`   `    ``print``(``"No subarray found"``)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``15``, ``2``, ``4``, ``8``, ``9``, ``5``, ``10``, ``23``]` `    ``n ``=` `len``(arr)` `    ``sum` `=` `23`   `    ``# Function Call` `    ``subArraySum(arr, n, ``sum``)`     `# This code is contributed by phasing17`

C#

 `/* A simple program to print subarray` `with sum as given sum */`   `using` `System;`   `public` `static` `class` `GFG {` `    ``/* Returns true if the there is a subarray` `    ``of arr[] with sum equal to 'sum' otherwise` `    ``returns false. Also, prints the result */`   `    ``public` `static` `int` `subArraySum(``int``[] arr, ``int` `n, ``int` `sum)` `    ``{` `        ``int` `curr_sum;` `        ``int` `i;` `        ``int` `j;`   `        ``// Pick a starting point` `        ``for` `(i = 0; i < n; i++) {` `            ``curr_sum = 0;`   `            ``// try all subarrays starting with 'i'` `            ``for` `(j = i; j < n; j++) {` `                ``curr_sum = curr_sum + arr[j];`   `                ``if` `(curr_sum == sum) {` `                    ``Console.Write(` `                        ``"Sum found between indexes "``);` `                    ``Console.Write(i);` `                    ``Console.Write(``" and "``);` `                    ``Console.Write(j);` `                    ``return` `1;` `                ``}` `            ``}` `        ``}`   `        ``Console.Write(``"No subarray found"``);` `        ``return` `0;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 15, 2, 4, 8, 9, 5, 10, 23 };` `        ``int` `n = arr.Length;` `        ``int` `sum = 23;`   `        ``// Function call` `        ``subArraySum(arr, n, sum);` `    ``}` `}`   `// This code is contributed by Aarti_Rathi`

Javascript

 `/* JavaScript program to print subarray` `with sum as given sum */`   ` `  `/* Returns true if the there is a subarray` `of arr[] with sum equal to 'sum' otherwise` `returns false. Also, prints the result */` `function` `subArraySum(arr, n, sum)` `{` `    ``var` `curr_sum, i, j;` ` `  `    ``// Pick a starting point` `    ``for` `(i = 0; i < n; i++) {` `        ``curr_sum = 0;` ` `  `        ``// try all subarrays starting with 'i'` `        ``for` `(j = i ; j < n; j++) {` `           ``curr_sum = curr_sum + arr[j];` `          `  `            ``if` `(curr_sum == sum) {` `                ``console.log(``"Sum found between indexes "` `+ i + ``" and "` `+ j);` `                ``return``;` `            ``}` `        ``}` `    ``}` ` `  `    ``console.log(``"No subarray found"``);` `}` ` `  `// Driver Code` `var` `arr = [ 15, 2, 4, 8, 9, 5, 10, 23 ];` `var` `n = arr.length;` `var` `sum = 23;`   `//Function Call` `subArraySum(arr, n, sum);`     `//This code is contributed by phasing17`

Output

`Sum found between indexes 1 and 4`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Find subarray with given sum using Hash-Map:

To solve the problem follow the below idea:

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

Follow the given steps to solve the problem:

• 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
• Traverse through the array from start to end.
• For every element update the sum, i.e sum = sum + array[i]
• If the sum is equal to s then print that the subarray with the given sum is from 0 to i
• 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
• Put the sum and index in the hashmap as a key-value pair.

Dry-run of the above approach:

Below is the implementation of the above approach:

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 code` `int` `main()` `{` `    ``int` `arr[] = { 10, 2, -2, -20, 10 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `sum = -10;`   `    ``// Function call` `    ``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 cumulative 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``;`   `        ``// Function call` `        ``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 code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``10``, ``2``, ``-``2``, ``-``20``, ``10``]` `    ``n ``=` `len``(arr)` `    ``Sum` `=` `-``10`   `    ``# Function call` `    ``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 cumulative 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;`   `        ``// Function call` `        ``subArraySum(arr, n, sum);` `    ``}` `}`   `// This code is contributed by Shrikant13`

Javascript

 `// Javascript program to print subarray with sum as given sum`   `    ``function` `subArraySum(arr, n, sum) {` `        ``//cur_sum to keep track of cumulative sum till that point` `        ``let cur_sum = 0;` `        ``let start = 0;` `        ``let end = -1;` `        ``let hashMap = ``new` `Map();` `  `  `        ``for` `(let 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.has(cur_sum - sum)) {` `                ``start = hashMap.get(cur_sum - sum) + 1;` `                ``end = i;` `                ``break``;` `            ``}` `            ``//if value is not present then add to hashmap` `            ``hashMap.set(cur_sum, i);` `  `  `        ``}` `        ``// if end is -1 : means we have reached end without the sum` `        ``if` `(end == -1) {` `            ``console.log(``"No subarray with given sum exists"``);` `        ``} ` `        ``else` `{` `            ``console.log(``"Sum found between indexes "` `                            ``+ start + ``" to "` `+ end);` `        ``}` `  `  `    ``}`   `// Driver program `   `         ``let arr = [10, 2, -2, -20, 10];` `        ``let n = arr.length;` `        ``let sum = -10;` `        ``subArraySum(arr, n, sum);`

Output

`Sum found between indexes 0 to 3`

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.

Previous
Next