Skip to content
Related Articles

Related Articles

Choose X such that (A xor X) + (B xor X) is minimized
  • Last Updated : 13 Apr, 2021
GeeksforGeeks - Summer Carnival Banner

Given two integers A and B. The task is to choose an integer X such that (A xor X) + (B xor X) is the minimum possible.

Examples: 

Input: A = 2, B = 3 
Output: X = 2, Sum = 1

Input: A = 7, B = 8 
Output: X = 0, Sum = 15 

A simple solution is to generate all possible sum by taking xor of A and B with all possible values of X ≤ min(A, B). To generate all possible sums it would take O(N) time where N = min(A, B). 



An efficient solution is based on the fact that the number X will contain the set bits only at that index where both A and B contain a set bit such that after xor operation with X that bit will be unset. This would take only O(Log N) time.
Other cases: If at a particular index one or both the numbers contain 0 (unset bit) and the number X contains 1 (set bit) then 0 will be set after xor with X in A and B then the sum couldn’t be minimized.

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Function to return the integer X such that
// (A xor X) + (B ^ X) is minimized
int findX(int A, int B)
{
    int j = 0, x = 0;
 
    // While either A or B is non-zero
    while (A || B) {
 
        // Position at which both A and B
        // have a set bit
        if ((A & 1) && (B & 1)) {
 
            // Inserting a set bit in x
            x += (1 << j);
        }
 
        // Right shifting both numbers to
        // traverse all the bits
        A >>= 1;
        B >>= 1;
        j += 1;
    }
    return x;
}
 
// Driver code
int main()
{
    int A = 2, B = 3;
    int X = findX(A, B);
 
    cout << "X = " << X << ", Sum = " << (A ^ X) + (B ^ X);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG {
 
    // Function to return the integer X such that
    // (A xor X) + (B ^ X) is minimized
    static int findX(int A, int B)
    {
        int j = 0, x = 0;
 
        // While either A or B is non-zero
        while (A != 0 || B != 0) {
 
            // Position at which both A and B
            // have a set bit
            if ((A % 2 == 1) && (B % 2 == 1)) {
 
                // Inserting a set bit in x
                x += (1 << j);
            }
 
            // Right shifting both numbers to
            // traverse all the bits
            A >>= 1;
            B >>= 1;
            j += 1;
        }
        return x;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int A = 2, B = 3;
        int X = findX(A, B);
 
        System.out.println(
            "X = " + X + ", Sum = " + ((A ^ X) + (B ^ X)));
    }
}
 
// This code has been contributed by 29AjayKumar
Python3



# Python 3 implementation of the approach
 
# Function to return the integer X such that
# (A xor X) + (B ^ X) is minimized
 
 
def findX(A, B):
    j = 0
    x = 0
 
    # While either A or B is non-zero
    while (A or B):
 
        # Position at which both A and B
        # have a set bit
        if ((A & 1) and (B & 1)):
 
            # Inserting a set bit in x
            x += (1 << j)
 
        # Right shifting both numbers to
        # traverse all the bits
        A >>= 1
        B >>= 1
        j += 1
    return x
 
 
# Driver code
if __name__ == '__main__':
    A = 2
    B = 3
    X = findX(A, B)
 
    print("X =", X, ", Sum =", (A ^ X) + (B ^ X))
 
# This code is contributed by
# Surendra_Gangwar
C#



// C# implementation of the approach
using System;
 
class GFG {
 
    // Function to return the integer X such that
    // (A xor X) + (B ^ X) is minimized
    static int findX(int A, int B)
    {
        int j = 0, x = 0;
 
        // While either A or B is non-zero
        while (A != 0 || B != 0) {
 
            // Position at which both A and B
            // have a set bit
            if ((A % 2 == 1) && (B % 2 == 1)) {
 
                // Inserting a set bit in x
                x += (1 << j);
            }
 
            // Right shifting both numbers to
            // traverse all the bits
            A >>= 1;
            B >>= 1;
            j += 1;
        }
        return x;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int A = 2, B = 3;
        int X = findX(A, B);
 
        Console.WriteLine(
            "X = " + X + ", Sum = " + ((A ^ X) + (B ^ X)));
    }
}
 
// This code has been contributed by 29AjayKumar
PHP



<?php
// PHP implementation of the approach
 
// Function to return the integer X such that
// (A xor X) + (B ^ X) is minimized
function findX($A, $B)
{
    $j = 0;
    $x = 0;
 
    // While either A or B is non-zero
    while ($A || $B) {
 
        // Position at which both A and B
        // have a set bit
        if (($A & 1) && ($B & 1))
        {
 
            // Inserting a set bit in x
            $x += (1 << $j);
        }
 
        // Right shifting both numbers to
        // traverse all the bits
        $A >>= 1;
        $B >>= 1;
        $j += 1;
    }
    return $x;
}
 
// Driver code
    $A = 2;
    $B = 3;
    $X = findX($A, $B);
 
    echo "X = " , $X , ", Sum = ",
        ($A ^ $X) + ($B ^ $X);
 
// This code is contributed by ajit.
?>
Javascript



<script>
    // Javascript implementation of the approach
     
    // Function to return the integer X such that
    // (A xor X) + (B ^ X) is minimized
    function findX(A, B)
    {
        let j = 0, x = 0;
  
        // While either A or B is non-zero
        while (A != 0 || B != 0) {
  
            // Position at which both A and B
            // have a set bit
            if ((A % 2 == 1) && (B % 2 == 1)) {
  
                // Inserting a set bit in x
                x += (1 << j);
            }
  
            // Right shifting both numbers to
            // traverse all the bits
            A >>= 1;
            B >>= 1;
            j += 1;
        }
        return x;
    }
     
    let A = 2, B = 3;
    let X = findX(A, B);
 
    document.write("X = " + X + ", Sum = " + ((A ^ X) + (B ^ X)));
         
        // This code is contributed by suresh07.
</script>
 
 
Output
X = 2, Sum = 1
 
Most Efficient Approach:
 
Using the idea that X will contain only the set bits as A and B,  X = A & B. On replacing X, the above equation becomes (A ^ (A & B)) + (B ^ (A & B)) which further equates to A^B. 


 
Proof:
Given (A ^ X) + (B ^ X)
Taking X = (A & B), we have 
(A ^ (A & B)) + (B ^ (A & B))
   (using x ^ y = x'y + y'x )
= (A'(A & B) + A(A & B)') + (B'(A & B) + B(A & B)')
   (using (x & y)' = x' + y')
= (A'(A & B) + A(A' + B')) + (B'(A & B) + B(A' + B'))
  (A'(A & B) = A'A & A'B = 0, B'(A & B) 
   = B'A & B'B = 0)
= (A(A' + B')) + (B(A' + B'))                               
= (AA' + AB') + (BA' + BB')
  (using xx' = x'x = 0)                                   
= (AB') + (BA')                                             
= (A ^ B)
 
Click here to know more about Boolean Properties.
 
Below is the implementation of the above approach: 
 
C++



// c++ implementation of above approach
#include <iostream>
using namespace std;
 
// finding X
int findX(int A, int B) {
  return A & B;
}
 
// finding Sum
int findSum(int A, int B) {
  return A ^ B;
}
 
// Driver code
int main()
{
    int A = 2, B = 3;
    cout << "X = " << findX(A, B)
         << ", Sum = " << findSum(A, B);
    return 0;
}
 
// This code is contribued by yashbeersingh42
Java



// Java implementation of above approach
import java.io.*;
 
class GFG
{
    // finding X
    public static int findX(int A, int B)
    {
      return A & B;
    }
 
    // finding Sum
    public static int findSum(int A, int B)
    {
        return A ^ B;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int A = 2, B = 3;
        System.out.print("X = " + findX(A, B)
                         + ", Sum = " + findSum(A, B));
    }
}
// This code is contribued by yashbeersingh42
Python3



# Python3 implementation of above approach
 
# finding X
def findX(A, B):
    return A & B
 
# finding Sum
def findSum(A, B):
    return A ^ B
 
# Driver code
A, B = 2, 3
print("X =", findX(A, B) , ", Sum =" , findSum(A, B))
 
# This code is contributed by divyeshrabadiya07
C#



// C# implementation of above approach
using System;
 
class GFG{
     
// Finding X
public static int findX(int A, int B)
{
    return A & B;
}
 
// Finding Sum
public static int findSum(int A, int B)
{
    return A ^ B;
}
 
// Driver Code
public static void Main(String[] args)
{
    int A = 2, B = 3;
     
    Console.Write("X = " + findX(A, B) +
                  ", Sum = " + findSum(A, B));
}
}
 
// This code is contributed by Princi Singh
Javascript



<script>
 
    // Javascript implementation of the approach
     
    // finding X
    function findX(A, B) {
      return A & B;
    }
      
    // finding Sum
    function findSum(A, B) {
      return A ^ B;
    }
     
    let A = 2, B = 3;
    document.write("X = " + findX(A, B) + ", Sum = " + findSum(A, B));
 
</script>
Output
X = 2, Sum = 1
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.
My Personal Notes
arrow_drop_up
Previous
Check if the robot is within the bounds of the grid after given moves
Next

Smallest multiple of N formed using the given set of digits
Recommended Articles
Page :
Choose an integer K such that maximum of the xor values of K with all Array elements is minimized
23, Apr 20
Find a point such that sum of the Manhattan distances is minimized
04, Oct 18
Delete odd and even numbers at alternate step such that sum of remaining elements is minimized
12, Apr 19
Partition the array into two odd length groups with minimized absolute difference between their median
26, Feb 20
Divide a sorted array in K parts with sum of difference of max and min minimized in each part
12, May 20
Select K elements from an array whose maximum value is minimized
08, Jul 20
Choose points from two ranges such that no point lies in both the ranges
04, Feb 19
Ways to choose balls such that at least one ball is chosen
03, Sep 19
Choose two elements from the given array such that their sum is not present in any of the arrays
28, Oct 19
Number of ways to choose a pair containing an even and an odd number from 1 to N
25, Oct 18
Puzzle | Choose the game of Rolling Dice
20, Jul 20
Find if it is possible to choose subarray that it contains exactly K even integers
13, Apr 20
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Given a set, find XOR of the XOR's of all subsets.
27, Dec 15
Find XOR of two number without using XOR operator
21, Oct 15
Find smallest number n such that n XOR n+1 equals to given k.
11, Sep 17
Count ordered pairs of positive numbers such that their sum is S and XOR is K
26, Oct 18
Number of subarrays such that XOR of one half is equal to the other
18, Feb 19
Check if a number from every row can be selected such that xor of the numbers is greater than zero
22, Apr 19
Find array such that no subarray has xor zero or Y
16, Jul 19
Find a number X such that (X XOR A) is minimum and the count of set bits in X and B are equal
20, Nov 19
Create an array such that XOR of subarrays of length K is X
29, May 20
Find a number M < N such that difference between their XOR and AND is maximum
31, Jul 20
Largest number M having bit count of N such that difference between their OR and XOR value is maximized
15, Aug 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
NikhilRathor
@NikhilRathor
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox