# Largest possible value of M not exceeding N having equal Bitwise OR and XOR between them

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 = 5Output:2

5 ^ 4 = 1 and 5 | 4 = 5. Therefore,XORandORbetween them are not equal.

5 ^ 3 = 6 and 5 | 3 = 7. Therefore,XORandORbetween them are not equal.

5 ^ 2 = 7 and 5 | 2 = 7. Therefore,XORandORbetween them are equal.Input:N = 14Output:1

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

- If the
**i**of^{th}bit**N**is**1**then:- If the
**i**of^{th}bit**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
**i**is set of^{th}bit**M**to**0**, then**N^M**will be equal to**N|M**as**(1^0 = 1)**and**(1|0 = 1)**. - So if the
**i**of^{th}bit**N**is**1**, set the**i**of^{th}bit**M**to**0**.

- If the
- If the
**i**of^{th}bit**N**is**0**then:- If the
**i**of^{th}bit**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
**i**of^{th}bit**M**to**0**, then**N^M**will be equal to**N|M**as (**0^0 = 0**) and (**0|0 = 0**). - So, if the
**i**of^{th}bit**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**i**of^{th}bit**M**to**1**.

- If the

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[31] = 1. So M[31] should be set to 0.
- For index 30, N[30] = 0. So M[30] should be set to 1.
- For index 29, N[29] = 1. So M[29] 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 <bits/stdc++.h>` `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` |

## Javascript

`<script>` `// javascript program to implement` `// the above approach ` `// Function to find required` ` ` `// number M` ` ` `function` `equalXORandOR(n) {` ` ` `// Initialising m` ` ` `var` `m = 0;` ` ` `// Finding the index of the` ` ` `// most significant bit of N` ` ` `var` `MSB = parseInt( Math.log(n));` ` ` `// Calculating required number` ` ` `for` `(i = 0; i <= MSB; i++) {` ` ` `if` `((n & (1 << i)) <= 0) {` ` ` `m += (1 << i);` ` ` `}` ` ` `}` ` ` `return` `m;` ` ` `}` ` ` `// Driver Code` ` ` ` ` `var` `n = 14;` ` ` `document.write(equalXORandOR(n));` `// This code contributed by Rajput-Ji` `</script>` |

**Output:**

1

**Time Complexity: **O(log_{2 }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. 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**.