Given an integer N, the task is to find all possible integer M in the range [2, N] such that the bitwise OR of all positive values till M is the same as the bitwise OR of all positive values till M-1.
Examples:
Input: N = 4
Output: 1
Explanation: Bitwise OR till 3 = 1 | 2 | 3 = 3.
Bitwise OR till 2 = 1 | 2 = 3.Input: N = 7
Output: 4
Approach: The approach to solve this problem is based on the following observation:
Consider p(x) to the bitwise OR till x. So p(x) = 1 | 2 | 3 | . . . | (x-1) | x
Given p(x) = 1 | 2 | 3 | . . . | x – 1 | x. Therefore, p(x + 1) will be different from p(x) if there is a new “1” bit in (x + 1) that isn’t present in the binary sequence of p(x).Now, let us observe the pattern:
Decimal Number Binary Number 1 1 2 10 3 11 4 100 5 101 6 110 7 111 8 1000 9 1001 We can see that a new “1” bit that hasn’t previously appeared in the range [1, x] appears at every power of 2.
As such, p(x) = 1 | 2 | 3 | . . . | x – 1 | x
= 2a+1 – 1, where a = log2x.
This implies that, for a given a, there will be ( 2a + 1 – 2a – 1 ) values of x where p(x) = p(x – 1).
Follow the step below to solve this problem:
- Calculate a = log2N.
- Iterate through the powers (say using variable exp) of 2 from 1 to a and increment ans (initially 0) by ( 2 exp + 1 – 2exp – 1 ).
- Finally, count for the pairs between N and 2aby adding (n – 2a) to ans.
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to calculate // total matches in the range int checkXORrange( int n)
{ int ans = 0;
int a = log2(n);
for ( int exp = 1; exp <= a; exp ++)
ans += pow (2, exp ) - pow (2, exp - 1) - 1;
ans += n - pow (2, a);
return ans;
} // Driver code int main()
{ int N = 7;
// Function call
cout << checkXORrange(N) << endl;
return 0;
} |
// C code to implement the approach #include <math.h> #include <stdio.h> // Function to calculate // total matches in the range int checkXORrange( int n)
{ int ans = 0;
int a = log2(n);
for ( int exp = 1; exp <= a; exp ++)
ans += pow (2, exp ) - pow (2, exp - 1) - 1;
ans += n - pow (2, a);
return ans;
} // Driver code int main()
{ int N = 7;
// Function call
printf ( "%d\n" , checkXORrange(N));
return 0;
} |
// Java code to implement the approach import java.io.*;
class GFG {
public static int log2( int N)
{
// calculate log2 N indirectly
// using log() method
int result = ( int )(Math.log(N) / Math.log( 2 ));
return result;
}
// Function to calculate
// total matches in the range
public static int checkXORrange( int n)
{
int ans = 0 ;
int a = log2(n);
for ( int exp = 1 ; exp <= a; exp++)
ans += Math.pow( 2 , exp) - Math.pow( 2 , exp - 1 )
- 1 ;
ans += n - Math.pow( 2 , a);
return ans;
}
// Driver code
public static void main(String[] args)
{
int N = 7 ;
// Function call
System.out.print(checkXORrange(N));
}
} // This code is contributed by Rohit Pradhan |
// C# code to implement the approach using System;
public class GFG {
// Function to calculate
// total matches in the range
public static int checkXORrange( int n)
{
int ans = 0;
int a = ( int )Math.Log(n, 2);
for ( int exp = 1; exp <= a; exp++)
ans += ( int )(Math.Pow(2, exp)
- Math.Pow(2, exp - 1) - 1);
ans += ( int )(n - (Math.Pow(2, a)));
return ans;
}
// Driver Code
public static void Main( string [] args)
{
int N = 7;
// Function call
Console.Write(checkXORrange(N));
}
} // This code is contributed by phasing17 |
# Python3 code to implement the approach import math
# Function to calculate # total matches in the range def checkXORrange(n):
ans = 0
a = int (math.log2(n))
for exp in range ( 1 , a + 1 ):
ans + = 2 * * exp - 2 * * (exp - 1 ) - 1
ans + = n - 2 * * a
return ans
# Driver Code if __name__ = = "__main__" :
N = 7
print (checkXORrange(N))
|
<script> // JavaScript code to implement the approach
// Function to calculate
// total matches in the range
const checkXORrange = (n) => {
let ans = 0;
let a = parseInt(Math.log2(n));
for (let exp = 1; exp <= a; exp++)
ans += Math.pow(2, exp) - Math.pow(2, exp - 1) - 1;
ans += n - Math.pow(2, a);
return ans;
}
// Driver code
let N = 7;
// Function call
document.write(checkXORrange(N));
// This code is contributed by rakeshsahni </script> |
4
Time Complexity: O(log2N)
Auxiliary Space: O(1)