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:
- 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.
- 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[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++ 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 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 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# 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 |
<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> |
1
Time Complexity: O(log2 N)
Auxiliary Space: O(1)