Related Articles
Largest possible value of M not exceeding N having equal Bitwise OR and XOR between them
• Difficulty Level : Easy
• Last Updated : 10 Aug, 2020

Given an integer N, the task is to find the largest number M, where (M < N), such that N(XOR)M is equal to N(OR)M i.e. (N ^ M) = (N | M).

Examples:

Input: N = 5
Output:
5 ^ 4 = 1 and 5 | 4 = 5. Therefore, XOR and OR between them are not equal.
5 ^ 3 = 6 and 5 | 3 = 7. Therefore, XOR and OR between them are not equal.
5 ^ 2 = 7 and 5 | 2 = 7. Therefore, XOR and OR between them are equal.

Input: N = 14
Output:

Approach:
To get the required number M, traverse all the bits of N from its Least Significant Bit (LSB) to Most Significant Bit (MSB). Two cases arise here:

1. If the ith bit of N is 1 then:
• If the ith bit of M is set to 1, then N^M will not be equal to N|M as (1^1 = 0) and (1|1 = 1).
• If the ith bit is set of M to 0, then N^M will be equal to N|M as (1^0 = 1) and (1|0 = 1).
• So if the ith bit of N is 1, set the ith bit of M to 0.
2. If the ith bit of N is 0 then:
• If the ith bit of M is set to 1, then N^M will be equal to N|M as (0^1 = 1) and (0|1 = 1).
• If we set the ith bit of M to 0, then N^M will be equal to N|M as (0^0 = 0) and (0|0 = 0).
• So, if the ith bit of M is set to either 0 or 1, N^M will always be equal to N|M.
• As the largest value of M which is less than N has to be found out, always set the ith bit of M to 1.

Illustration:

• N = 5
• 32-bit representation of 5 = 00000000000000000000000000000101
• LSB index of 5 = 31
• MSB index of 5 = 29
• Traversing from LSB to MSB i.e. from 31 to 29:
• For index 31, N = 1. So M should be set to 0.
• For index 30, N = 0. So M should be set to 1.
• For index 29, N = 1. So M should be set to 0.
• Thus the 32-bit representation of M is 00000000000000000000000000000010, which is equal to 2 in decimal representation.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;`` ` `// Function to find required``// number M``int` `equalXORandOR(``int` `n)``{``    ``// Initialising m``    ``int` `m = 0;`` ` `    ``// Finding the index of the``    ``// most significant bit of N``    ``int` `MSB = (``int``)log2(n);`` ` `    ``// Calculating required number``    ``for` `(``int` `i = 0; i <= MSB; i++) {`` ` `        ``if` `(!(n & (1 << i))) {``            ``m += (1 << i);``        ``}``    ``}`` ` `    ``return` `m;``}`` ` `// Driver Code``int` `main()``{``    ``int` `n = 14;``    ``cout << equalXORandOR(n);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``class` `GFG{`` ` `// Function to find required``// number M``static` `int` `equalXORandOR(``int` `n)``{``     ` `    ``// Initialising m``    ``int` `m = ``0``;`` ` `    ``// Finding the index of the``    ``// most significant bit of N``    ``int` `MSB = (``int``)Math.log(n);`` ` `    ``// Calculating required number``    ``for``(``int` `i = ``0``; i <= MSB; i++)``    ``{``        ``if` `((n & (``1` `<< i)) <= ``0``)``        ``{``            ``m += (``1` `<< i);``        ``}``    ``}``    ``return` `m;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``14``;``     ` `    ``System.out.print(equalXORandOR(n));``}``}`` ` `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 program to implement ``# the above approach ``from` `math ``import` `log2`` ` `# Function to find required``# number M``def` `equalXORandOR(n):`` ` `    ``# Initialising m``    ``m ``=` `0`` ` `    ``# Finding the index of the``    ``# most significant bit of N``    ``MSB ``=` `int``(log2(n))`` ` `    ``# Calculating required number``    ``for` `i ``in` `range``(MSB ``+` `1``):``        ``if``(``not``(n & (``1` `<< i))):``            ``m ``+``=` `(``1` `<< i)`` ` `    ``return` `m`` ` `# Driver Code``n ``=` `14`` ` `# Function call``print``(equalXORandOR(n))`` ` `# This code is contributed by Shivam Singh`

## C#

 `// C# program to implement``// the above approach``using` `System;`` ` `class` `GFG{`` ` `// Function to find required``// number M``static` `int` `equalXORandOR(``int` `n)``{``     ` `    ``// Initialising m``    ``int` `m = 0;`` ` `    ``// Finding the index of the``    ``// most significant bit of N``    ``int` `MSB = (``int``)Math.Log(n);`` ` `    ``// Calculating required number``    ``for``(``int` `i = 0; i <= MSB; i++)``    ``{``        ``if` `((n & (1 << i)) <= 0)``        ``{``            ``m += (1 << i);``        ``}``    ``}``    ``return` `m;``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 14;``     ` `    ``Console.Write(equalXORandOR(n));``}``}`` ` `// This code is contributed by amal kumar choubey`
Output:
```1
```

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up