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

1. If the i^th bit of N is 1 then: 
   • If the i^th 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 i^th 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 i^th bit of N is 1, set the i^th bit of M to 0.
2. If the i^th bit of N is 0 then: 
   • If the i^th 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 i^th 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 i^th 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 i^th 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[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₂ N) 
Auxiliary Space: O(1)