Dada una array binaria arr[] , la tarea es calcular el XOR bit a bit de todos los elementos de esta array e imprimirlo.
Ejemplos:
Entrada: arr[] = {“100”, “1001”, “0011”}
Salida: 1110
0100 XOR 1001 XOR 0011 = 1110Entrada: arr[] = {“10”, “11”, “1000001”}
Salida: 1000000
Acercarse:
- Paso 1: primero encuentre la string binaria de tamaño máximo.
- Paso 2: haga que todas las strings binarias en una array tengan el tamaño de la string de tamaño máximo, agregando 0 en el bit más significativo
- Paso 3: ahora busque la string resultante realizando XOR bit a bit en todas las strings binarias de la array.
Por ejemplo:
- Deje que la array binaria sea {“100”, “001” y “1111”}.
- Aquí la string binaria de tamaño máximo es 4.
- Haga todas las strings binarias en la array de tamaño 4, agregando 0 en el MSB. Ahora la array binaria se convierte en {“0100”, “0001” y “1111”}
- Realizando XOR bit a bit en todas las strings binarias en la array
“0100” XOR “0001” XOR “1111” = “1110”
A continuación se muestra la implementación del enfoque anterior:
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>
Producción:
11010
Publicación traducida automáticamente
Artículo escrito por SHUBHAMSINGH10 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA