Related Articles
Given two binary strings perform operation until B > 0 and print the result
• Last Updated : 01 Jun, 2021

Given two binary strings A and B of length N and M (up to 105). The task is to repeat the below process and find the answer.

```Initialize ans = 0
while (B > 0)
ans += A & B (bitwise AND)
B = B / 2
print ans```

Examples:

```Input: A = "1001", B = "10101"
Output: 11
1001 & 10101 = 1, ans = 1, B = 1010
1001 & 1010 = 8, ans = 9, B = 101
1001 & 101 = 1, ans = 10, B = 10
1001 & 10 = 0, ans = 10, B = 1
1001 & 1 = 1, ans = 11, B = 0

Input: A = "1010", B = "1101"
Output: 12```

Approach: Since only B is getting affected in all the iterations and dividing a binary number by 2 means right shifting it by 1 bit, it can be observed that a bit in A will only be affected by the set bits in B which are on the left i.e. more significant than the current bit (including the current bit). For example, A = “1001” and B = “10101”, the least significant bit in A will only be affected by the set bits in B i.e. 3 bits in total and the most significant bit in A will only be affected by a single set bit in B i.e. the most significant bit in B as all the other set bits will not affect it in any iteration of the loop while performing bitwise AND, so the final result will be 20 * 3 + 23 * 1 = 3 + 8 = 11.
Below is the implementation of the above approach.

C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define ll long long``#define mod (int)(1e9 + 7)` `// Function to return the required result``ll BitOperations(string a, ``int` `n, string b, ``int` `m)``{` `    ``// Reverse the strings``    ``reverse(a.begin(), a.end());``    ``reverse(b.begin(), b.end());` `    ``// Count the number of set bits in b``    ``int` `c = 0;``    ``for` `(``int` `i = 0; i < m; i++)``        ``if` `(b[i] == ``'1'``)``            ``c++;` `    ``// To store the powers of 2``    ``ll power[n];``    ``power[0] = 1;` `    ``// power[i] = pow(2, i) % mod``    ``for` `(``int` `i = 1; i < n; i++)``        ``power[i] = (power[i - 1] * 2) % mod;` `    ``// To store the final answer``    ``ll ans = 0;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(a[i] == ``'1'``) {` `            ``// Add power[i] to the ans after``            ``// multiplying it with the number``            ``// of set bits in b``            ``ans += c * power[i];``            ``if` `(ans >= mod)``                ``ans %= mod;``        ``}` `        ``// Divide by 2 means right shift b>>1``        ``// if b has 1 at right most side than``        ``// number of set bits will get decreased``        ``if` `(b[i] == ``'1'``)``            ``c--;` `        ``// If no more set bits in b i.e. b = 0``        ``if` `(c == 0)``            ``break``;``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``string a = ``"1001"``, b = ``"10101"``;``    ``int` `n = a.length(), m = b.length();` `    ``cout << BitOperations(a, n, b, m);` `    ``return` `0;``}`

Java

 `// Java implementation of the approach``class` `GFG``{``    ` `static` `int` `mod = (``int``)(1e9 + ``7``);` `// Function to return the required result``static` `int` `BitOperations(String a,``            ``int` `n, String b, ``int` `m)``{` `    ``// Reverse the strings``    ``char``[] ch1 = a.toCharArray();``    ``reverse( ch1 );``    ``a = ``new` `String( ch1 );``    ``char``[] ch2 = b.toCharArray();``    ``reverse( ch2 );``    ``b = ``new` `String( ch2 );` `    ``// Count the number of set bits in b``    ``int` `c = ``0``;``    ``for` `(``int` `i = ``0``; i < m; i++)``        ``if` `(b.charAt(i) == ``'1'``)``            ``c++;` `    ``// To store the powers of 2``    ``int``[] power = ``new` `int``[n];``    ``power[``0``] = ``1``;` `    ``// power[i] = pow(2, i) % mod``    ``for` `(``int` `i = ``1``; i < n; i++)``        ``power[i] = (power[i - ``1``] * ``2``) % mod;` `    ``// To store the final answer``    ``int` `ans = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(a.charAt(i) == ``'1'``)``        ``{` `            ``// Add power[i] to the ans after``            ``// multiplying it with the number``            ``// of set bits in b``            ``ans += c * power[i];``            ``if` `(ans >= mod)``                ``ans %= mod;``        ``}` `        ``// Divide by 2 means right shift b>>1``        ``// if b has 1 at right most side than``        ``// number of set bits will get decreased``        ``if` `(b.charAt(i) == ``'1'``)``            ``c--;` `        ``// If no more set bits in b i.e. b = 0``        ``if` `(c == ``0``)``            ``break``;``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `static` `void` `reverse(``char` `a[])``{``    ``int` `i, k,n=a.length;``    ``char` `t;``    ``for` `(i = ``0``; i < n / ``2``; i++)``    ``{``        ``t = a[i];``        ``a[i] = a[n - i - ``1``];``        ``a[n - i - ``1``] = t;``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``String a = ``"1001"``, b = ``"10101"``;``    ``int` `n = a.length(), m = b.length();` `    ``System.out.println(BitOperations(a, n, b, m));``}``}` `// This code contributed by Rajput-Ji`

Python3

 `# Python 3 implementation of the approach``mod ``=` `1000000007` `# Function to return the required result``def` `BitOperations(a, n, b, m):``    ` `    ``# Reverse the strings``    ``a ``=` `a[::``-``1``]``    ``b ``=` `b[::``-``1``]``    ` `    ``# Count the number of set``    ``# bits in b``    ``c ``=` `0``    ``for` `i ``in` `range``(m):``        ``if` `(b[i] ``=``=` `'1'``):``            ``c ``+``=` `1` `    ``# To store the powers of 2``    ``power ``=` `[``None``] ``*` `n``    ``power[``0``] ``=` `1` `    ``# power[i] = pow(2, i) % mod``    ``for` `i ``in` `range``(``1``, n):``        ``power[i] ``=` `(power[i ``-` `1``] ``*` `2``) ``%` `mod` `    ``# To store the final answer``    ``ans ``=` `0``    ``for` `i ``in` `range``(``0``, n):``        ``if` `(a[i] ``=``=` `'1'``):``            ` `            ``# Add power[i] to the ans after``            ``# multiplying it with the number``            ``# of set bits in b``            ``ans ``+``=` `c ``*` `power[i]``            ``if` `(ans >``=` `mod):``                ``ans ``%``=` `mod` `        ``# Divide by 2 means right shift b>>1``        ``# if b has 1 at right most side than``        ``# number of set bits will get decreased``        ``if` `(b[i] ``=``=` `'1'``):``            ``c ``-``=` `1``            ` `        ``# If no more set bits in b i.e. b = 0``        ``if` `(c ``=``=` `0``):``            ``break` `    ``# Return the required answer``    ``return` `ans` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``a ``=` `"1001"``    ``b ``=` `"10101"``    ``n ``=` `len``(a)``    ``m ``=` `len``(b)` `    ``print``(BitOperations(a, n, b, m))` `# This code is contributed by``# Surendra_Gangwar`

C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections;` `class` `GFG``{``    ` `static` `int` `mod = (``int``)(1e9 + 7);` `// Function to return the required result``static` `int` `BitOperations(``string` `a,``            ``int` `n, ``string` `b, ``int` `m)``{` `    ``// Reverse the strings``    ``char``[] ch1 = a.ToCharArray();``    ``Array.Reverse( ch1 );``    ``a = ``new` `string``( ch1 );``    ``char``[] ch2 = b.ToCharArray();``    ``Array.Reverse( ch2 );``    ``b = ``new` `string``( ch2 );` `    ``// Count the number of set bits in b``    ``int` `c = 0;``    ``for` `(``int` `i = 0; i < m; i++)``        ``if` `(b[i] == ``'1'``)``            ``c++;` `    ``// To store the powers of 2``    ``int``[] power = ``new` `int``[n];``    ``power[0] = 1;` `    ``// power[i] = pow(2, i) % mod``    ``for` `(``int` `i = 1; i < n; i++)``        ``power[i] = (power[i - 1] * 2) % mod;` `    ``// To store the final answer``    ``int` `ans = 0;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(a[i] == ``'1'``)``        ``{` `            ``// Add power[i] to the ans after``            ``// multiplying it with the number``            ``// of set bits in b``            ``ans += c * power[i];``            ``if` `(ans >= mod)``                ``ans %= mod;``        ``}` `        ``// Divide by 2 means right shift b>>1``        ``// if b has 1 at right most side than``        ``// number of set bits will get decreased``        ``if` `(b[i] == ``'1'``)``            ``c--;` `        ``// If no more set bits in b i.e. b = 0``        ``if` `(c == 0)``            ``break``;``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `// Driver code``static` `void` `Main()``{``    ``string` `a = ``"1001"``, b = ``"10101"``;``    ``int` `n = a.Length, m = b.Length;` `    ``Console.WriteLine(BitOperations(a, n, b, m));``}``}` `// This code is contributed by mits`

PHP

 `= ``\$GLOBALS``[``'mod'``])``                ``\$ans` `%= ``\$GLOBALS``[``'mod'``];``        ``}` `        ``// Divide by 2 means right shift b>>1``        ``// if b has 1 at right most side than``        ``// number of set bits will get decreased``        ``if` `(``\$b``[``\$i``] == ``'1'``)``            ``\$c``--;` `        ``// If no more set bits in b i.e. b = 0``        ``if` `(``\$c` `== 0)``            ``break``;``    ``}` `    ``// Return the required answer``    ``return` `\$ans``;``}` `// Driver code``\$a` `= ``"1001"``;``\$b` `= ``"10101"``;``\$n` `= ``strlen``(``\$a``);``\$m` `= ``strlen``(``\$b``);` `echo` `BitOperations(``\$a``, ``\$n``, ``\$b``, ``\$m``);` `// This code is contributed by Ryuga``?>`

Javascript

 ``
Output:
`11`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up