OR bit a bit de N strings binarias

Dada una array arr[] de strings binarias, la tarea es calcular el OR bit a bit de todas estas strings e imprimir la string resultante.
Ejemplos: 
 

Entrada: arr[] = {“100”, “1001”, “0011”} 
Salida 1111 
0100 O 1001 O 0011 = 1111
Entrada: arr[] = {“10”, “11”, “1000001”} 
Salida: 1000011 
 

Enfoque: podemos hacer esto encontrando primero la string de tamaño máximo. Necesitamos esto ya que tenemos que agregar 0 al frente de las strings cuyas longitudes son menores que el tamaño máximo. Luego aplique la operación OR en cada bit. 
Por ejemplo, si las strings son «100», «001» y «1111». Aquí el tamaño máximo es 4, por lo que tenemos que agregar 1 cero en la primera y segunda string para que su longitud sea 4 y luego la operación OR se puede realizar en cada uno de los bits de los números que dan como resultado «0100» O «0001» O » 1111” = “1111”.
A continuación se muestra la implementación del enfoque anterior:
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the bitwise OR of
// all the binary strings
string strBitwiseOR(string* arr, int n)
{
    string res;
 
    int max_size = INT_MIN;
 
    // Get max size and reverse each string
    // Since we have to perform OR 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_size = max(max_size, (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_size - arr[i].size(); j++)
            s += '0';
 
        arr[i] = arr[i] + s;
    }
 
    // Perform OR operation on each bit
    for (int i = 0; i < max_size; i++) {
        int curr_bit = 0;
        for (int j = 0; j < n; j++)
            curr_bit = curr_bit | (arr[j][i] - '0');
 
        res += (curr_bit + '0');
    }
 
    // Reverse the resultant string
    // to get the final string
    reverse(res.begin(), res.end());
 
    // Return the final string
    return res;
}
 
// Driver code
int main()
{
    string arr[] = { "10", "11", "1000001" };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << strBitwiseOR(arr, n);
 
    return 0;
}

// Java implementation of the approach
 
class GFG
{
 
// Function to return the bitwise OR of
// all the binary strings
static String strBitwiseOR(String[] arr, int n)
{
    String res="";
 
    int max_size = Integer.MIN_VALUE;
 
    // Get max size and reverse each string
    // Since we have to perform OR 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_size = Math.max(max_size, (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_size - arr[i].length(); j++)
            s += '0';
 
        arr[i] = arr[i] + s;
    }
     
    // Perform OR operation on each bit
    for (int i = 0; i < max_size; i++)
    {
        int curr_bit = 0;
        for (int j = 0; j < n; j++)
            curr_bit = curr_bit | (arr[j].charAt(i) - '0');
 
        res += (char)(curr_bit + '0');
    }
 
    // Reverse the resultant string
    // to get the final string
    res = reverse(res);
 
    // Return the final string
    return res;
}
 
static String reverse(String input)
{
    char[] temparray = input.toCharArray();
    int left, right = 0;
    right = temparray.length - 1;
 
    for (left = 0; left < right; left++, right--)
    {
        // Swap values of left and right
        char temp = temparray[left];
        temparray[left] = temparray[right];
        temparray[right] = temp;
    }
    return String.valueOf(temparray);
}
     
// Driver code
public static void main(String[] args)
{
    String arr[] = { "10", "11", "1000001" };
    int n = arr.length;
    System.out.println(strBitwiseOR(arr, n));
}
}
 
// This code contributed by Rajput-Ji

# Python3 implementation of the approach
 
# Function to return the bitwise OR of
# all the binary strings
def strBitwiseOR(arr, n):
    res=""
    max_size = -(2**32)
     
    # Get max size and reverse each string
    # Since we have to perform OR 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_size = max(max_size, len(arr[i]))
        arr[i] = arr[i][::-1]
     
    for i in range(n):
         
        # Add 0s to the end of strings
        # if needed
        s = ""
        for j in range(max_size - len(arr[i])):
            s += '0'
         
        arr[i] = arr[i] + s
         
    # Perform OR operation on each bit
    for i in range(max_size):
        curr_bit = 0
        for j in range(n):
            curr_bit = curr_bit | ord(arr[j][i])
         
        res += chr(curr_bit)
     
    # Reverse the resultant string
    # to get the final string
    res=res[::-1]
 
    # Return the final string
    return res
 
 
# Driver code
arr = ["10", "11", "1000001"]
n = len(arr)
print(strBitwiseOR(arr, n))
 
# This code is contributed by shubhamsingh10

// C# implementation of the approach
using System;
 
class GFG
{
  
// Function to return the bitwise OR of
// all the binary strings
static String strBitwiseOR(String[] arr, int n)
{
    String res="";
  
    int max_size = int.MinValue;
  
    // Get max size and reverse each string
    // Since we have to perform OR 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_size = Math.Max(max_size, (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_size - arr[i].Length; j++)
            s += '0';
  
        arr[i] = arr[i] + s;
    }
      
    // Perform OR operation on each bit
    for (int i = 0; i < max_size; i++)
    {
        int curr_bit = 0;
        for (int j = 0; j < n; j++)
            curr_bit = curr_bit | (arr[j][i] - '0');
  
        res += (char)(curr_bit + '0');
    }
  
    // Reverse the resultant string
    // to get the final string
    res = reverse(res);
  
    // Return the final string
    return res;
}
  
static String reverse(String input)
{
    char[] temparray = input.ToCharArray();
    int left, right = 0;
    right = temparray.Length - 1;
  
    for (left = 0; left < right; left++, right--)
    {
        // Swap values of left and right
        char temp = temparray[left];
        temparray[left] = temparray[right];
        temparray[right] = temp;
    }
    return String.Join("",temparray);
}
      
// Driver code
public static void Main(String[] args)
{
    String []arr = { "10", "11", "1000001" };
    int n = arr.Length;
    Console.WriteLine(strBitwiseOR(arr, n));
}
}
 
/* This code contributed by PrinciRaj1992 */

<script>
 
// JavaScript implementation of the approach
 
// Function to return the bitwise OR of
// all the binary strings
function strBitwiseOR(arr, n)
{
    var res = "";
 
    var max_size = -1000000000;
 
    // Get max size and reverse each string
    // Since we have to perform OR 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_size = Math.max(max_size, 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_size - arr[i].length; j++)
            s += '0';
 
        arr[i] = arr[i] + s;
    }
 
    // Perform OR operation on each bit
    for (var i = 0; i < max_size; i++) {
        var curr_bit = 0;
        for (var j = 0; j < n; j++)
            curr_bit = curr_bit | (arr[j][i].charCodeAt(0) -
            '0'.charCodeAt(0));
 
        res += String.fromCharCode(curr_bit + '0'.charCodeAt(0));
    }
 
    // Reverse the resultant string
    // to get the final string
    res = res.split('').reverse().join('');
 
    // Return the final string
    return res;
}
 
// Driver code
 
var arr = ["10", "11", "1000001"];
var n = arr.length;
document.write( strBitwiseOR(arr, n));
 
 
</script>

1000011