Bitwise OR (or | ) of a range

Given two integers L and R. Determine the bitwise OR of all the integers in the range [L, R] (both inclusive).

Examples:

Input: L = 3, R = 8
Output: 15
3 | 4 | 5 | 6 | 7 | 8 = 15

Input: L = 12, R = 18
Output: 31
12 | 13 | 14 | 15 | 16 | 17 | 18 = 31

A naive approach is to traverse through all the integers between L and R and do bitwise OR of all the numbers.



An efficient approach be to follow the following steps:

  1. Find the position of Most Significant Bit (MSB) in both the numbers (L and R)
  2. If the position of both MSBs are different, set all the bits from the max(MSB1, MSB2) including this different bit upto Oth bit i.e. add the value (1 << i) for all 0 ≤ i ≤ max(MSB1, MSB2) in the answer.
  3. If the position of both MSBs are same, then
    • Set this bit corresponding to MSB or add the value (1 << MSB) in the answer.
    • Subtract the value (1 << MSB) from both the numbers (L and R).

    • Repeat the steps 1, 2 and 3.

Given below is the working of the above algorithm when L = 18 and R = 21.

L = 18, R = 21
The result is initially 0.
The position of Most Significant Bit in L = 4
Position of Most Significant Bit in R = 4
Since positions are same, add value (1 << 4) i.e. 16 to the result.

Subtract (1 << 4) from L, L becomes 2.
Subtract (1 << 4) from R, R becomes 5.

Now, Position of MSB in L is 1
Position of MSB in R is 2
Since positions are different all value (1 << i) for all 
0 ≤ i ≤ max(MSB1, MSB2)
i.e. Add ((1 << 2) + (1 << 1) + (1 << 0)) = 7
Hence, final result is 16 + 7 = 23.

Below is the implementation of above approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to find the bitwise
// OR of all the intgers in range L-R
#include <bits/stdc++.h>
using namespace std;
  
// Returns the Most Significant Bit
// Position (MSB)
int MSBPosition(long long int N)
{
    int msb_p = -1;
    while (N) {
        N = N >> 1;
        msb_p++;
    }
    return msb_p;
}
  
// Returns the Bitwise OR of all
// integers between L and R
long long int findBitwiseOR(long long int L,
                            long long int R)
{
    long long int res = 0;
  
    // Find the MSB position in L
    int msb_p1 = MSBPosition(L);
  
    // Find the MSB position in R
    int msb_p2 = MSBPosition(R);
  
    while (msb_p1 == msb_p2) {
        long long int res_val = (1 << msb_p1);
  
        // Add this value until msb_p1 and
        // msb_p2 are same;
        res += res_val;
  
        L -= res_val;
        R -= res_val;
  
        // Calculate msb_p1 and msb_p2
        msb_p1 = MSBPosition(L);
        msb_p2 = MSBPosition(R);
    }
    // Find the max of msb_p1 and msb_p2
    msb_p1 = max(msb_p1, msb_p2);
  
    // Set all the bits from msb_p1 upto
    // 0th bit in the result
    for (int i = msb_p1; i >= 0; i--) {
        long long int res_val = (1 << i);
        res += res_val;
    }
    return res;
}
  
// Driver Code
int main()
{
    int L = 12, R = 18;
    cout << findBitwiseOR(L, R) << endl;
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to find 
// the bitwise OR of all 
// the intgers in range L-R
import java.io.*;
  
class GFG
{
  
// Returns the Most Significant 
// Bit Position (MSB)
static int MSBPosition(long N)
{
    int msb_p = -1;
    while (N > 0)
    {
        N = N >> 1;
        msb_p++;
    }
    return msb_p;
}
  
// Returns the Bitwise 
// OR of all integers 
// between L and R
static long findBitwiseOR(long L,
                          long R)
{
    long res = 0;
  
    // Find the MSB 
    // position in L
    int msb_p1 = MSBPosition(L);
  
    // Find the MSB 
    // position in R
    int msb_p2 = MSBPosition(R);
  
    while (msb_p1 == msb_p2)
    {
        long res_val = (1 << msb_p1);
  
        // Add this value until 
        // msb_p1 and msb_p2 are same;
        res += res_val;
  
        L -= res_val;
        R -= res_val;
  
        // Calculate msb_p1 
        // and msb_p2
        msb_p1 = MSBPosition(L);
        msb_p2 = MSBPosition(R);
    }
      
    // Find the max of 
    // msb_p1 and msb_p2
    msb_p1 = Math.max(msb_p1, 
                      msb_p2);
  
    // Set all the bits 
    // from msb_p1 upto
    // 0th bit in the result
    for (int i = msb_p1; i >= 0; i--) 
    {
        long res_val = (1 << i);
        res += res_val;
    }
    return res;
}
  
// Driver Code
public static void main (String[] args) 
{
    int L = 12, R = 18;
    System.out.println(findBitwiseOR(L, R));
}
}
  
// This code is contributed
// by anuj_67.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 Program to find the bitwise 
# OR of all the intgers in range L-R 
  
# Returns the Most Significant Bit 
# Position (MSB) 
def MSBPosition(N) : 
   
    msb_p = -1
    while (N) :
        N = N >> 1 
        msb_p += 1 
   
    return msb_p 
   
  
# Returns the Bitwise OR of all 
# integers between L and R 
def findBitwiseOR(L, R) :
  
    res = 0
  
    # Find the MSB position in L 
    msb_p1 = MSBPosition(L)
  
    # Find the MSB position in R 
    msb_p2 = MSBPosition(R) 
  
    while (msb_p1 == msb_p2) :
        res_val = (1 << msb_p1)
  
        # Add this value until msb_p1 and 
        # msb_p2 are same; 
        res += res_val
  
        L -= res_val
        R -= res_val
  
        # Calculate msb_p1 and msb_p2 
        msb_p1 = MSBPosition(L) 
        msb_p2 = MSBPosition(R) 
       
    # Find the max of msb_p1 and msb_p2 
    msb_p1 = max(msb_p1, msb_p2) 
  
    # Set all the bits from msb_p1 upto 
    # 0th bit in the result 
    for i in range(msb_p1, -1, -1) : 
        res_val = (1 << i)
        res += res_val
      
    return res 
   
  
# Driver Code 
if __name__ == "__main__" :
   
    L , R= 12 ,18 
    print(findBitwiseOR(L, R)) 
  
# This code is contributed by Ryuga

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to find 
// the bitwise OR of all 
// the intgers in range L-R
using System;
  
class GFG
{
  
// Returns the Most Significant 
// Bit Position (MSB)
static int MSBPosition(long N)
{
    int msb_p = -1;
    while (N > 0)
    {
        N = N >> 1;
        msb_p++;
    }
    return msb_p;
}
  
// Returns the Bitwise 
// OR of all integers 
// between L and R
static long findBitwiseOR(long L,
                          long R)
{
    long res = 0;
  
    // Find the MSB 
    // position in L
    int msb_p1 = MSBPosition(L);
  
    // Find the MSB 
    // position in R
    int msb_p2 = MSBPosition(R);
  
    while (msb_p1 == msb_p2)
    {
        long res_val = (1 << msb_p1);
  
        // Add this value until 
        // msb_p1 and msb_p2 are same;
        res += res_val;
  
        L -= res_val;
        R -= res_val;
  
        // Calculate msb_p1 
        // and msb_p2
        msb_p1 = MSBPosition(L);
        msb_p2 = MSBPosition(R);
    }
      
    // Find the max of 
    // msb_p1 and msb_p2
    msb_p1 = Math.Max(msb_p1, 
                      msb_p2);
  
    // Set all the bits 
    // from msb_p1 upto
    // 0th bit in the result
    for (int i = msb_p1; i >= 0; i--) 
    {
        long res_val = (1 << i);
        res += res_val;
    }
    return res;
}
  
// Driver Code
public static void Main () 
{
    int L = 12, R = 18;
    Console.WriteLine(findBitwiseOR(L, R));
}
}
  
// This code is contributed
// by anuj_67.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP Program to find the 
// bitwise OR of all the 
// intgers in range L-R
  
// Returns the Most Significant 
// Bit Position (MSB)
function MSBPosition($N)
{
    $msb_p = -1;
    while ($N
    {
        $N = $N >> 1;
        $msb_p++;
    }
    return $msb_p;
}
  
// Returns the Bitwise 
// OR of all integers 
// between L and R
function findBitwiseOR($L, $R)
{
    $res = 0;
  
    // Find the MSB
    // position in L
    $msb_p1 = MSBPosition($L);
  
    // Find the MSB
    // position in R
    $msb_p2 = MSBPosition($R);
  
    while ($msb_p1 == $msb_p2
    {
        $res_val = (1 << $msb_p1);
  
        // Add this value until 
        // msb_p1 and msb_p2 are same;
        $res += $res_val;
  
        $L -= $res_val;
        $R -= $res_val;
  
        // Calculate msb_p1 
        // and msb_p2
        $msb_p1 = MSBPosition($L);
        $msb_p2 = MSBPosition($R);
    }
      
    // Find the max of
    // msb_p1 and msb_p2
    $msb_p1 = max($msb_p1
                  $msb_p2);
  
    // Set all the bits from msb_p1 
    // upto 0th bit in the result
    for ($i = $msb_p1; $i >= 0; $i--) 
    {
        $res_val = (1 << $i);
        $res += $res_val;
    }
    return $res;
}
  
// Driver Code
$L = 12; $R = 18;
echo findBitwiseOR($L, $R);
  
// This code is contributed
// by anuj_67.
?>

chevron_right


Output:

31

Time Complexity: O(N), where N is the Most significant bit.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : vt_m, AnkitRai01