Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Print all subarrays with 0 sum

  • Difficulty Level : Hard
  • Last Updated : 07 Dec, 2021

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 
 

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).
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[0]…arr[i] and now the same sum is obtained for the current sub-array arr[0]…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 <bits/stdc++.h>
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 <pair<int, int>> 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<pair<int, int>> 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[0]);
  
    vector<pair<int, int> > 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<Pair> findSubArrays(int[] arr, int n)
    {
            // create an empty map
            HashMap<Integer,ArrayList<Integer>> map = new HashMap<>();
 
            // create an empty vector of pairs to store
            // subarray starting and ending index
            ArrayList<Pair> 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<Integer> 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<Pair> 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<Pair> 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<Pair> 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<Pair> outt = new List<Pair>();
 
        // 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<Pair> 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<Pair> 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
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)
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.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.
 

My Personal Notes
arrow_drop_up
Next

Find if there is a subarray with 0 sum
Recommended Articles
Page :
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
27, Sep 21
Print all subarrays with sum in a given range
24, Nov 21
Differences between number of increasing subarrays and decreasing subarrays in k sized windows
16, Nov 17
Split given Array in minimum number of subarrays such that rearranging the order of subarrays sorts the array
03, Sep 21
Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0
13, Dec 21
Print indices of pair of array elements required to be removed to split array into 3 equal sum subarrays
22, Feb 21
For all Array elements find Product of Sum of all smaller and Sum of all greater elements
06, Apr 22
Sum of minimum and maximum elements of all subarrays of size k.
04, Jan 17
Maximum subarray size, such that all subarrays of that size have sum less than k
30, Dec 16
Sum of all Subarrays | Set 1
22, Feb 17
Count all subarrays whose sum can be split as difference of squares of two Integers
10, May 20
Generate Array whose sum of all K-size subarrays divided by N leaves remainder X
29, Jun 20
Sum of bitwise OR of all subarrays
16, Sep 18
Sum of minimum elements of all subarrays
05, Nov 18
Sum of Bitwise-OR of all subarrays of a given Array | Set 2
06, Dec 18
Sum of XOR of all subarrays
11, Feb 19
Sum of minimum element of all subarrays of a sorted array
21, Feb 19
Sum of maximum of all subarrays | Divide and Conquer
24, May 19
Calculate the Sum of GCD over all subarrays
02, Dec 19
Maximum length L such that the sum of all subarrays of length L is less than K
20, Jan 20
Sum of all subarrays of size K
26, Mar 20
Make sum of all subarrays of length K equal by only inserting elements
05, May 20
Generate a unique Array of length N with sum of all subarrays divisible by N
29, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!