# Longest Subarray having strictly positive XOR

• Difficulty Level : Medium
• Last Updated : 27 Apr, 2021

Given an array arr[] of N non-negative integers. The task is to find the length of the longest sub-array such that XOR of all the elements of this sub-array is strictly positive. If no such sub-array exists then print -1
Examples:

Input: arr[] = {1, 1, 1, 1}
Output:
Take sub-array[0:2] = {1, 1, 1}
Xor of this sub-array is equal to 1.
Input: arr[] = {0, 1, 5, 19}
Output:

Approach:

• If the XOR of the complete array is positive, then answer is equal to N.
• If all the elements are zeroes then the answer is -1 as it is impossible to get strictly positive XOR.
• Otherwise, let’s say that index of the first positive number is l and the last positive number is r.
• Now XOR of all the elements of the index range [l, r] must be zero as elements before l and after r are 0s which will not contribute to the XOR value and the XOR of the original array was 0.
• Consider the sub-arrays A1, A1, …, Ar-1 and Al+1, Al+2, …, AN.
• The first subarray would have XOR value equal to A[r] and second, would have an XOR value A[l] which is positive.
• Return the length of the larger sub-array among these two sub-arrays.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the length of the``// longest sub-array having positive XOR``int` `StrictlyPositiveXor(``int` `A[], ``int` `N)``{` `    ``// To store the XOR``    ``// of all the elements``    ``int` `allxor = 0;` `    ``// To check if all the``    ``// elements of the array are 0s``    ``bool` `checkallzero = ``true``;` `    ``for` `(``int` `i = 0; i < N; i += 1) {` `        ``// Take XOR of all the elements``        ``allxor ^= A[i];` `        ``// If any positive value is found``        ``// the make the checkallzero false``        ``if` `(A[i] > 0)``            ``checkallzero = ``false``;``    ``}` `    ``// If complete array is the answer``    ``if` `(allxor != 0)``        ``return` `N;` `    ``// If all elements are equal to zero``    ``if` `(checkallzero)``        ``return` `-1;` `    ``// Initialize l and r``    ``int` `l = N, r = -1;` `    ``for` `(``int` `i = 0; i < N; i += 1) {` `        ``// First positive value of the array``        ``if` `(A[i] > 0) {``            ``l = i + 1;``            ``break``;``        ``}``    ``}``    ``for` `(``int` `i = N - 1; i >= 0; i -= 1) {` `        ``// Last positive value of the array``        ``if` `(A[i] > 0) {``            ``r = i + 1;``            ``break``;``        ``}``    ``}` `    ``// Maximum length among``    ``// these two subarrays``    ``return` `max(N - l, r - 1);``}` `// Driver code``int` `main()``{` `    ``int` `A[] = { 1, 0, 0, 1 };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``cout << StrictlyPositiveXor(A, N);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;` `class` `GFG``{` `// Function to return the length of the``// longest sub-array having positive XOR``static` `int` `StrictlyPositiveXor(``int` `[]A, ``int` `N)``{` `    ``// To store the XOR``    ``// of all the elements``    ``int` `allxor = ``0``;` `    ``// To check if all the``    ``// elements of the array are 0s``    ``boolean` `checkallzero = ``true``;` `    ``for` `(``int` `i = ``0``; i < N; i += ``1``)``    ``{` `        ``// Take XOR of all the elements``        ``allxor ^= A[i];` `        ``// If any positive value is found``        ``// the make the checkallzero false``        ``if` `(A[i] > ``0``)``            ``checkallzero = ``false``;``    ``}` `    ``// If complete array is the answer``    ``if` `(allxor != ``0``)``        ``return` `N;` `    ``// If all elements are equal to zero``    ``if` `(checkallzero)``        ``return` `-``1``;` `    ``// Initialize l and r``    ``int` `l = N, r = -``1``;` `    ``for` `(``int` `i = ``0``; i < N; i += ``1``)``    ``{` `        ``// First positive value of the array``        ``if` `(A[i] > ``0``)``        ``{``            ``l = i + ``1``;``            ``break``;``        ``}``    ``}``    ``for` `(``int` `i = N - ``1``; i >= ``0``; i -= ``1``)``    ``{` `        ``// Last positive value of the array``        ``if` `(A[i] > ``0``)``        ``{``            ``r = i + ``1``;``            ``break``;``        ``}``    ``}` `    ``// Maximum length among``    ``// these two subarrays``    ``return` `Math.max(N - l, r - ``1``);``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``int` `A[] = { ``1``, ``0``, ``0``, ``1` `};` `    ``int` `N = A.length;` `    ``System.out.print(StrictlyPositiveXor(A, N));``}``}` `// This code is contributed by anuj_67..`

## Python3

 `# Python3 implementation of the approach` `# Function to return the length of the``# longest sub-array having positive XOR``def` `StrictlyPositiveXor(A, N) :` `    ``# To store the XOR``    ``# of all the elements``    ``allxor ``=` `0``;` `    ``# To check if all the``    ``# elements of the array are 0s``    ``checkallzero ``=` `True``;` `    ``for` `i ``in` `range``(N) :` `        ``# Take XOR of all the elements``        ``allxor ^``=` `A[i];` `        ``# If any positive value is found``        ``# the make the checkallzero false``        ``if` `(A[i] > ``0``) :``            ``checkallzero ``=` `False``;` `    ``# If complete array is the answer``    ``if` `(allxor !``=` `0``) :``        ``return` `N;` `    ``# If all elements are equal to zero``    ``if` `(checkallzero) :``        ``return` `-``1``;` `    ``# Initialize l and r``    ``l ``=` `N; r ``=` `-``1``;` `    ``for` `i ``in` `range``(N) :` `        ``# First positive value of the array``        ``if` `(A[i] > ``0``) :``            ``l ``=` `i ``+` `1``;``            ``break``;``            ` `    ``for` `i ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``) :` `        ``# Last positive value of the array``        ``if` `(A[i] > ``0``) :``            ``r ``=` `i ``+` `1``;``            ``break``;` `    ``# Maximum length among``    ``# these two subarrays``    ``return` `max``(N ``-` `l, r ``-` `1``);`  `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``A``=` `[ ``1``, ``0``, ``0``, ``1` `];``    ``N ``=` `len``(A);``    ``print``(StrictlyPositiveXor(A, N));` `    ``# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// Function to return the length of the``// longest sub-array having positive XOR``static` `int` `StrictlyPositiveXor(``int` `[]A, ``int` `N)``{` `    ``// To store the XOR``    ``// of all the elements``    ``int` `allxor = 0;` `    ``// To check if all the``    ``// elements of the array are 0s``    ``bool` `checkallzero = ``true``;` `    ``for` `(``int` `i = 0; i < N; i += 1)``    ``{` `        ``// Take XOR of all the elements``        ``allxor ^= A[i];` `        ``// If any positive value is found``        ``// the make the checkallzero false``        ``if` `(A[i] > 0)``            ``checkallzero = ``false``;``    ``}` `    ``// If complete array is the answer``    ``if` `(allxor != 0)``        ``return` `N;` `    ``// If all elements are equal to zero``    ``if` `(checkallzero)``        ``return` `-1;` `    ``// Initialize l and r``    ``int` `l = N, r = -1;` `    ``for` `(``int` `i = 0; i < N; i += 1)``    ``{` `        ``// First positive value of the array``        ``if` `(A[i] > 0)``        ``{``            ``l = i + 1;``            ``break``;``        ``}``    ``}``    ``for` `(``int` `i = N - 1; i >= 0; i -= 1)``    ``{` `        ``// Last positive value of the array``        ``if` `(A[i] > 0)``        ``{``            ``r = i + 1;``            ``break``;``        ``}``    ``}` `    ``// Maximum length among``    ``// these two subarrays``    ``return` `Math.Max(N - l, r - 1);``}` `// Driver code``public` `static` `void` `Main ()``{``    ``int` `[]A = { 1, 0, 0, 1 };` `    ``int` `N = A.Length;` `    ``Console.WriteLine(StrictlyPositiveXor(A, N));``}``}` `// This code is contributed by anuj_67..`

## Javascript

 ``

Output:

`3`

Time complexity: O(N)

My Personal Notes arrow_drop_up