# 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++ program to change least bits to
// get desired OR value
#include <bits/stdc++.h>
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<<pos);
return bit;
}

//	Utility method to toggle bit at
// 'pos' position
void toggle(int &num,int pos)
{
num ^= (1 << pos);
}

//	method returns minimum number of bit flip
// to get T as OR value of A and B
void minChangeToReachTaregetOR(int A, int B,
int K, int T)
{
int maxlen = max(bitCount(A), bitCount(B),
bitCount(T));

// Loop over maximum number of bits among
// A, B and T
for (int i = maxlen - 1; i >= 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;
}
```

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.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3 Average Difficulty : 3/5.0
Based on 2 vote(s)