 GFG App
Open App Browser
Continue

# 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
Explanation: (000101) & (110110) & (000111) = 000100

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

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

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

## Java

 `// Java implementation of the above approach` `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.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

 `# 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 length ` `def` `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 string ` `def` `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 Code ` `arr ``=` `[``"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#

 `// 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;` `    ``for` `(``int` `i = 1; i < n; i++) {` `      ``result = andOperationBitwise(result, arr[i]);` `    ``}` `    ``Console.WriteLine(result);` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output:

`000100`

Time Complexity: O(n *(length)), where n is the number of binary strings, and length is the length of the longest binary string.
Auxiliary Space: O(length), where length is the length of the longest binary string.

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`

## Javascript

 ``

Output:

`000100`

Time Complexity: O(max(n, length)), where n is the number of binary strings, and length is the length of the longest binary string
Auxiliary Space: O(length), where length is the length of the longest binary string

My Personal Notes arrow_drop_up