Bitwise AND of N binary strings

04 Jul, 2022
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:  
C++
Java
Python3
C#
Javascript
// 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 new lengthint 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 stringstring 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 Codeint 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; i++)    {        result = andOperationBitwise(result, arr[i]);    }    cout <<result<<endl;}// This code has been contributed by sharathmaidargi
// Java implementation of the above approachclass GFG {     // global fields    static String a;    static String b;     // Helper method: given two unequal sized    // bit strings, converts them to    // same length by adding leading 0s in the    // smaller string. Returns the new length    static int makeEqualLength()    {        int len_a = a.length();        int len_b = b.length();         int num_zeros = Math.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    static String andOperationBitwise(String s1, String s2)    {        // Make both strings of same length with the        // maximum length of s1 & s2.        a = s1;        b = s2;        int length = makeEqualLength();        s1 = a;        s2 = b;         // 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.charAt(i) - '0'                            & s2.charAt(i) - '0')                           + '0');        }        return res;    }     // Driver code    public static void main(String[] args)    {        String arr[] = { "101", "110110", "111" };        int n = arr.length;         String result = "";         // Check corner case: If there is just one        // binary string, then print it and return.        if (n < 2) {            System.out.println(arr[n - 1]);        }        result = arr[0];        for (int i = 1; i < n; i++) {            result = andOperationBitwise(result, arr[i]);        }        System.out.println(result);    }} // This code is contributed by phasing17
# Python3 implementation of above approach # this function takes two unequal sized# bit strings, converts them to# same length by adding leading 0s in the# smaller string. Returns the new lengthdef makeEqualLength(a, b):    len_a = len(a)    len_b = len(b)         num_zeros = abs(len_a - len_b)         if (len_a < len_b):        for i in range(num_zeros):            a = '0' + a                     # Return len_b which is highest.        # No need to proceed further!        return len_b, a, b     else:        for i in range(num_zeros):            b = '0' + b                 # Return len_a which is greater or    # equal to len_b    return len_a, a, b # The main function that performs AND# operation of two-bit sequences# and returns the resultant stringdef andOperationBitwise(s1, s2):         # Make both strings of same length    # with the maximum length of s1 & s2.    length, s1, s2 = makeEqualLength(s1, s2)     # Initialize res as NULL string    res = ""     # We start from left to right as we have    # made both strings of same length.    for i in range(length):                 # Convert s1[i] and s2[i] to int        # and perform bitwise AND operation,        # append to "res" string        res = res + str(int(s1[i]) & int(s2[i]))             return res # Driver Codearr = ["101", "110110", "111"]n = len(arr)if (n < 2):    print(arr[n - 1])     else:    result = arr[0]    for i in range(n):        result = andOperationBitwise(result, arr[i]);     print(result)     # This code is contributed by# ANKITKUMAR34
// C# implementation of the above approach using System; class GFG {   // global fields  static string a;  static string b;   // Helper method: given two unequal sized  // bit strings, converts them to  // same length by adding leading 0s in the  // smaller string. Returns the new length  static int makeEqualLength()  {    int len_a = a.Length;    int len_b = b.Length;     int num_zeros = Math.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  static string andOperationBitwise(string s1, string s2)  {    // Make both strings of same length with the    // maximum length of s1 & s2.    a = s1;    b = s2;    int length = makeEqualLength();    s1 = a;    s2 = b;     // 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  public static void Main(string[] args)  {    string[] arr = { "101", "110110", "111" };    int n = arr.Length;     string result = "";     // Check corner case: If there is just one    // binary string, then print it and return.    if (n < 2) {      Console.WriteLine(arr[n - 1]);    }    result = arr[0];    for (int i = 1; i < n; i++) {      result = andOperationBitwise(result, arr[i]);    }    Console.WriteLine(result);  }} // This code is contributed by phasing17
<script> // Javascript implementation of the above approach // Helper method: given two unequal sized// bit strings, converts them to// same length by adding leading 0s in the// smaller string. Returns the new lengthlet s1, s2; function makeEqualLength(){    let len_a = s1.length;    let len_b = s2.length;     let num_zeros = Math.abs(len_a - len_b);     if (len_a < len_b)    {        for(let i = 0; i < num_zeros; i++)        {            s1 = '0' + s1;        }                 // Return len_b which is highest.        // No need to proceed further!        return len_b;    }    else    {        for(let i = 0; i < num_zeros; i++)        {            s2 = '0' + s2;        }    }         // 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 stringfunction andOperationBitwise(){         // Make both strings of same length with the    // maximum length of s1 & s2.    let length = makeEqualLength();     // Initialize res as NULL string    let res = "";     // We start from left to right as we have    // made both strings of same length.    for(let i = 0 ; i<length; i++)    {                 // Convert s1[i] and s2[i] to int        // and perform bitwise AND operation,        // append to "res" string        res = res + String.fromCharCode((s1[i].charCodeAt() -                                           '0'.charCodeAt() &                                         s2[i].charCodeAt() -                                           '0'.charCodeAt()) +                                           '0'.charCodeAt());    }    return res;} // Driver codelet arr = [ "101", "110110", "111" ];let n = arr.length;let result;  // Check corner case: If there is just one// binary string, then print it and return.if (n < 2){    document.write(arr[n - 1] + "</br>");}result = arr[0];for(let i = 1; i<n; i++){    s1 = result;    s2 = arr[i];    result = andOperationBitwise();}document.write(result); // This code is contributed by vaibhavrabadiya3 </script>
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++
Java
Python3
C#
Javascript
// C++ implementation of the above approach #include <bits/stdc++.h>using namespace std; // Function to find the bitwise AND of// all the binary stringsstring 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 codeint main(){    string arr[] = { "101", "110110", "111" };     int n = sizeof(arr) / sizeof(arr[0]);     cout << strBitwiseAND(arr, n);     return 0;}
// Java implementation of the above approachclass 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
# Python3 implementation of the above approachimport sys; # Function to find the bitwise AND of# all the binary stringsdef 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 codeif __name__ == "__main__" :     arr = [ "101", "110110", "111" ];     n = len(arr) ;     print(strBitwiseAND(arr, n));     # This code is contributed by Ryuga
// 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
<script>     // JavaScript implementation of the above approach:         // Function to find the bitwise AND of    // all the binary strings    function strBitwiseAND(arr, n)    {        let res = "";               // To store the largest and the smallest        // string's size, We need this to add        // '0's in the resultant string        let smallest_size = Number.MAX_VALUE;        let largest_size = Number.MIN_VALUE;               // Reverse each string        // Since we need to perform AND operation        // on bits from Right to Left        let temp ="";        for (let 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 (let i = 0; i < smallest_size; i++)        {            let all_ones = true;                   for (let 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 (let i = 0; i < largest_size - smallest_size; i++)            res += '0';               // Reverse the string        // Since we started from LEFT to RIGHT        let temp1 = "";        temp1+=res;        res = reverse(temp1);               // Return the resultant string        let temparray1 = res;        let Temparray = "";        for(let i = 6; i < temparray1.length; i++)        {            Temparray = Temparray + temparray1[i];        }        return Temparray;    }           function reverse(input)    {        let temparray = input.split('');        let left, right = 0;        right = temparray.length - 1;           for (left = 0; left < right; left++, right--)        {            // Swap values of left and right            let temp = temparray[left];            temparray[left] = temparray[right];            temparray[right] = temp;        }        return temparray.join("");    }         let arr = [ "101", "110110", "111" ];    let n = arr.length;     document.write(strBitwiseAND(arr, n));     </script>
000100
 
ankthon
rituraj_jain
29AjayKumar
sharathmaidargi
ANKITKUMAR34
ApurvaRaj
rameshtravel07
vaibhavrabadiya3
ankita_saini
phasing17
binary-string
Bitwise-AND
Marketing
Sorting
Strings
Strings
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
HeapSort
std::sort() in C++ STL
Time Complexities of all Sorting Algorithms
Count Inversions in an array | Set 1 (Using Merge Sort)
Merge two sorted arrays
Write a program to reverse an array or string
Reverse a string in Java
Write a program to print all permutations of a given string
C++ Data Types
Check for Balanced Brackets in an expression (well-formedness) using Stack