N个二进制字符串的按位或

给定一个二进制字符串数组arr[] ，任务是计算所有这些字符串的按位或并打印结果字符串。
例子：

Input: arr[] = {“100”, “1001”, “0011”} 
Output 1111 
0100 OR 1001 OR 0011 = 1111
Input: arr[] = {“10”, “11”, “1000001”} 
Output: 1000011 
 

方法：我们可以通过首先找到最大大小的字符串来做到这一点。我们需要这个，因为我们必须在长度小于最大大小的字符串的前面添加 0。然后对每个位应用 OR 操作。
例如，如果字符串是“100”、“001”和“1111”。这里最大大小为 4，因此我们必须在第一个和第二个字符串上添加 1 个零以使其长度为 4，然后可以对数字的每个位执行 OR 运算，从而得到“0100”或“0001”或“ 1111” = “1111”。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
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

// 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

# 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#

// 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 */

Javascript

 
// 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));
 
 

输出：

1000011