"The concept of Arrays form the basic foundation of nearly all the complicated coding interview questions."

That said, it is nearly not as difficult to cover the whole concept of arrays if you strive towards practicing all the important DSA questions for your coding interviews such as the one discussed in this blog!

From elements to Subarrays, there are a range of characteristics and components of Arrays that are important to be learned and adapted by every programmer in order to ace their coding interviews.

One such concept is the **zero sum subarray** that we have discussed in-depth in this blog.

The Subarrays with a sum 0 are essentially empty sections within an array that are required to be identified so that they can be deleted from the list.

So, launch your IDE software and let's tackle this problem together!

**How would you define Subarrays?**

Subarrays are basically a small portion or section of the Arrays that are written in brackets and parentheses.

Typically, while writing a program, one would have to reference the name of the targeted array and the exact section of the Subarray in order to reach the desired destination within the Array data structure.

Hence, in the context of program development, the Subarrays share more than a few similarities with their parent i.e the Arrays.

Also, the uses of Subarrays remains the same as the Arrays such as calling a function or method while using the similar syntaxes used in the Arrays.

While working with the Subarrays, the programmers have to dedicate the same amount of attention to detail as they would do with the Arrays. That said, it is often found that Subarrays might consist of a "Zero Sum".

A **zero sum subarray** is determined when we essentially calculate the sum of all the elements within the given input array till the required element and implement it on the map to check whether a sum 0 can be obtained or not.

You will often find the 0 sum Subarray problem mentioned in the technical rounds of your programming interview.

Let's find out how we can essentially solve this Subarray problem in particular by using a few simple algorithms.

**Subarrays With Zero Sum Problem **

The **zero sum subarray** problems essentially exist because the Arrays will often contain empty spaces or empty sections that might go undetected.

Which is why, the developers consider it necessary to write the Subarrays within the Arrays so that it would be easier to locate these empty pockets (or sections as we know them in programming).

Essentially, the Subarrays equivalent to sum 0 can be found using the Hash Table as we have briefly mentioned earlier.

But, before we dive deeper into the algorithm, let's consider what the problem statement would actually go like for the 0 sum Subarrays problem.

**Problem Statement:**

You have been given an input array, figure out the positions of all the possible Subarrays that can be located within this Array that result in a sum 0 and print them by the end of the program.

One of the simpler solutions for finding the **zero sum subarrays** within this problem would be analysing all the Subarrays and checking whether any of their sum equals zero or not.

Let's have a look at this approach and also analyse its time complexity.

**Method 1: Applying the Brute Force Algorithm**

The Brute Force is an algorithm in programming that involves solving a problem by iterating through every single element within the program and making sure to check every item until the purpose of the program is fulfilled.

The time complexity for applying the Brute Force algorithm corresponds to the size of the input provided in the problem statement.

Now, as per the nature of this algorithm, one can certainly conclude that this approach in particular is definitely more lengthy and time consuming than others.

It may be consistent but it is rather slow as compared to all the other derivatives. But, in the context of finding **zero sum Subarray** in a given input, the Brute Force Algorithm will certainly prove to be most effective and accurate.

Let's have a look at how the algorithm for Brute Force will follow:

- Start by visiting every single Subarray contained within the input Array.
- Check the value of the sum of these Subarrays individually. The target is finding the Subarray values that equals 0.

**Time Complexity of this approach:**

Since we have applied the Brute Force Algorithm, the required time complexity for this problem will be projected as: O(n^2).

**Method 2: Creating a Hashmap**

From finding the second largest element in an array to implementing the **reverse string word wise, **the HashMaps essentially help with solving all sorts of DSA problems.

The HashMap is a form of data structure that is known for using the Hash function in order to identify specific keys. These keys are associated with their allotted values and are used for storing them within maps.

A hashmap essentially consists of "key-value" pairs that allows retaining the values by the keys.

Here's how the algorithm for creating a Hashmap would work:

- Keep storing the value of the elements found within the Subarray in a variable.
- If the initial sum is found to be 0, then we have successfully spotted the Subarray with index 0.
- Next up, you will have to check whether this current sum is available in the Hashmap or not.
- If this initial sum already exists with the Hashmap then we can conclude that the sum of the located Subarray equals 0.
- Finally, end the program by inserting the value of the current sum within the hash table.

**Time Complexity for this approach:**

O(N)

**Final Thoughts**

Did you know that knowing the concept of arrays by-heart plays a big role in landing you job profiles in the technical and coding fields?

This blog was merely a glimpse of how vast the concept of arrays is.

For people who are interested in more fundamentals and concepts of DSA, we would recommend practicing Binary Trees and String based problems such as finding the largest BST in a Binary Tree or **reverse string word wise** problem.