Related Articles
Maximize the Expression | Bit Manipulation
• Difficulty Level : Medium
• Last Updated : 26 Apr, 2021

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:

## C++

 `// C++ implementation of the approach``#include ``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;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ``final` `static` `int` `MAX = ``32``;``    ` `    ``// Function to return the value of``    ``// the maximized expression``    ``static` `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``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `a = ``11``, b = ``14``;``    ` `        ``System.out.println(maximizeExpression(a, b));``    ``}``}` `// This code is contributed by AnkitRai01`

## Python3

 `# Python3 implementation of the approach``MAX` `=` `32` `# Function to return the value of``# the maximized expression``def` `maximizeExpression(a, b) :` `    ``result ``=` `a` `    ``# int can have 32 bits``    ``for` `bit ``in` `range``(``MAX` `-` `1``, ``-``1``, ``-``1``) :` `        ``# Consider the ith bit of D to be 1``        ``bitOfD ``=` `1` `<< bit` `        ``# Calculate the value of (B AND bitOfD)``        ``x ``=` `b & bitOfD` `        ``# Check if bitOfD satisfies (B AND D = D)``        ``if` `(x ``=``=` `bitOfD) :` `            ``# Check if bitOfD can maximize (A XOR D)``            ``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``a ``=` `11``b ``=` `14``print``(maximizeExpression(a, b))` `# This code is contributed by divyamohan123`

## C#

 `// C# implementation of the above approach``using` `System;``class` `GFG``{``    ``static` `int` `MAX = 32;``    ` `    ``// Function to return the value of``    ``// the maximized expression``    ``static` `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``    ``public` `static` `void` `Main (String []args)``    ``{``        ``int` `a = 11, b = 14;``    ` `        ``Console.WriteLine(maximizeExpression(a, b));``    ``}``}` `// This code is contributed by Arnab Kundu`

## Javascript

 ``
Output:
`15`

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.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up