Maximize the Expression | Bit Manipulation

Given two positive integers A and B. Let’s define D such that B AND D = D. The task is to maximize the expression A XOR D.

Examples:

Input: A = 11 B = 4
Output: 15
Take D = 4 as (B AND D) = (4 AND 4) = 4.
Also, (A XOR D) = (11 XOR 4) = 15 which is the 
maximum according to the given condition.

Input: A = 9 and B = 13
Output: 13

Naive approach: Since B AND D = D, D will always be smaller than or equal to B. Hence, one can run a loop from 1 to B and check whether the given conditions are satisfied or not.



Efficient approach: Instead of running a loop and checking for each D, the maximum value of the expression (A XOR D) can be easily calculated using Bit Manipulation techniques.
Let’s take an example to understand the way to approach the problem:

A = 11 = 1011, B = 14 = 1110
Let's assume D = abcd in base 2 notation

B AND D:     1110           A XOR D:     1011
             abcd                        abcd   
            ------                      ------
             abcd                        ????

At 0th place: (0 AND d) = d implies d = 0 
At 1st place: (1 AND c) = c implies c = 0, 1 but to maximize (A XOR D), take c = 0
At 2nd place: (1 AND b) = b implies b = 0, 1 but to maximize (A XOR D), take b = 1
At 3rd place: (1 AND a) = a implies a = 0, 1 but to maximize (A XOR D), take a = 0

Hence, D = 0100 = 4 and maximum value of (A XOR D) = (11 XOR 4) = 15.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
using namespace std;
  
#define MAX 32
  
// Function to return the value of
// the maximized expression
int maximizeExpression(int a, int b)
{
    int result = a;
  
    // int can have 32 bits
    for (int bit = MAX - 1; bit >= 0; bit--) {
  
        // Consider the ith bit of D to be 1
        int bitOfD = 1 << bit;
  
        // Calculate the value of (B AND bitOfD)
        int x = b & bitOfD;
  
        // Check if bitOfD satisfies (B AND D = D)
        if (x == bitOfD) {
  
            // Check if bitOfD can maximize (A XOR D)
            int y = result & bitOfD;
            if (y == 0) {
                result = result ^ bitOfD;
            }
        }
  
        // Note that we do not need to consider ith bit of D
        // to be 0 because if above condition are not satisfied
        // then value of result will not change
        // which is similar to considering bitOfD = 0
        // as result XOR 0 = result
    }
  
    return result;
}
  
// Driver code
int main()
{
    int a = 11, b = 14;
  
    cout << maximizeExpression(a, b);
  
    return 0;
}

chevron_right


Output:

15


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.