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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++ implementation of the above approach ` ` `  `#include ` `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

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

 `// C++ implementation of the above approach ` ` `  `#include ` `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); ` ` `  `    ``cout << strBitwiseAND(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

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

## Python3

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

## C#

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

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.