# Find a pair of numbers with set bit count as at most that of N and whose Bitwise XOR is N

• Difficulty Level : Medium
• Last Updated : 02 Sep, 2021

Given a positive integer N, the task is to find the pair of integers (X, Y) such that the Bitwise XOR of X and Y is N and X * Y is maximum where the count of bits in X and Y is less than or equal to N.

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: N = 10
Output: 13 7
Explanation: The case where X = 13 and Y = 7 is the most optimal choice as 13 xor 7 = 10 and 13 * 7 = 91 which is maximum possible.

Input: N = 45
Output: 50 31

Approach: The given problem can be solved using the following observations:

• If the ith bit of N is 0, then the ith bit of both X and Y must be either 0 or 1. In order to maximize the product, set such bits as 1.
• If the ith bit of N is 1, then one of the ith bits of X or Y must be 1 and the other must be 0. Since N must have a constant number of set bits, therefore the sum of X and Y must be constant.
• If the sum of two numbers is constant, their product is maximum when the difference between the two numbers is minimized.

According to the above observations, initialize two integers X and Y as 0. In order to minimize the difference between X and Y, X must be equal to the MSBN and Y must be equal to N – MSBN where MSB represents the Most Significant Bit. Also, for all the 0 bits in N, set the respective bits in both X and Y as 1

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the pair (X, Y) such` `// that X xor Y = N and the count of set` `// bits in X and Y is less than count of` `// set bit in N` `void` `maximizeProduct(``int` `N)` `{` `    ``// Stores MSB (Most Significant Bit)` `    ``int` `MSB = (``int``)log2(N);`   `    ``// Stores the value of X` `    ``int` `X = 1 << MSB;`   `    ``// Stores the value of Y` `    ``int` `Y = N - (1 << MSB);`   `    ``// Traversing over all bits of N` `    ``for` `(``int` `i = 0; i < MSB; i++) {`   `        ``// If ith bit of N is 0` `        ``if` `(!(N & (1 << i))) {`   `            ``// Set ith bit of X to 1` `            ``X += 1 << i;`   `            ``// Set ith bit of Y to 1` `            ``Y += 1 << i;` `        ``}` `    ``}`   `    ``// Print Answer` `    ``cout << X << ``" "` `<< Y;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 45;` `    ``maximizeProduct(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG` `{`   `// Function to find the pair (X, Y) such` `// that X xor Y = N and the count of set` `// bits in X and Y is less than count of` `// set bit in N` `static` `void` `maximizeProduct(``int` `N)` `{` `    ``// Stores MSB (Most Significant Bit)` `    ``int` `MSB = (``int``)(Math.log(N) / Math.log(``2``));` `  `  `    ``// Stores the value of X` `    ``int` `X = ``1` `<< MSB;` `  `  `    ``// Stores the value of Y` `    ``int` `Y = N - (``1` `<< MSB);` `  `  `    ``// Traversing over all bits of N` `    ``for` `(``int` `i = ``0``; i < MSB; i++) {` `  `  `        ``// If ith bit of N is 0` `        ``if` `((N & (``1` `<< i))==``0``) {` `  `  `            ``// Set ith bit of X to 1` `            ``X += ``1` `<< i;` `  `  `            ``// Set ith bit of Y to 1` `            ``Y += ``1` `<< i;` `        ``}` `    ``}` `  `  `    ``// Print Answer` `    ``System.out.println(X+``" "``+Y);` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``45``;` `    ``maximizeProduct(N);` `}` `}`   `// This code is contributed by dwivediyash`

## Python3

 `# python 3 program for the above approach` `import` `math`   `# Function to find the pair (X, Y) such` `# that X xor Y = N and the count of set` `# bits in X and Y is less than count of` `# set bit in N` `def` `maximizeProduct(N):`   `    ``# Stores MSB (Most Significant Bit)` `    ``MSB ``=` `(``int``)(math.log2(N))`   `    ``# Stores the value of X` `    ``X ``=` `1` `<< MSB`   `    ``# / Stores the value of Y` `    ``Y ``=` `N ``-` `(``1` `<< MSB)`   `    ``# Traversing over all bits of N` `    ``for` `i ``in` `range``(MSB):`   `        ``# If ith bit of N is 0` `        ``if` `(``not` `(N & (``1` `<< i))):`   `            ``# / Set ith bit of X to 1` `            ``X ``+``=` `1` `<< i`   `            ``# Set ith bit of Y to 1` `            ``Y ``+``=` `1` `<< i`   `    ``# Print Answer` `    ``print``(X, Y)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `45` `    ``maximizeProduct(N)`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG {`   `// Function to find the pair (X, Y) such` `// that X xor Y = N and the count of set` `// bits in X and Y is less than count of` `// set bit in N` `static` `void` `maximizeProduct(``int` `N)` `{` `  `  `    ``// Stores MSB (Most Significant Bit)` `    ``int` `MSB = (``int``)(Math.Log(N) / Math.Log(2));` `  `  `    ``// Stores the value of X` `    ``int` `X = 1 << MSB;` `  `  `    ``// Stores the value of Y` `    ``int` `Y = N - (1 << MSB);` `  `  `    ``// Traversing over all bits of N` `    ``for` `(``int` `i = 0; i < MSB; i++) {` `  `  `        ``// If ith bit of N is 0` `        ``if` `((N & (1 << i))==0) {` `  `  `            ``// Set ith bit of X to 1` `            ``X += 1 << i;` `  `  `            ``// Set ith bit of Y to 1` `            ``Y += 1 << i;` `        ``}` `    ``}` `  `  `    ``// Print Answer` `    ``Console.Write(X+``" "``+Y);` `}`     `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `N = 45;` `        ``maximizeProduct(N);` `    ``}` `}`   `// This code is contributed by code_hunt.`

## Javascript

 ``

Output:

`50 31`

Time Complexity: O(log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :