Largest number M having bit count of N such that difference between their OR and XOR value is maximized

Given a natural number N, the task is to find the largest number M having the same length in binary representation as N such that the difference between N | M and N ^ M is maximum.

Examples:

Input: N = 6
Output: 7
Explanation:
All number numbers having same length in binary representation as N are 4, 5, 6, 7.
(6 | 4) – (6 ^ 4) = 4
(6 | 5) – (6 ^ 5) = 4
(6 | 6) – (6 ^ 6) = 6
(6 | 7) – (6 ^ 7) = 6
Hence, largest M for which (N | M) – (N ^ M) is maximum is 7

Input: N = 10
Output: 15
Explanation:
The largest number M = 15 which has the same length in binary representation as 10 and the difference between N | M and N ^ M is maximum.

Naive Approach: The idea is to simply find all the numbers having the same length in binary representation as N and then for every number iterate and find the largest integer having (N | i) – (N ^ i) maximum.

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

Efficient Approach: The idea is to initialize M = 0 and iterate bit by bit in N (say i) and set or unset the ith bit of M according to the following 2 observations :

• When an ith bit of N is set: In this case, if we unset the ith bit of M, ith bit of both N | M and N^M will be set whereas on setting this bit of M, an ith bit of N|M will be set and N^M will be unset which will increase (N | M) – (N ^ M). Hence, it is optimal to set this bit of M.
• When an ith bit of N is unset: In this case, if we set this bit of M, both N|M and N^M will have this bit set or on keeping this bit of M unset both N|M and N^M will have this bit unset. So, in this case, we cannot increase the difference between them but as the requirement is to output the maximum M possible, so set this bit of M.
• From the above observations, it is clear that M will have all the bits set.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the largest number``// M having the same length in binary``// form as N such that the difference``// between N | M and N ^ M is maximum``int` `maxORminusXOR(``int` `N)``{``    ``// Find the most significant``    ``// bit of N``    ``int` `MSB = log2(N);` `    ``// Initialize M``    ``int` `M = 0;` `    ``// Set all the bits of M``    ``for` `(``int` `i = 0; i <= MSB; i++)``        ``M += (1 << i);` `    ``// Return the answer``    ``return` `M;``}` `// Driver Code``int` `main()``{``    ``// Given Number N``    ``int` `N = 10;` `    ``// Function Call``    ``cout << maxORminusXOR(N);``    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the largest number``// M having the same length in binary``// form as N such that the difference``// between N | M and N ^ M is maximum``static` `int` `maxORminusXOR(``int` `N)``{``    ` `    ``// Find the most significant``    ``// bit of N``    ``int` `MSB = (``int``)Math.ceil(Math.log(N));` `    ``// Initialize M``    ``int` `M = ``0``;` `    ``// Set all the bits of M``    ``for``(``int` `i = ``0``; i <= MSB; i++)``        ``M += (``1` `<< i);` `    ``// Return the answer``    ``return` `M;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given number N``    ``int` `N = ``10``;` `    ``// Function call``    ``System.out.print(maxORminusXOR(N));``}``}` `// This code is contributed by Rajput-Ji`

Python3

 `# Python3 program for the above approach``import` `math` `# Function to find the largest number``# M having the same length in binary``# form as N such that the difference``# between N | M and N ^ M is maximum``def` `maxORminusXOR(N):` `    ``# Find the most significant``    ``# bit of N``    ``MSB ``=` `int``(math.log2(N));` `    ``# Initialize M``    ``M ``=` `0` `    ``# Set all the bits of M``    ``for` `i ``in` `range``(MSB ``+` `1``):``        ``M ``+``=` `(``1` `<< i)` `    ``# Return the answer``    ``return` `M` `# Driver code``if` `__name__ ``=``=` `'__main__'``: ``    ` `    ``# Given Number N``    ``N ``=` `10` `    ``# Function call``    ``print``(maxORminusXOR(N))` `# This code is contributed by jana_sayantan`

C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the largest number``// M having the same length in binary``// form as N such that the difference``// between N | M and N ^ M is maximum``static` `int` `maxORminusXOR(``int` `N)``{``    ` `    ``// Find the most significant``    ``// bit of N``    ``int` `MSB = (``int``)Math.Ceiling(Math.Log(N));` `    ``// Initialize M``    ``int` `M = 0;` `    ``// Set all the bits of M``    ``for``(``int` `i = 0; i <= MSB; i++)``        ``M += (1 << i);` `    ``// Return the answer``    ``return` `M;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given number N``    ``int` `N = 10;` `    ``// Function call``    ``Console.Write(maxORminusXOR(N));``}``}` `// This code is contributed by 29AjayKumar`

Javascript

 ``

Output:
`15`

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

Previous
Next