Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Choose X such that (A xor X) + (B xor X) is minimized

  • Last Updated : 26 Nov, 2021

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: 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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
Time Complexity: O(log(max(A, B)))
Auxiliary Space: O(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 contributed 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 contributed 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
Time Complexity: O(1)
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Next

Find a number X such that (X XOR A) is minimum and the count of set bits in X and B are equal
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
Split the Array in two parts such that maximum product is minimized
22, Nov 21
Partition the array into two odd length groups with minimized absolute difference between their median
26, Feb 20
Generate an N-length array having maximum element minimized and sum of array elements divisible by K
10, May 21
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
Count of subarrays in range [L, R] having XOR + 1 equal to XOR (XOR) 1 for M queries
26, Oct 21
Count of integers K in range [0, N] such that (K XOR K+1) equals (K+2 XOR K+3)
06, Jul 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
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
Count of ways to choose K elements from given Array with maximum sum
22, Jul 21
Find if it is possible to choose subarray that it contains exactly K even integers
13, Apr 20
Minimum operations to choose Array elements with sum as K by choosing element from front, or rear or both
29, Nov 21
Count of Ways to Choose N People Containing at Least 4 Boys and 1 Girl from P Boys and Q Girls | Set 2
30, Nov 21
Count of Ways to Choose N People With at Least X Men and Y Women from P Men and Q Women | Set 2
30, Nov 21
Count of All Possible Ways to Choose N People With at Least X Men and Y Women from P Men and Q Women
29, Nov 21
Count of ways to choose N people containing at least 4 boys and 1 girl from P boys and Q girls
26, Nov 21
Given a set, find XOR of the XOR's of all subsets.
27, Dec 15
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

Start Your Coding Journey Now!