# 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++ 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 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 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# 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 `

Output:
```15
```

Time Complexity: O(log N)
Auxiliary Space: O(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.