Change bits to make specific OR value

• Difficulty Level : Medium
• Last Updated : 21 Jun, 2018

Given two positive integers A and B, we can change at most K bits in both the numbers to make OR of them equal to a given target number T. In the case of multiple solutions try to keep A as small as possible.

Examples :

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```Input : A = 175,
B = 66,
T = 100,
K = 5
Output : A = 36
B = 64
Initial bits of A = 1010 1111
Changed bits of A = 0010 0100
Initial bits of B = 0100 0010
Changed bits of B = 0100 0000
OR of changed Bits = 0110 0100
Which has decimal value equal to Target T.

Input : A = 175,
B = 66,
T = 100,
K = 4
Output : Not Possible
It is not possible to get OR of
A and B as T, just by changing K bits.
```

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

We can solve this problem by iterating over all bits of A and B and greedily changing them that is,

• If i-th bit of Target T is 0 then set i-th bits of A and B to 0 (if not already)
• If i-th bit of Target T is 1 then we will try to set one of the bits to 1 and we will change i-th bit of B only to 1(if not already) to minimize A.

After above procedure, if changed bits are more than K, then it is not possible to get OR of A and B as T by changing at most K bits.
If changed bits are less than k, then we can further minimize the value of A by using remaining value of K for which we will loop over bits one more time and if at any time,

• i-th A bit is 1 and i-th B bit is 0 then we will make 2 changes and flip both.
• i-th A and B bits are 1 then again we will make 1 change and flip A’s bit.

Total time complexity of above solution will be O(max number of bits).

C++

 `// C++ program to change least bits to``// get desired OR value``#include ``using` `namespace` `std;`` ` `// Returns max of three numbers``int` `max(``int` `a, ``int` `b, ``int` `c)``{``    ``return` `max(a, max(b, c));``}`` ` `// Returns count of bits in N``int` `bitCount(``int` `N)``{``    ``int` `cnt = 0;``    ``while` `(N)``    ``{``        ``cnt++;``        ``N >>= 1;``    ``}``    ``return` `cnt;``}`` ` `// Returns bit at 'pos' position``bool` `at_position(``int` `num, ``int` `pos)``{``    ``bool` `bit = num & (1<= 0; i--)``    ``{``        ``bool` `bitA = at_position(A, i);``        ``bool` `bitB = at_position(B, i);``        ``bool` `bitT = at_position(T, i);`` ` `        ``// T's bit is set, try to toggle bit``        ``// of B, if not already``        ``if` `(bitT)``        ``{``            ``if` `(!bitA && !bitB)``            ``{``                ``toggle(B, i);``                ``K--;``            ``}``        ``}``        ``else``        ``{``            ``//    if A's bit is set, flip that``            ``if` `(bitA)``            ``{``                ``toggle(A, i);``                ``K--;``            ``}`` ` `            ``//    if B's bit is set, flip that``            ``if` `(bitB)``            ``{``                ``toggle(B, i);``                ``K--;``            ``}``        ``}``    ``}`` ` `    ``//    if K is less than 0 then we can make A|B == T``    ``if` `(K < 0)``    ``{``        ``cout << ``"Not possible\n"``;``        ``return``;``    ``}`` ` `    ``// Loop over bits one more time to minimise``    ``// A further``    ``for` `(``int` `i = maxlen - 1; K > 0 && i >= 0; --i)``    ``{``        ``bool` `bitA = at_position(A, i);``        ``bool` `bitB = at_position(B, i);``        ``bool` `bitT = at_position(T, i);`` ` `        ``if` `(bitT)``        ``{``            ``// If both bit are set, then Unset``            ``// A's bit to minimise it``            ``if` `(bitA && bitB)``            ``{``                ``toggle(A, i);``                ``K--;``            ``}``        ``}`` ` `        ``// If A's bit is 1 and B's bit is 0,``        ``// toggle both``        ``if` `(bitA && !bitB && K >= 2)``        ``{``            ``toggle(A, i);``            ``toggle(B, i);``            ``K -= 2;``        ``}``    ``}`` ` `    ``//    Output changed value of A and B``    ``cout << A << ``" "` `<< B << endl;``}`` ` `// Driver code``int` `main()``{``    ``int` `A = 175, B = 66, K = 5, T = 100;``    ``minChangeToReachTaregetOR(A, B, K, T);``    ``return` `0;``}`

PHP

 `>= 1;``    ``}``    ``return` `\$cnt``;``}`` ` `// Returns bit at 'pos' position``function` `at_position(``\$num``, ``\$pos``)``{``    ``\$bit` `= ``\$num` `& (1 << ``\$pos``);``    ``return` `\$bit``;``}`` ` `// Utility method to toggle``// bit at 'pos' position``function` `toggle(&``\$num``, ``\$pos``)``{``    ``\$num` `^= (1 << ``\$pos``);``}`` ` `// method returns minimum ``// number of bit flip to ``// get T as OR value of A and B``function` `minChangeToReachTaregetOR(``\$A``, ``\$B``,``                                   ``\$K``, ``\$T``)``{``    ``\$maxlen` `= max(bitCount(``\$A``),``                  ``bitCount(``\$B``),``                  ``bitCount(``\$T``));`` ` `    ``// Loop over maximum number ``    ``// of bits among A, B and T``    ``for` `( ``\$i` `= ``\$maxlen` `- 1; ``\$i` `>= 0; ``\$i``--)``    ``{``        ``\$bitA` `= at_position(``\$A``, ``\$i``);``        ``\$bitB` `= at_position(``\$B``, ``\$i``);``        ``\$bitT` `= at_position(``\$T``, ``\$i``);`` ` `        ``// T's bit is set, try to toggle``        ``// bit of B, if not already``        ``if` `(``\$bitT``)``        ``{``            ``if` `(!``\$bitA` `&& !``\$bitB``)``            ``{``                ``toggle(``\$B``, ``\$i``);``                ``\$K``--;``            ``}``        ``}``        ``else``        ``{``            ``// if A's bit is set, ``            ``// flip that``            ``if` `(``\$bitA``)``            ``{``                ``toggle(``\$A``, ``\$i``);``                ``\$K``--;``            ``}`` ` `            ``// if B's bit is set,``            ``// flip that``            ``if` `(``\$bitB``)``            ``{``                ``toggle(``\$B``, ``\$i``);``                ``\$K``--;``            ``}``        ``}``    ``}`` ` `    ``// if K is less than 0 then``    ``// we can make A|B == T``    ``if` `(``\$K` `< 0)``    ``{``    ``echo` `"Not possible\n"``;``        ``return``;``    ``}`` ` `    ``// Loop over bits one more ``    ``// time to minimise A further``    ``for` `(``\$i` `= ``\$maxlen` `- 1; ``         ``\$K` `> 0 && ``\$i` `>= 0; --``\$i``)``    ``{``        ``\$bitA` `= at_position(``\$A``, ``\$i``);``        ``\$bitB` `= at_position(``\$B``, ``\$i``);``        ``\$bitT` `= at_position(``\$T``, ``\$i``);`` ` `        ``if` `(``\$bitT``)``        ``{``            ``// If both bit are set, then ``            ``// Unset A's bit to minimise it``            ``if` `(``\$bitA` `&& ``\$bitB``)``            ``{``                ``toggle(``\$A``, ``\$i``);``                ``\$K``--;``            ``}``        ``}`` ` `        ``// If A's bit is 1 and B's ``        ``// bit is 0, toggle both``        ``if` `(``\$bitA` `&& !``\$bitB` `&& ``\$K` `>= 2)``        ``{``            ``toggle(``\$A``, ``\$i``);``            ``toggle(``\$B``, ``\$i``);``            ``\$K` `-= 2;``        ``}``    ``}`` ` `    ``// Output changed value``    ``// of A and B``    ``echo` `\$A` `, ``" "` `, ``\$B` `, ``"\n"``;``}`` ` `// Driver Code``\$A` `= 175;``\$B` `= 66;``\$K` `= 5;``\$T` `= 100;``minChangeToReachTaregetOR(``\$A``, ``\$B``, ``\$K``, ``\$T``);`` ` `// This code is contributed by ajit``?>`

Output :
```36 64
```

This article is contributed by Utkarsh Trivedi. 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.