# Change bits to make specific OR value

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 :

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

My Personal Notes arrow_drop_up

Improved By : jit_t

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.