Given a binary array arr[], the task is to calculate the bitwise XOR of all the elements in this array and print it.
Examples:
Input: arr[] = {“100”, “1001”, “0011”}
Output: 1110
0100 XOR 1001 XOR 0011 = 1110Input: arr[] = {“10”, “11”, “1000001”}
Output: 1000000
Approach:
- Step 1: First find the maximum-sized binary string.
- Step 2: Make all the binary strings in an array to the size of the maximum sized string, by adding 0s at the Most Significant Bit
- Step 3: Now find the resultant string by performing bitwise XOR on all the binary strings in the array.
For Examples:
- Let the binary array be {“100”, “001”, and “1111”}.
- Here the maximum sized binary string is 4.
- Make all the binary strings in the array of size 4, by adding 0s at the MSB. Now the binary array becomes {“0100”, “0001” and “1111”}
- Performing bitwise XOR on all the binary strings in the array
“0100” XOR “0001” XOR “1111” = “1110”
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 bitwise XOR // of all the binary strings void strBitwiseXOR(string* arr, int n)
{ string result;
int max_len = INT_MIN;
// Get max size and reverse each string
// Since we have to perform XOR operation
// on bits from right to left
// Reversing the string will make it easier
// to perform operation from left to right
for ( int i = 0; i < n; i++) {
max_len = max(max_len,
( int )arr[i].size());
reverse(arr[i].begin(),
arr[i].end());
}
for ( int i = 0; i < n; i++) {
// Add 0s to the end
// of strings if needed
string s;
for ( int j = 0;
j < max_len - arr[i].size();
j++)
s += '0' ;
arr[i] = arr[i] + s;
}
// Perform XOR operation on each bit
for ( int i = 0; i < max_len; i++) {
int pres_bit = 0;
for ( int j = 0; j < n; j++)
pres_bit = pres_bit ^ (arr[j][i] - '0' );
result += (pres_bit + '0' );
}
// Reverse the resultant string
// to get the final string
reverse(result.begin(), result.end());
// Return the final string
cout << result;
} // Driver code int main()
{ string arr[] = { "1000" , "10001" , "0011" };
int n = sizeof (arr) / sizeof (arr[0]);
strBitwiseXOR(arr, n);
return 0;
} |
Java
// Java implementation of the approach import java.io.*;
import java.util.*;
class GFG{
// Function to return the // reverse string static String reverse(String str)
{ String rev = "" ;
for ( int i = str.length() - 1 ; i >= 0 ; i--)
rev = rev + str.charAt(i);
return rev;
} // Function to return the bitwise XOR // of all the binary strings static String strBitwiseXOR(String[] arr, int n)
{ String result = "" ;
int max_len = Integer.MIN_VALUE;
// Get max size and reverse each string
// Since we have to perform XOR operation
// on bits from right to left
// Reversing the string will make it easier
// to perform operation from left to right
for ( int i = 0 ; i < n; i++)
{
max_len = Math.max(max_len,
( int )arr[i].length());
arr[i] = reverse(arr[i]);
}
for ( int i = 0 ; i < n; i++)
{
// Add 0s to the end
// of strings if needed
String s = "" ;
for ( int j = 0 ;
j < max_len - arr[i].length();
j++)
s += '0' ;
arr[i] = arr[i] + s;
}
// Perform XOR operation on each bit
for ( int i = 0 ; i < max_len; i++)
{
int pres_bit = 0 ;
for ( int j = 0 ; j < n; j++)
pres_bit = pres_bit ^
(arr[j].charAt(i) - '0' );
result += ( char )(pres_bit + '0' );
}
// Reverse the resultant string
// to get the final string
result = reverse(result);
// Return the final string
return result;
} // Driver code public static void main(String[] args)
{ String[] arr = { "1000" , "10001" , "0011" };
int n = arr.length;
System.out.print(strBitwiseXOR(arr, n));
} } // This code is contributed by akhilsaini |
Python3
# Function to return the bitwise XOR # of all the binary strings import sys
def strBitwiseXOR(arr, n):
result = ""
max_len = - 1
# Get max size and reverse each string
# Since we have to perform XOR operation
# on bits from right to left
# Reversing the string will make it easier
# to perform operation from left to right
for i in range (n):
max_len = max (max_len, len (arr[i]))
arr[i] = arr[i][:: - 1 ]
for i in range (n):
# Add 0s to the end
# of strings if needed
s = ""
# t = max_len - len(arr[i])
for j in range (max_len - len (arr[i])):
s + = "0"
arr[i] = arr[i] + s
# Perform XOR operation on each bit
for i in range (max_len):
pres_bit = 0
for j in range (n):
pres_bit = pres_bit ^ ( ord (arr[j][i]) - ord ( '0' ))
result + = chr ((pres_bit) + ord ( '0' ))
# Reverse the resultant string
# to get the final string
result = result[:: - 1 ]
# Return the final string
print (result)
# Driver code if (__name__ = = "__main__" ):
arr = [ "1000" , "10001" , "0011" ]
n = len (arr)
strBitwiseXOR(arr, n)
# This code is contributed by skylags |
C#
// C# implementation of the approach using System;
class GFG{
// Function to return the // reverse string static string reverse( string str)
{ string rev = "" ;
for ( int i = str.Length - 1; i >= 0; i--)
rev = rev + str[i];
return rev;
} // Function to return the bitwise XOR // of all the binary strings static string strBitwiseXOR( string [] arr, int n)
{ string result = "" ;
int max_len = int .MinValue;
// Get max size and reverse each string
// Since we have to perform XOR operation
// on bits from right to left
// Reversing the string will make it easier
// to perform operation from left to right
for ( int i = 0; i < n; i++)
{
max_len = Math.Max(max_len,
( int )arr[i].Length);
arr[i] = reverse(arr[i]);
}
for ( int i = 0; i < n; i++)
{
// Add 0s to the end
// of strings if needed
string s = "" ;
for ( int j = 0;
j < max_len - arr[i].Length;
j++)
s += '0' ;
arr[i] = arr[i] + s;
}
// Perform XOR operation on each bit
for ( int i = 0; i < max_len; i++)
{
int pres_bit = 0;
for ( int j = 0; j < n; j++)
pres_bit = pres_bit ^
(arr[j][i] - '0' );
result += ( char )(pres_bit + '0' );
}
// Reverse the resultant string
// to get the final string
result = reverse(result);
// Return the final string
return result;
} // Driver code public static void Main()
{ string [] arr = { "1000" , "10001" , "0011" };
int n = arr.Length;
Console.Write(strBitwiseXOR(arr, n));
} } // This code is contributed by akhilsaini |
Javascript
<script> // Javascript implementation of the approach // Function to return the bitwise XOR // of all the binary strings function strBitwiseXOR(arr, n)
{ var result = "" ;
var max_len = -1000000000;
// Get max size and reverse each string
// Since we have to perform XOR operation
// on bits from right to left
// Reversing the string will make it easier
// to perform operation from left to right
for ( var i = 0; i < n; i++) {
max_len = Math.max(max_len,
arr[i].length);
arr[i] = arr[i].split( '' ).reverse().join( '' );
}
for ( var i = 0; i < n; i++) {
// Add 0s to the end
// of strings if needed
var s;
for ( var j = 0;
j < max_len - arr[i].length;
j++)
s += '0' ;
arr[i] = arr[i] + s;
}
// Perform XOR operation on each bit
for ( var i = 0; i < max_len; i++) {
var pres_bit = 0;
for ( var j = 0; j < n; j++)
pres_bit = pres_bit ^ (arr[j][i] - '0' .charCodeAt(0));
result += (pres_bit + '0' .charCodeAt(0));
}
// Reverse the resultant string
// to get the final string
result = result.split( '' ).reverse().join( '' );
// Return the final string
document.write( result);
} // Driver code var arr = [ "1000" , "10001" , "0011" ];
var n = arr.length;
strBitwiseXOR(arr, n); </script> |
Output:
11010
Time complexity: O(n*m) where n is the number of strings in the array, and m is the maximum length of any string in the array.
Space Complexity: O(n*m)