Skip to content
Related Articles

Related Articles

Number of ways to erase exactly one element in the Binary Array to make XOR zero

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 19 Mar, 2022

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)
Auxiliary Space: O(1)
 

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 :
Ways to remove one element from a binary string so that XOR becomes zero
19, Jul 17
Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1
28, Jan 19
Check if possible to make Array sum equal to Array product by replacing exactly one element
28, Aug 21
Count ways to make Bitwise XOR of odd and even indexed elements equal by removing an array element
02, Dec 20
Minimum operations to make XOR of array zero
18, Sep 17
Maximum sum in an array such that every element has exactly one adjacent element to it
23, May 19
Minimum increments to make all array elements equal with sum same as the given array after exactly one removal
04, Dec 20
Count of ways to make Array sum even by removing only one element
02, Jul 20
Bitwise XOR of same indexed array elements after rearranging an array to make XOR of same indexed elements of two arrays equal
05, Aug 21
Check if rows of a Matrix can be rearranged to make Bitwise XOR of first column non-zero
05, Nov 20
Count ways to distribute exactly one coin to each worker
10, Sep 20
Count of subarrays in range [L, R] having XOR + 1 equal to XOR (XOR) 1 for M queries
26, Oct 21
Print all the root-to-leaf paths of a Binary Tree whose XOR is non-zero
30, Apr 20
Make all elements zero by decreasing any two elements by one at a time
08, Jan 20
Find the next non-zero Array element to the right of each array element
15, Oct 21
Remove all zero-rows and all zero-columns from a Matrix
06, Jan 21
Next greater number than N with exactly one bit different in binary representation of N
22, Oct 18
Remove exactly one element from the array such that max - min is minimum
02, Jan 19
Maximum length of longest increasing contiguous subarray after deleting exactly one element from array
27, Oct 21
Find an integer X which is divisor of all except exactly one element in an array
26, Dec 18
Count ways to split array into two equal sum subarrays by changing sign of any one array element
03, Dec 20
Last element of an array after repeatedly removing the first element and appending it to the end of the array twice exactly K times
27, Jun 21
Number of ways to choose an integer such that there are exactly K elements greater than it in the given array
04, Feb 19
Number of ways to select exactly K even numbers from given Array
18, Jul 20
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

Start Your Coding Journey Now!