 GFG App
Open App Browser
Continue

# Print all subarrays with 0 sum

Given an array, print all subarrays in the array which has sum 0.

Examples:

Input:  arr = [6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7]
Output:
Subarray found from Index 2 to 4
Subarray found from Index 2 to 6
Subarray found from Index 5 to 6
Subarray found from Index 6 to 9
Subarray found from Index 0 to 10

Related posts: Find if there is a subarray with 0 sum

Recommended Practice

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

Below is the implementation of the above approach:

## C++

 `// C++ program to print all subarrays` `// in the array which has sum 0` `#include ` `using` `namespace` `std;`   `vector > findSubArrays(``int` `arr[], ``int` `n)` `{`   `    ``// Array to store all the start and end` `    ``// indices of subarrays with 0 sum` `    ``vector > output;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `prefix = 0;` `        ``for` `(``int` `j = i; j < n; j++) {` `            ``prefix += arr[j];` `            ``if` `(prefix == 0)` `                ``output.push_back({ i, j });` `        ``}` `    ``}`   `    ``return` `output;` `}`   `// Function to print all subarrays with 0 sum` `void` `print(vector > output)` `{` `    ``for` `(``auto` `it = output.begin(); it != output.end(); it++)` `        ``cout << ``"Subarray found from Index "` `<< it->first` `             ``<< ``" to "` `<< it->second << endl;` `}`   `// Driver code` `int` `main()` `{`   `    ``// Given array` `    ``int` `arr[] = { 6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``vector > output = findSubArrays(arr, n);`   `    ``// if we didn’t find any subarray with 0 sum,` `    ``// then subarray doesn’t exists` `    ``if` `(output.size() == 0) {` `        ``cout << ``"No subarray exists"``;` `    ``}` `    ``else` `{` `        ``print(output);` `    ``}` `    ``return` `0;` `}`   `// This article is contributed by Arpit Jain`

## Java

 `// Java program to print all subarrays` `// in the array which has sum 0` `import` `java.io.*;` `import` `java.util.*;`   `// User defined pair class` `class` `Pair` `{` `  ``int` `first, second;` `  ``Pair(``int` `a, ``int` `b)` `  ``{` `    ``first = a;` `    ``second = b;` `  ``}` `}`   `public` `class` `GFG` `{` `  ``static` `ArrayList findSubArrays(``int``[] arr, ``int` `n)` `  ``{ ` `    ``// Array to store all the start and end` `    ``// indices of subarrays with 0 sum` `    ``ArrayList out = ``new` `ArrayList<>();`   `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``{` `      ``int` `prefix = ``0``;` `      ``for``(``int` `j = i; j < n; j++){` `        ``prefix += arr[j];` `        ``if``(prefix == ``0``)` `          ``out.add(``new` `Pair(i, j));` `      ``}  ` `    ``}` `    ``return` `out;` `  ``}`   `  ``// Function to print all subarrays with 0 sum` `  ``static` `void` `print(ArrayList out)` `  ``{` `    ``for` `(``int` `i = ``0``; i < out.size(); i++)` `    ``{` `      ``Pair p = out.get(i);` `      ``System.out.println(``"Subarray found from Index "` `                         ``+ p.first + ``" to "` `+ p.second);` `    ``}` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String args[])` `  ``{`   `    ``// Given array` `    ``int``[] arr = {``6``, ``3``, -``1``, -``3``, ``4``, -``2``, ``2``, ``4``, ``6``, -``12``, -``7``};` `    ``int` `n = arr.length;`   `    ``// Function Call` `    ``ArrayList out = findSubArrays(arr, n);`   `    ``// if we didn’t find any subarray with 0 sum,` `    ``// then subarray doesn’t exists` `    ``if` `(out.size() == ``0``)` `      ``System.out.println(``"No subarray exists"``);` `    ``else` `      ``print(out);` `  ``}` `}`   `// This code is contributed by sandharbnkamble.`

## Python3

 `# User defined pair class` `class` `Pair :` `    ``first ``=` `0` `    ``second ``=` `0` `    ``def` `__init__(``self``, a,  b) :` `        ``self``.first ``=` `a` `        ``self``.second ``=` `b` `class` `GFG :` `    ``@staticmethod` `    ``def`  `findSubArrays( arr,  n) :` `      `  `        ``# Array to store all the start and end` `        ``# indices of subarrays with 0 sum` `        ``out ``=`  `[]` `        ``i ``=` `0` `        ``while` `(i < n) :` `            ``prefix ``=` `0` `            ``j ``=` `i` `            ``while` `(j < n) :` `                ``prefix ``+``=` `arr[j]` `                ``if` `(prefix ``=``=` `0``) :` `                    ``out.append(Pair(i, j))` `                ``j ``+``=` `1` `            ``i ``+``=` `1` `        ``return` `out` `      `  `    ``# Function to print all subarrays with 0 sum` `    ``@staticmethod` `    ``def` `print``( out) :` `        ``i ``=` `0` `        ``while` `(i < ``len``(out)) :` `            ``p ``=` `out[i]` `            ``print``(``"Subarray found from Index "` `+` `str``(p.first) ``+` `" to "` `+` `str``(p.second))` `            ``i ``+``=` `1` `            `  `    ``# Driver code` `    ``@staticmethod` `    ``def` `main( args) :` `      `  `        ``# Given array` `        ``arr ``=` `[``6``, ``3``, ``-``1``, ``-``3``, ``4``, ``-``2``, ``2``, ``4``, ``6``, ``-``12``, ``-``7``]` `        ``n ``=` `len``(arr)` `        `  `        ``# Function Call` `        ``out ``=` `GFG.findSubArrays(arr, n)` `        `  `        ``# if we didn't find any subarray with 0 sum,` `        ``# then subarray doesn't exists` `        ``if` `(``len``(out) ``=``=` `0``) :` `            ``print``(``"No subarray exists"``)` `        ``else` `:` `            ``GFG.``print``(out)` `    `    `if` `__name__``=``=``"__main__"``:` `    ``GFG.main([])` `    `  `    ``# This code is contributed by aadityaburujwale.`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `  `  `  ``// Array to store all the start and end` `  ``// indices of subarrays with 0 sum` `  ``static` `List> findSubArrays(``int``[] arr, ``int` `n)` `  ``{` `    ``var` `output = ``new` `List>();` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{` `      ``int` `prefix = 0;` `      ``for` `(``int` `j = i; j < n; j++)` `      ``{` `        ``prefix += arr[j];` `        ``if` `(prefix == 0)` `          ``output.Add(Tuple.Create(i, j));` `      ``}` `    ``}`   `    ``return` `output;` `  ``}`   `  ``// Function to print all subarrays with 0 sum` `  ``static` `void` `print(List> output)` `  ``{` `    ``foreach` `(``var` `subArray ``in` `output)` `      ``Console.Write(``"Subarray found from Index "` `+ subArray.Item1 + ``" to "` `+ subArray.Item2+``"\n"``);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``// Given array` `    ``int``[] arr = { 6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7 };` `    ``int` `n = arr.Length;`   `    ``// Function Call` `    ``List> output = findSubArrays(arr, n);`   `    ``// if we didn’t find any subarray with 0 sum,` `    ``// then subarray doesn’t exists` `    ``if` `(output.Count == 0)` `    ``{` `      ``Console.WriteLine(``"No subarray exists"``);` `    ``}` `    ``else` `    ``{` `      ``print(output);` `    ``}` `  ``}` `}`   `// This code is contributed by ratiagarwal.`

## Javascript

 `// Javascript program to print all subarrays` `// in the array which has sum 0` `function` `findSubArrays(arr, n)` `{`   `    ``// Array to store all the start and end` `    ``// indices of subarrays with 0 sum` `    ``let out =[];` `    ``for` `(let i = 0; i < n; i++) {` `        ``let prefix = 0;` `        ``for` `(let j = i; j < n; j++) {` `            ``prefix += arr[j];` `            ``if` `(prefix == 0)` `                ``out.push([i, j]);` `        ``}` `    ``}`   `    ``return` `out;` `}`   `// Function to print all subarrays with 0 sum` `function` `print(out)` `{` `    ``for` `(let it of out)` `        ``console.log(``"Subarray found from Index "` `+ it` `             ``+ ``" to "` `+ it);` `}`   `// Driver code` `// Given array` `let arr = [ 6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7 ];` `let n = arr.length ;`   `// Function Call` `let out = findSubArrays(arr, n);`   `// if we didn’t find any subarray with 0 sum,` `// then subarray doesn’t exists` `if` `(out.length == 0) {` `    ``console.log(``"No subarray exists"``);` `}` `else` `{` `    ``print(out);` `}` ` `  ` ``// This code is contributed by poojaagarwal2.`

Output

```Subarray found from Index 0 to 10
Subarray found from Index 2 to 4
Subarray found from Index 2 to 6
Subarray found from Index 5 to 6
Subarray found from Index 6 to 9```

Time Complexity: O(N^2) since we are using 2 loops.
Auxiliary Space: O(1), as constant extra space is required.

A better approach is to use Hashing.

Do following for each element in the array

1. Maintain sum of elements encountered so far in a variable (say sum).
2. If current sum is 0, we found a subarray starting from index 0 and ending at index current index
3. Check if current sum exists in the hash table or not.
4. If current sum already exists in the hash table then it indicates that this sum was the sum of some sub-array elements arr…arr[i] and now the same sum is obtained for the current sub-array arr…arr[j] which means that the sum of the sub-array arr[i+1]…arr[j] must be 0.
5. Insert current sum into the hash table

Below is a dry run of the above approach: Below is the implementation of the above approach:

## C++

 `// C++ program to print all subarrays` `// in the array which has sum 0` `#include ` `using` `namespace` `std;` ` `  `// Function to print all subarrays in the array which` `// has sum 0` `vector< pair<``int``, ``int``> > findSubArrays(``int` `arr[], ``int` `n)` `{` `    ``// create an empty map` `    ``unordered_map<``int``, vector<``int``> > map;` ` `  `    ``// create an empty vector of pairs to store` `    ``// subarray starting and ending index` `    ``vector > out;` ` `  `    ``// Maintains sum of elements so far` `    ``int` `sum = 0;` ` `  `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{` `        ``// add current element to sum` `        ``sum += arr[i];` ` `  `        ``// if sum is 0, we found a subarray starting` `        ``// from index 0 and ending at index i` `        ``if` `(sum == 0)` `            ``out.push_back(make_pair(0, i));` ` `  `        ``// If sum already exists in the map there exists` `        ``// at-least one subarray ending at index i with` `        ``// 0 sum` `        ``if` `(map.find(sum) != map.end())` `        ``{` `            ``// map[sum] stores starting index of all subarrays` `            ``vector<``int``> vc = map[sum];` `            ``for` `(``auto` `it = vc.begin(); it != vc.end(); it++)` `                ``out.push_back(make_pair(*it + 1, i));` `        ``}` ` `  `        ``// Important - no else` `        ``map[sum].push_back(i);` `    ``}` ` `  `    ``// return output vector` `    ``return` `out;` `}` ` `  `// Utility function to print all subarrays with sum 0` `void` `print(vector> out)` `{` `    ``for` `(``auto` `it = out.begin(); it != out.end(); it++)` `        ``cout << ``"Subarray found from Index "` `<<` `            ``it->first << ``" to "` `<< it->second << endl;` `}` ` `  `// Driver code` `int` `main()` `{` `    ``int` `arr[] = {6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);` ` `  `    ``vector > out = findSubArrays(arr, n);` ` `  `    ``// if we didn’t find any subarray with 0 sum,` `    ``// then subarray doesn’t exists` `    ``if` `(out.size() == 0)` `        ``cout << ``"No subarray exists"``;` `    ``else` `        ``print(out);` ` `  `    ``return` `0;` `}`

## Java

 `// Java program to print all subarrays` `// in the array which has sum 0` `import` `java.io.*;` `import` `java.util.*;`   `// User defined pair class` `class` `Pair ` `{` `    ``int` `first, second;` `    ``Pair(``int` `a, ``int` `b) ` `    ``{` `        ``first = a;` `        ``second = b;` `    ``}` `}`   `public` `class` `GFG` `{` `    ``// Function to print all subarrays in the array which ` `    ``// has sum 0` `    ``static` `ArrayList findSubArrays(``int``[] arr, ``int` `n)` `    ``{` `            ``// create an empty map ` `            ``HashMap> map = ``new` `HashMap<>();`   `            ``// create an empty vector of pairs to store ` `            ``// subarray starting and ending index ` `            ``ArrayList out = ``new` `ArrayList<>();`   `            ``// Maintains sum of elements so far` `            ``int` `sum = ``0``;`   `            ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``{` `                ``// add current element to sum ` `                ``sum += arr[i];`   `                ``// if sum is 0, we found a subarray starting ` `                ``// from index 0 and ending at index i ` `                ``if` `(sum == ``0``)` `                    ``out.add(``new` `Pair(``0``, i));` `                ``ArrayList al = ``new` `ArrayList<>();` `                `  `                ``// If sum already exists in the map there exists ` `                ``// at-least one subarray ending at index i with ` `                ``// 0 sum ` `                ``if` `(map.containsKey(sum))` `                ``{` `                    ``// map[sum] stores starting index of all subarrays` `                    ``al = map.get(sum);` `                    ``for` `(``int` `it = ``0``; it < al.size(); it++)` `                    ``{` `                            ``out.add(``new` `Pair(al.get(it) + ``1``, i)); ` `                    ``}` `                ``}` `                ``al.add(i);` `                ``map.put(sum, al);` `            ``}` `            ``return` `out;` `    ``} `   `    ``// Utility function to print all subarrays with sum 0` `    ``static` `void` `print(ArrayList out)` `    ``{` `            ``for` `(``int` `i = ``0``; i < out.size(); i++)` `            ``{` `                ``Pair p = out.get(i);` `                ``System.out.println(``"Subarray found from Index "` `                        ``+ p.first + ``" to "` `+ p.second); ` `            ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `            ``int``[] arr = {``6``, ``3``, -``1``, -``3``, ``4``, -``2``, ``2``, ``4``, ``6``, -``12``, -``7``};` `            ``int` `n = arr.length;` `            `  `            ``ArrayList out = findSubArrays(arr, n);` `            `  `            ``// if we did not find any subarray with 0 sum, ` `            ``// then subarray does not exists ` `            ``if` `(out.size() == ``0``)` `                ``System.out.println(``"No subarray exists"``);` `            ``else` `                ``print(out);` `    ``}` `}`   `// This code is contributed by rachana soma`

## Python3

 `# Python3 program to print all subarrays` `# in the array which has sum 0`   `# Function to get all subarrays` `# in the array which has sum 0` `def` `findSubArrays(arr,n):`   `    ``# create a python dict` `    ``hashMap ``=` `{}` `    `  `    ``# create a python list ` `    ``# equivalent to ArrayList` `    ``out ``=` `[]` `    `  `    ``# tracker for sum of elements` `    ``sum1 ``=` `0` `    ``for` `i ``in` `range``(n):` `        `  `        ``# increment sum by element of array` `        ``sum1 ``+``=` `arr[i]` `        `  `        ``# if sum is 0, we found a subarray starting ` `        ``# from index 0 and ending at index i` `        ``if` `sum1 ``=``=` `0``:` `            ``out.append((``0``, i))` `        ``al ``=` `[]` `        `  `        ``# If sum already exists in the map ` `        ``# there exists at-least one subarray ` `        ``# ending at index i with 0 sum ` `        ``if` `sum1 ``in` `hashMap:` `            `  `            ``# map[sum] stores starting index ` `            ``# of all subarrays` `            ``al ``=` `hashMap.get(sum1)` `            ``for` `it ``in` `range``(``len``(al)):` `                ``out.append((al[it] ``+` `1``, i))` `        ``al.append(i)` `        ``hashMap[sum1] ``=` `al` `    ``return` `out`   `# Utility function to print` `# all subarrays with sum 0 ` `def` `printOutput(output):` `    ``for` `i ``in` `output:` `        ``print` `(``"Subarray found from Index "` `+` `                ``str``(i[``0``]) ``+` `" to "` `+` `str``(i[``1``]))`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``6``, ``3``, ``-``1``, ``-``3``, ``4``, ``-``2``, ` `              ``2``, ``4``, ``6``, ``-``12``, ``-``7``]` `    ``n ``=` `len``(arr)` `    ``out ``=` `findSubArrays(arr, n)` `    `  `    ``# if we did not find any subarray with 0 sum, ` `    ``# then subarray does not exists ` `    ``if` `(``len``(out) ``=``=` `0``):` `        ``print` `(``"No subarray exists"``)` `    ``else``:` `        ``printOutput (out) `   `# This code is contributed by Vikas Chitturi`

## C#

 `// C# program to print all subarrays` `// in the array which has sum 0` `using` `System;` `using` `System.Collections.Generic;`   `// User defined pair class` `class` `Pair ` `{` `    ``public` `int` `first, second;` `    ``public` `Pair(``int` `a, ``int` `b) ` `    ``{` `        ``first = a;` `        ``second = b;` `    ``}` `}`   `class` `GFG` `{` `    ``// Function to print all subarrays ` `    ``// in the array which has sum 0` `    ``static` `List findSubArrays(``int``[] arr, ``int` `n)` `    ``{` `        ``// create an empty map ` `        ``Dictionary<``int``, List<``int``>> map = ` `                   ``new` `Dictionary<``int``, List<``int``>>();`   `        ``// create an empty vector of pairs to store ` `        ``// subarray starting and ending index ` `        ``List outt = ``new` `List();`   `        ``// Maintains sum of elements so far` `        ``int` `sum = 0;`   `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `            ``// add current element to sum ` `            ``sum += arr[i];`   `            ``// if sum is 0, we found a subarray starting ` `            ``// from index 0 and ending at index i ` `            ``if` `(sum == 0)` `                ``outt.Add(``new` `Pair(0, i));` `            ``List<``int``> al = ``new` `List<``int``>();` `            `  `            ``// If sum already exists in the map there exists ` `            ``// at-least one subarray ending at index i with ` `            ``// 0 sum ` `            ``if` `(map.ContainsKey(sum))` `            ``{` `                ``// map[sum] stores starting index ` `                ``// of all subarrays` `                ``al = map[sum];` `                ``for` `(``int` `it = 0; it < al.Count; it++)` `                ``{` `                    ``outt.Add(``new` `Pair(al[it] + 1, i)); ` `                ``}` `            ``}` `            ``al.Add(i);` `            ``if``(map.ContainsKey(sum))` `                ``map[sum] = al;` `            ``else` `                ``map.Add(sum, al);` `        ``}` `        ``return` `outt;` `    ``} `   `    ``// Utility function to print all subarrays with sum 0` `    ``static` `void` `print(List outt)` `    ``{` `        ``for` `(``int` `i = 0; i < outt.Count; i++)` `        ``{` `            ``Pair p = outt[i];` `            ``Console.WriteLine(``"Subarray found from Index "` `+ ` `                               ``p.first + ``" to "` `+ p.second); ` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``int``[] arr = {6, 3, -1, -3, 4, -2,` `                        ``2, 4, 6, -12, -7};` `        ``int` `n = arr.Length;` `        `  `        ``List outt = findSubArrays(arr, n);` `        `  `        ``// if we did not find any subarray with 0 sum, ` `        ``// then subarray does not exists ` `        ``if` `(outt.Count == 0)` `            ``Console.WriteLine(``"No subarray exists"``);` `        ``else` `            ``print(outt);` `    ``}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 `// JavaScript program to print all subarrays` `// in the array which has sum 0`   `// Function to print all subarrays in the array which` `// has sum 0` `function` `findSubArrays(arr, n)` `{` `    ``// create an empty map` `    ``let map = {};` ` `  `    ``// create an empty vector of pairs to store` `    ``// subarray starting and ending index` `    ``let out = [];` ` `  `    ``// Maintains sum of elements so far` `    ``let sum = 0;` ` `  `    ``for` `(``var` `i = 0; i < n; i++)` `    ``{` `        ``// add current element to sum` `        ``sum += arr[i];` ` `  `        ``// if sum is 0, we found a subarray starting` `        ``// from index 0 and ending at index i` `        ``if` `(sum == 0)` `            ``out.push([0, i]);` ` `  `        ``// If sum already exists in the map there exists` `        ``// at-least one subarray ending at index i with` `        ``// 0 sum` `        ``if` `(map.hasOwnProperty(sum))` `        ``{` `            ``// map[sum] stores starting index of all subarrays` `            ``let vc = map[sum];` `            ``for` `(let it of vc)` `                ``out.push([it + 1, i]);` `        ``}` `        ``else` `            ``map[sum] = [];` ` `  `        ``// Important - no else` `        ``map[sum].push(i);` `    ``}` ` `  `    ``// return output vector` `    ``return` `out;` `}` ` `  `// Utility function to print all subarrays with sum 0` `function` `print(out)` `{` `    ``for` `(let it of out)` `        ``console.log(``"Subarray found from Index "` `+ it + ``" to "` `+ it);` `}` ` `  ` `  `// Driver code` `let arr = [6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7];` `let n = arr.length;` ` `  `let out = findSubArrays(arr, n);` ` `  `// if we didn’t find any subarray with 0 sum,` `// then subarray doesn’t exists` `if` `(out.length == 0)` `    ``console.log(``"No subarray exists"``);` `else` `    ``print(out);`   `// This code is contributed by phasing17.`

Output

```Subarray found from Index 2 to 4
Subarray found from Index 2 to 6
Subarray found from Index 5 to 6
Subarray found from Index 6 to 9
Subarray found from Index 0 to 10```

Time Complexity: O(N)
Auxiliary Space: O(N)

## Approach 3:  Finding subarrays with sum 0 using dynamic programming:

### Algorithm:

1. Create an empty vector of pairs to store the starting and ending indices of all subarrays with a 0 sum.

2. Create an unordered map with the starting index of all subarrays that have the same sum.

3. Initialize  variable “sum =0″.

4.  Add a dummy index -1 to represent the empty subarray , i.e. ” sums.push_back(-1);”

5. Traverse the array from left to right:

• Add current element to the sum.
• If sum is already present in map, retrieve the vector of indices and add all subarrays beginning with those indices and ending with the current index to the output vector.
• In the map, add the current index to the vector of indices for the current total.

6. Return the output vector “out”.

Here’s the implementation of above algorithm:

## C++

 `#include ` `using` `namespace` `std;`   `vector> findSubArrays(``int` `arr[], ``int` `n) {` `    ``vector> out;` `    ``unordered_map<``int``, vector<``int``>> sums; ``// map to store the starting index of all subarrays with the same sum` `    ``int` `sum = 0;` `    ``sums.push_back(-1); ``// add a dummy index -1 to represent the empty subarray` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``sum += arr[i];` `        ``if` `(sums.find(sum) != sums.end()) {` `            ``vector<``int``> indices = sums[sum];` `            ``for` `(``int` `j = 0; j < indices.size(); j++) {` `                ``out.push_back(make_pair(indices[j] + 1, i));` `            ``}` `        ``}` `        ``sums[sum].push_back(i);` `    ``}` `    ``return` `out;` `}`   `void` `print(vector> out) {` `    ``for` `(``auto` `it = out.begin(); it != out.end(); it++) {` `        ``cout << ``"Subarray found from Index "` `<< it->first << ``" to "` `<< it->second << endl;` `    ``}` `}`   `int` `main() {` `    ``int` `arr[] = {6, 3, -1, -3, 4, -2, 2, 4, 6, -12, -7};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``vector> out = findSubArrays(arr, n);`   `    ``if` `(out.size() == 0) {` `        ``cout << ``"No subarray exists"``;` `    ``}` `    ``else` `{` `        ``print(out);` `    ``}`   `    ``return` `0;` `}`   `// This article is contributed by Vaibhav Saroj`

Output

```Subarray found from Index 2 to 4
Subarray found from Index 2 to 6
Subarray found from Index 5 to 6
Subarray found from Index 6 to 9
Subarray found from Index 0 to 10```

The dynamic programming approach to finding subarrays with sum 0  is contributed by Vaibhav Saroj.

Time Complexity: O(n)
Auxiliary Space: O(n)