Skip to content
Related Articles

Related Articles

Improve Article

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: 3 
Take sub-array[0:2] = {1, 1, 1} 
Xor of this sub-array is equal to 1.
Input: arr[] = {0, 1, 5, 19} 
Output: 4 
 

 

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 <bits/stdc++.h>
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



<script>
 
// Javascript implementation of the approach
 
// Function to return the length of the
// longest sub-array having positive XOR
function StrictlyPositiveXor(A, N)
{
 
    // To store the XOR
    // of all the elements
    let allxor = 0;
 
    // To check if all the
    // elements of the array are 0s
    let checkallzero = true;
 
    for (let 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
    let l = N, r = -1;
 
    for (let i = 0; i < N; i += 1) {
 
        // First positive value of the array
        if (A[i] > 0) {
            l = i + 1;
            break;
        }
    }
    for (let 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
 
    let A = [ 1, 0, 0, 1 ];
 
    let N = A.length;
 
    document.write(StrictlyPositiveXor(A, N));
 
</script>
Output: 
3
 
Time complexity: O(N)
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
Count of numbers upto M divisible by given Prime Numbers
Next

Greatest contiguous sub-array of size K
Recommended Articles
Page :
Partition array into two subarrays with every element in the right subarray strictly greater than every element in left subarray
01, Mar 21
Longest alternating (positive and negative) subarray starting at every index
09, Dec 17
Length of longest subarray with positive product
02, Sep 20
Find Maximum Sum Strictly Increasing Subarray
07, Dec 16
Count the subarray with sum strictly greater than the sum of remaining elements
26, Jan 20
Maximize product of a strictly increasing or decreasing subarray
12, Jan 21
Length of longest strictly increasing subset with each pair of adjacent elements satisfying the condition 2 * A[i] ≥ A[i + 1]
22, Mar 21
Length of the longest subarray whose Bitwise XOR is K
10, Dec 20
Length of largest sub-array having primes strictly greater than non-primes
12, Oct 18
Print all numbers in given range having digits in strictly increasing order
13, Jul 20
Find a K-length subarray having Bitwise XOR equal to that of remaining array elements
17, Jan 21
Number of triplets in array having subarray xor equal
23, Sep 19
Only integer with positive value in positive negative value in array
08, Nov 17
Generate an array with K positive numbers such that arr[i] is either -1 or 1 and sum of the array is positive
16, May 21
Find the last positive element remaining after repeated subtractions of smallest positive element from all Array elements
10, Sep 21
First subarray having sum at least half the maximum sum of any subarray of size K
09, Sep 20
Longest Subarray having sum of elements atmost 'k'
03, Sep 17
Longest subarray having count of 1s one more than count of 0s
28, Oct 17
Longest subarray not having more than K distinct elements
08, Nov 17
Longest subarray having average greater than or equal to x
18, Aug 18
Longest subarray having average greater than or equal to x | Set-2
10, Sep 18
Longest subarray having maximum sum
23, Sep 18
Longest subarray having difference in the count of 1's and 0's equal to k
05, Oct 18
Length of longest subarray having frequency of every element equal to K
11, Nov 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
CrazyPro
@CrazyPro
Vote for difficulty
Current difficulty :
Medium





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