# 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 = 4Output: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 = 13Output: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:

`// 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*

*filter_none*

**Output:**

15

## Recommended Posts:

- Array Manipulation and Sum
- Bit manipulation | Swap Endianness of a number
- Bits manipulation (Important tactics)
- Maximize the value of x + y + z such that ax + by + cz = n
- Maximize the number of subarrays with XOR as zero
- Maximize big when both big and small can be exchanged
- Maximize the bitwise OR of an array
- Maximize the product of four factors of a Number
- Burst Balloon to maximize coins
- Maximize the number of sum pairs which are divisible by K
- Maximize the number by rearranging bits
- Maximize the number of segments of length p, q and r
- Maximize the total profit of all the persons
- Maximize the happiness of the groups on the Trip
- Find a permutation of 2N numbers such that the result of given expression is exactly 2K

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.