# Minimum bitwise operations to convert given a into b.

Given two positive integer a and b you have to change a to b by applying any of the three operations on binary form of a. You can select ai and aj (any two bits where i!=j) from binary form of a and then perform operation as:

• AND operation as : temp = ai & aj, ai = temp & ai, aj = temp & aj
• OR operation as : temp = ai | aj, ai = temp | ai, aj = temp | aj
• XOR operation as : temp = ai ^ aj, ai = temp ^ ai, aj = temp ^ aj

where & = bitwise AND, | = bitwiese OR and ^ = bitwise XOR.
Find the minimum operation required for conversion of a to b. Also, if conversion of a to b is not possible then print -1.

Examples:

```Input : a = 12 (1100), b = 10 (1010)
Output : 1
Explanation : select a2 and a3 and perform XOR

Input : a = 15 (1111), b = 10 (1010)
Output : -1
Explanation : Conversion from a to b is not possible
```

Explanation : First of all let’s understand the working of all three operation.

1. AND operation as : temp = ai & aj, ai = temp & ai, aj = temp & aj
2. If any of ai or aj is 0 then it makes both as 0 otherwise no effect on ai and aj.

3. OR operation as : temp = ai | aj, ai = temp | ai, aj = temp | aj
4. If any of ai or aj is 1 then it makes both as 1 otherwise no effect on ai and aj.

5. XOR operation as : temp = ai ^ aj, ai = temp ^ ai, aj = temp ^ aj
6. Simply interchange value of ai and aj.

Some conclusion on basis of working of operations :

1. If all bits of a are 1 or 0 then we can not change value of a.
2. If a equals to b then no operation required.
3. Let n be number of indices i, where ai = 0 and bi = 1.
Let m be number of indices i, where ai = 1 and bi = 0.

Let us think about the n elements, where ai = 0 and bi = 1. We have to change all of these zeros into ones. Note that this will require at least n operations.
Similarly for all the m elements, where ai = 1 and bi = 0. We have to change all of these ones into zeros. Note that this will require at least m operations.

Let res = max(n, m). We can make the a an b equal in res operations as follows.

Let n >= m. Take m 1’s and n 0’s in A and apply the XOR operation to swap 0’s with 1’s. After that you will be left with total n-m zeros elements to change to one. That you can do by taking each of these zeros with some single one and applying the OR operation.
Let m >= n. Take m 1’s and n 0’s in A and apply the XOR operation to swap 0’s with 1’s. After that you will be left with total m-n ones elements to change to zero. That you can do by taking each of these ones with some single zero and applying the OR operation.

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

 `// Cpp program to find min operation to convert a to b ` `#include ` `using` `namespace` `std; ` ` `  `// function to return min operation ` `int` `minOp(bitset<32> a1, bitset<32> b1) ` `{ ` `    ``// if a1 == b1 return 0 ` `    ``if` `(a1 == b1) ` `        ``return` `0; ` ` `  `    ``// if all bits of a = 0 ` `    ``if` `(a1 == 0) ` `        ``return` `-1; ` ` `  `    ``// if all bits of a =1 ` `    ``// first convert a1 to int and then cal a1 & a1+1 ` `    ``if` `(((``int``)a1.to_ulong() & ((``int``)a1.to_ulong() + 1))  ` `                                               ``== 0) ` `        ``return` `-1; ` ` `  `    ``// convert a and b to binary string ` `    ``string a = a1.to_string(); ` `    ``string b = b1.to_string(); ` ` `  `    ``// check where ai and bi are different ` `    ``// and count n where ai = 1 and m where ai = 0 ` `    ``int` `n = 0, m = 0; ` `    ``for` `(``int` `i = 0; i < b.size(); i++) { ` `        ``if` `(b[i] != a[i]) { ` `            ``if` `(a[i] == ``'1'``) ` `                ``n++; ` `            ``else` `                ``m++; ` `        ``} ` `    ``} ` ` `  `    ``// return result ` `    ``return` `max(n, m); ` `} ` ` `  `// driver program ` `int` `main() ` `{ ` `    ``bitset<32> a = 14, b = 1; ` `    ``cout << minOp(a, b); ` `    ``return` `0; ` `} `

Output:

```3
```