#### Ninja loves playing with numbers. So his friend gives him an array on his birthday. The array consists of positive and negative integers. Now Ninja is interested in finding the length of the longest subarray whose sum is zero.

```
The first line contains a single integer T, denoting the number of test cases.
The first line of each test case will contain the integer N, denoting the number of elements in the given array.
The second and last line contains N space-separated integers that denote the value of the elements of the array.
```

```
The first and only line of each test case in the output contains an integer denoting the length of the longest subarray whose sum is zero.
```

##### Note:

```
You are not required to print the expected output; it has already been taken care of. Just implement the function.
```

##### Constraints:

```
1 <= T <= 10
1 <= N <= 10^4
-10^5 <= arr[i] <= 10^5
Time Limit: 1 sec
```

##### Sample Input 1:

```
2
5
1 3 -1 4 -4
4
1 -1 2 -2
```

##### Sample Output 1:

```
2
4
```

##### Explanation For Sample Output 1:

```
In the first test case, the given array is (1, 3, -1, 4, -4). The sub-arrays we can create are (1), (3), (-1), (4), (-4), (1, 3), (3, -1), (-1, 4), (4, -4), (1, 3, -1), (3, -1, 4), (-1, 4, -4), (1, 3, -1, 4), (3, -1, 4, -4), (1, 3, -1, 4, -4). Out of them only (4, -4) is the sub array whose sum is zero.Length of this sub array is 2 and hence we return 2 as the final answer.
In the second test case, the given array is (1, -1, 2, -2). The sub-arrays we can create are (1), (-1), (2), (-2), (1, -1), (-1, 2), (2, -2), (1, -1, 2), (-1, 2, -2), (1, -1, 2, -2). Out of them sub arrays with zer sum are (1, -1), (2, -2), (1, -1, 2, -2). Out of them only (1, -1, 2, -2) has the longest length of 4. Hence we return 4 as the final answer.
```

##### Sample Input 2:

```
2
3
4 -5 1
4
1 2 1 -2
```

##### Sample Output 2 :

```
3
0
```

The solution to the above question is:

#include<bits/stdc++.h>

int LongestSubsetWithZeroSum(vector < int > v) {

unordered_map<int,int>mymap;

int curr=0,ans=0;

for(int i=0; i<v.size(); i++){

curr+=v[i];

if(curr==0){

ans=i+1;

}

else{

auto it=mymap.find(curr);

if(it==mymap.end()){

mymap.insert({curr,i});

}

else{

ans=max(ans,abs(i-it->second));

}

}

}

return ans;

}

## 0 Comments

If you have any doubts/suggestion/any query or want to improve this article, you can comment down below and let me know. Will reply to you soon.