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 = 6Output:7Explanation:

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 = 10Output:15Explanation:

The largest number M = 15 which has the same length in binary representation as 10 and the difference betweenN |MandN ^ Mis 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** i ^{th}** bit of

**M**according to the following 2 observations :

- When an i
^{th}bit of N is**set**: In this case, if we**unset**the i^{th}bit of M, i^{th}bit of both**N | M**and**N^M**will be set whereas on setting this bit of M, an i^{th}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 i
^{th}bit of N is**unset:**In this case, if we**set**this bit of**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 <bits/stdc++.h> ` `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; `
`} ` |

*chevron_right*

*filter_none*

`// 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 ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

`// 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 ` |

*chevron_right*

*filter_none*

**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.