Bitwise AND of N binary strings

Given an array arr[] of binary strings, the task is to calculate the bitwise AND of all of these strings and print the resultant string.

Examples:

Input: arr[] = {"101", "110110", "111"}
Output: 000100
(000101) & (110110) & (000111) = 000100

Input: arr[] = {"110010101", "111101001"}
Output: 110000001


Approach 1: Similar to Add two bit strings(https://www.geeksforgeeks.org/add-two-bit-strings/)
Given an array of N binary strings. We first compute the AND operation of the first two binary strings and then perform this “Result” with third binary string and so on till the last binary string.
For Example, string arr[] = {“101”, “110110”, “111”};
Step 1: Result = 101 AND 110110;
Step 2: Result = Result(Step1) AND 111;
So on..



Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Helper method: given two unequal sized 
// bit strings, converts them to 
// same length by adding leading 0s in the
// smaller string. Returns the the new length 
int makeEqualLength(string &a, string &b)
{
    int len_a = a.length();
    int len_b = b.length();
      
    int num_zeros = abs(len_a-len_b);
      
    if (len_a<len_b)
    {
        for (int i = 0 ; i<num_zeros; i++)
        {
            a = '0' + a;
        }
        // Return len_b which is highest.
        // No need to proceed further!
        return len_b; 
    }
    else
    {
        for (int i = 0 ; i<num_zeros; i++)
        {
            b = '0' + b;
        
    }
    // Return len_a which is greater or 
    // equal to len_b
    return len_a; 
}
  
// The main function that performs AND 
// operation of two-bit sequences
// and returns the resultant string
string andOperationBitwise(string s1, string s2)
{
    // Make both strings of same length with the 
    // maximum length of s1 & s2.
    int length = makeEqualLength(s1,s2);
  
    // Initialize res as NULL string
    string res = "";
  
    // We start from left to right as we have 
    // made both strings of same length. 
    for (int i = 0 ; i<length; i++)
    {
        // Convert s1[i] and s2[i] to int and perform 
        // bitwise AND operation, append to "res" string
        res = res + (char)((s1[i] - '0' & s2[i]-'0')+'0');
    }
    return res;
}
  
//Driver Code
int main()
{
    string arr[] = {"101", "110110", "111"};
    int n = sizeof(arr)/sizeof(arr[0]);
      
    string result;
      
    // Check corner case: If there is just one 
    // binary string, then print it and return. 
    if (n<2)
    {
        cout<<arr[n-1]<<endl;
        return 0;
    }
    result = arr[0]; 
    for (int i = 1; i<n-1; i++)
    {
        result = andOperationBitwise(result, arr[i]);
    }
    cout <<result<<endl;
}
// This code has been contributed by sharathmaidargi

chevron_right


Output:

000100

Approach 2: Find the size of the smallest and the largest string. We need this to add (largest-smallest) zeroes to our result. For example, if we have 0010 and 11, then AND on these strings will be 0010 (since we can write 11 as 0011). Then perform AND operation on each bit.

We can achieve this by only finding if the current bit in any string is 0 or not. If current bit is 0 in any of the given strings, then AND operation on that bit will be 0. If all bits at the current position are 1, then AND operation will be 1.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the bitwise AND of
// all the binary strings
string strBitwiseAND(string* arr, int n)
{
    string res;
  
    // To store the largest and the smallest
    // string's size, We need this to add '0's
    // in the resultant string
    int smallest_size = INT_MAX;
    int largest_size = INT_MIN;
  
    // Reverse each string
    // Since we need to perform AND operation
    // on bits from Right to Left
    for (int i = 0; i < n; i++) {
        reverse(arr[i].begin(), arr[i].end());
  
        // Update the respective length values
        smallest_size = min(smallest_size, (int)arr[i].size());
        largest_size = max(largest_size, (int)arr[i].size());
    }
  
    // Traverse bits from 0 to smallest string's size
    for (int i = 0; i < smallest_size; i++) {
        bool all_ones = true;
  
        for (int j = 0; j < n; j++) {
  
            // If at this bit position, there is a 0
            // in any of the given strings then AND
            // operation on current bit position
            // will be 0
            if (arr[j][i] == '0') {
  
                all_ones = false;
                break;
            }
        }
  
        // Add resultant bit to result
        res += (all_ones ? '1' : '0');
    }
  
    // Add 0's to the string.
    for (int i = 0; i < largest_size - smallest_size; i++)
        res += '0';
  
    // Reverse the string
    // Since we started from LEFT to RIGHT
    reverse(res.begin(), res.end());
  
    // Return the resultant string
    return res;
}
  
// Driver code
int main()
{
    string arr[] = { "101", "110110", "111" };
  
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << strBitwiseAND(arr, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach 
class GfG
{
  
    // Function to find the bitwise AND of 
    // all the binary strings 
    static String strBitwiseAND(String[] arr, int n) 
    
        String res = ""
      
        // To store the largest and the smallest 
        // string's size, We need this to add 
        // '0's in the resultant string 
        int smallest_size = Integer.MAX_VALUE; 
        int largest_size = Integer.MIN_VALUE; 
      
        // Reverse each string 
        // Since we need to perform AND operation 
        // on bits from Right to Left 
        for (int i = 0; i < n; i++)
        
              
            StringBuilder temp = new StringBuilder();
            temp.append(arr[i]);
            arr[i] = temp.reverse().toString();
      
            // Update the respective length values 
            smallest_size = Math.min(smallest_size, arr[i].length()); 
            largest_size = Math.max(largest_size, arr[i].length()); 
        
      
        // Traverse bits from 0 to smallest string's size 
        for (int i = 0; i < smallest_size; i++) 
        
            boolean all_ones = true
      
            for (int j = 0; j < n; j++) 
            
      
                // If at this bit position, there is a 0 
                // in any of the given strings then AND 
                // operation on current bit position 
                // will be 0 
                if (arr[j].charAt(i) == '0'
                
      
                    all_ones = false
                    break
                
            
      
            // Add resultant bit to result 
            res += (all_ones ? '1' : '0'); 
        
      
        // Add 0's to the string. 
        for (int i = 0; i < largest_size - smallest_size; i++) 
            res += '0'
      
        // Reverse the string 
        // Since we started from LEFT to RIGHT 
        StringBuilder temp = new StringBuilder();
        temp.append(res);
        res = temp.reverse().toString();
      
        // Return the resultant string 
        return res; 
    
  
    // Driver code
    public static void main(String []args)
    {
          
        String arr[] = { "101", "110110", "111" }; 
        int n = arr.length; 
      
        System.out.println(strBitwiseAND(arr, n));
    }
}
  
// This code is contributed by Rituraj Jain

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the above approach 
import sys;
  
# Function to find the bitwise AND of 
# all the binary strings 
def strBitwiseAND(arr, n) :
      
    res = "" 
      
    # To store the largest and the smallest 
    # string's size, We need this to add '0's 
    # in the resultant string 
    smallest_size = sys.maxsize; 
    largest_size = -(sys.maxsize - 1); 
      
    # Reverse each string 
    # Since we need to perform AND operation 
    # on bits from Right to Left 
    for i in range(n) :
        arr[i] = arr[i][::-1] ;
          
        # Update the respective length values 
        smallest_size = min(smallest_size, len(arr[i]));
        largest_size = max(largest_size, len(arr[i])); 
      
    # Traverse bits from 0 to smallest string's size 
    for i in range(smallest_size) :
        all_ones = True
          
        for j in range(n) :
              
            # If at this bit position, there is a 0 
            # in any of the given strings then AND
            # operation on current bit position 
            # will be 0
            if (arr[j][i] == '0') :
                all_ones = False;
                break
          
        # Add resultant bit to result
        if all_ones :
            res += '1' ;
        else :
            res += '0' ;
      
    # Add 0's to the string.
    for i in range(largest_size - smallest_size) :
        res += '0'
      
    # Reverse the string 
    # Since we started from LEFT to RIGHT 
    res = res[::-1]; 
  
    # Return the resultant string 
    return res; 
  
  
# Driver code 
if __name__ == "__main__"
  
    arr = [ "101", "110110", "111" ]; 
  
    n = len(arr) ; 
  
    print(strBitwiseAND(arr, n)); 
      
# This code is contributed by Ryuga

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach:
using System;
  
class GfG
{
  
    // Function to find the bitwise AND of 
    // all the binary strings 
    static String strBitwiseAND(String[] arr, int n) 
    
        String res = ""
      
        // To store the largest and the smallest 
        // string's size, We need this to add 
        // '0's in the resultant string 
        int smallest_size = int.MaxValue; 
        int largest_size = int.MinValue; 
      
        // Reverse each string 
        // Since we need to perform AND operation 
        // on bits from Right to Left 
        String temp ="";
        for (int i = 0; i < n; i++)
        
              
              
            temp+=arr[i];
            arr[i] = reverse(temp);
      
            // Update the respective length values 
            smallest_size = Math.Min(smallest_size, arr[i].Length); 
            largest_size = Math.Max(largest_size, arr[i].Length); 
        
      
        // Traverse bits from 0 to smallest string's size 
        for (int i = 0; i < smallest_size; i++) 
        
            bool all_ones = true
      
            for (int j = 0; j < n; j++) 
            
      
                // If at this bit position, there is a 0 
                // in any of the given strings then AND 
                // operation on current bit position 
                // will be 0 
                if (arr[j][i] == '0'
                
      
                    all_ones = false
                    break
                
            
      
            // Add resultant bit to result 
            res += (all_ones ? '1' : '0'); 
        
      
        // Add 0's to the string. 
        for (int i = 0; i < largest_size - smallest_size; i++) 
            res += '0'
      
        // Reverse the string 
        // Since we started from LEFT to RIGHT 
        String temp1 = "";
        temp1+=res;
        res = reverse(temp1);
      
        // Return the resultant 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 = { "101", "110110", "111" }; 
        int n = arr.Length; 
      
        Console.WriteLine(strBitwiseAND(arr, n));
    }
}
  
// This code has been contributed by 29AjayKumar

chevron_right


Output:

000100


My Personal Notes arrow_drop_up

A Coding Enthusiast Rails Developer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.