Skip to content
Related Articles

Related Articles

Improve Article
Number of ways to erase exactly one element in the Binary Array to make XOR zero
  • Last Updated : 26 Apr, 2021

Given a binary array of 0’s and 1’s, the task is to find the number of ways to erase exactly one element from this array to make XOR zero.
Examples: 
 

Input: arr = {1, 1, 1, 1, 1 }
Output: 5 
You can erase any of the given 5 1's,
it will make the XOR of the rest equal to zero.

Input: arr = {1, 0, 0, 1, 0 }
Output: 3 
Since the XOR of array is already 0,
You can erase any of the given 3 0's
so that the XOR remains unaffected.

 

Approach: Since we know that, to make XOR of binary elements be 0, the number of 1’s should be even. Hence this problem can be broken into 4 cases: 
 

  • When the number of 1’s is even and the number of 0’s is also even in the given array: In this scenario, the XOR of the array is already 0. Hence to keep the XOR unaffected, we can remove only the 0’s. Hence the number of ways to erase exactly one element from this array to make XOR zero is the number of 0’s in this array. 
     
  • When the number of 1’s is even and the number of 0’s is odd in the given array: In this scenario, the XOR of the array is already 0. Hence to keep the XOR unaffected, we can remove only the 0’s. Hence the number of ways to erase exactly one element from this array to make XOR zero is the number of 0’s in this array. 
     
  • When the number of 1’s is odd and the number of 0’s is even in the given array: In this scenario, the XOR of the array is 1. Hence to make the XOR 0, we can remove any of the 1’s. Hence the number of ways to erase exactly one element from this array to make XOR zero is the number of 1’s in this array. 
     
  • When the number of 1’s is odd and the number of 0’s is also odd in the given array: In this scenario, the XOR of the array is 1. Hence to make the XOR 0, we can remove any of the 1’s. Hence the number of ways to erase exactly one element from this array to make XOR zero is the number of 1’s in this array. 
     

Below is the implementation of the above approach:
 

C++




// C++ program to find the number of ways
// to erase exactly one element
// from this array to make XOR zero
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the number of ways
int no_of_ways(int a[], int n)
{
    int count_0 = 0, count_1 = 0;
 
    // Calculate the number of 1's and 0's
    for (int i = 0; i < n; i++) {
        if (a[i] == 0)
            count_0++;
        else
            count_1++;
    }
 
    // Considering the 4 cases
    if (count_1 % 2 == 0)
        return count_0;
    else
        return count_1;
}
 
// Driver code
int main()
{
    int n = 4;
    int a1[4] = { 1, 1, 0, 0 };
    cout << no_of_ways(a1, n) << endl;
 
    n = 5;
    int a2[5] = { 1, 1, 1, 0, 0 };
    cout << no_of_ways(a2, n) << endl;
 
    n = 5;
    int a3[5] = { 1, 1, 0, 0, 0 };
    cout << no_of_ways(a3, n) << endl;
 
    n = 6;
    int a4[6] = { 1, 1, 1, 0, 0, 0 };
    cout << no_of_ways(a4, n) << endl;
 
    return 0;
}
Java



// Java program to find the number of ways
// to erase exactly one element
// from this array to make XOR zero
class GFG
{
     
    // Function to find the number of ways
    static int no_of_ways(int a[], int n)
    {
        int count_0 = 0, count_1 = 0;
     
        // Calculate the number of 1's and 0's
        for (int i = 0; i < n; i++)
        {
            if (a[i] == 0)
                count_0++;
            else
                count_1++;
        }
     
        // Considering the 4 cases
        if (count_1 % 2 == 0)
            return count_0;
        else
            return count_1;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int n = 4;
        int a1[] = { 1, 1, 0, 0 };
        System.out.println(no_of_ways(a1, n));
     
        n = 5;
        int a2[] = { 1, 1, 1, 0, 0 };
        System.out.println(no_of_ways(a2, n));
     
        n = 5;
        int a3[] = { 1, 1, 0, 0, 0 };
        System.out.println(no_of_ways(a3, n));
     
        n = 6;
        int a4[] = { 1, 1, 1, 0, 0, 0 };
        System.out.println(no_of_ways(a4, n));
    }
}
 
// This code is contributed by AnkitRai01
Python3



# Python3 program to find the number of ways
# to erase exactly one element
# from this array to make XOR zero
 
# Function to find the number of ways
def no_of_ways(a, n):
 
    count_0 = 0
    count_1 = 0
 
    # Calculate the number of 1's and 0's
    for i in range(0, n):
        if (a[i] == 0):
            count_0 += 1
        else:
            count_1 += 1
     
    # Considering the 4 cases
    if (count_1 % 2 == 0):
        return count_0
    else:
        return count_1
 
# Driver code
if __name__ == '__main__':
    n = 4
    a1 = [ 1, 1, 0, 0 ]
    print(no_of_ways(a1, n))
 
    n = 5
    a2 = [ 1, 1, 1, 0, 0 ]
    print(no_of_ways(a2, n))
 
    n = 5
    a3 = [ 1, 1, 0, 0, 0 ]
    print(no_of_ways(a3, n))
 
    n = 6
    a4 = [ 1, 1, 1, 0, 0, 0 ]
    print(no_of_ways(a4, n))
 
# This code is contributed by ashutosh450
C#



// C# program to find the number of ways
// to erase exactly one element
// from this array to make XOR zero
using System;
 
class GFG
{
     
    // Function to find the number of ways
    static int no_of_ways(int []a, int n)
    {
        int count_0 = 0, count_1 = 0;
     
        // Calculate the number of 1's and 0's
        for (int i = 0; i < n; i++)
        {
            if (a[i] == 0)
                count_0++;
            else
                count_1++;
        }
     
        // Considering the 4 cases
        if (count_1 % 2 == 0)
            return count_0;
        else
            return count_1;
    }
     
    // Driver code
    public static void Main ()
    {
        int n = 4;
        int [] a1 = { 1, 1, 0, 0 };
        Console.WriteLine(no_of_ways(a1, n));
     
        n = 5;
        int [] a2 = { 1, 1, 1, 0, 0 };
        Console.WriteLine(no_of_ways(a2, n));
     
        n = 5;
        int [] a3 = { 1, 1, 0, 0, 0 };
        Console.WriteLine(no_of_ways(a3, n));
     
        n = 6;
        int [] a4 = { 1, 1, 1, 0, 0, 0 };
        Console.WriteLine(no_of_ways(a4, n));
    }
}
 
// This code is contributed by Mohit kumar
Javascript



<script>
 
// Javascript program to find the number of ways
// to erase exactly one element
// from this array to make XOR zero
 
// Function to find the number of ways
function no_of_ways(a, n)
{
    let count_0 = 0, count_1 = 0;
 
    // Calculate the number of 1's and 0's
    for (let i = 0; i < n; i++) {
        if (a[i] == 0)
            count_0++;
        else
            count_1++;
    }
 
    // Considering the 4 cases
    if (count_1 % 2 == 0)
        return count_0;
    else
        return count_1;
}
 
// Driver code
    let n = 4;
    let a1 = [ 1, 1, 0, 0 ];
    document.write(no_of_ways(a1, n) + "<br>");
 
    n = 5;
    let a2 = [ 1, 1, 1, 0, 0 ];
    document.write(no_of_ways(a2, n) + "<br>");
 
    n = 5;
    let a3 = [ 1, 1, 0, 0, 0 ];
    document.write(no_of_ways(a3, n) + "<br>");
 
    n = 6;
    let a4 = [ 1, 1, 1, 0, 0, 0 ];
    document.write(no_of_ways(a4, n) + "<br>");
 
</script>
Output: 


2
3
3
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 industry experts, please refer DSA Live Classes



My Personal Notes
arrow_drop_up
Previous
Minimum absolute difference between N and any power of 2
Next

Random list of M non-negative integers whose sum is N
Recommended Articles
Page :
Count of ways to make Array sum even by removing only one element
02, Jul 20
Count ways to make sum of odd and even indexed elements equal by removing an array element
02, Dec 20
Count ways to make Bitwise XOR of odd and even indexed elements equal by removing an array element
02, Dec 20
Number of ways to change the Array such that largest element is LCM of array
20, Jun 20
Smallest number to make Array sum at most K by dividing each element
13, May 20
Minimum number of moves to make a binary array K periodic
12, Feb 19
Ways to remove one element from a binary string so that XOR becomes zero
19, Jul 17
Minimize replacements to make every element in an array exceed every element in another given array
17, Feb 21
Number of ways to split a binary number such that every part is divisible by 2
03, Nov 19
Count ways to split array into two equal sum subarrays by replacing each array element to 0 once
13, Nov 20
Count ways to split array into two equal sum subarrays by changing sign of any one array element
03, Dec 20
Count ways to make product of array elements even by replacements
03, Feb 21
Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1
28, Jan 19
Number of ways to divide string in sub-strings such to make them in lexicographically increasing sequence
11, Nov 19
Smallest indexed array element required to be flipped to make sum of array equal to 0
28, Dec 20
Rearrange array to make decimal equivalents of reversed binary representations of array elements sorted
27, May 21
Rearrange array to make it non-decreasing by swapping pairs having GCD equal to minimum array element
23, Sep 20
Minimum increments to modify array such that value of any array element can be splitted to make all remaining elements equal
25, Dec 20
Minimum array element changes to make its elements 1 to N
24, Sep 18
Count of array elements that can be found using Randomized Binary Search on every array element
13, Jan 21
Count remaining array elements after reversing binary representation of each array element
16, Feb 21
Change one element in the given array to make it an Arithmetic Progression
24, May 19
Minimum changes required to make all element in an array equal
09, Jan 20
Find if it is possible to make a binary string which contanins given number of "0", "1" , "01" and "10" as sub sequences
03, Jun 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
spp____
@spp____
Vote for difficulty





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