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:

C++

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


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
MAX = 32
  
# Function to return the value of 
# the maximized expression 
def maximizeExpression(a, b) : 
  
    result =
  
    # 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

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.