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 is 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, up to 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 is the 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 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 the above approach. 

C++

// C++ Program to find the bitwise
// OR of all the integers 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;
}

Java

// Java Program to find
// the bitwise OR of all
// the integers 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.

Python3

# Python3 Program to find the bitwise
# OR of all the integers 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

C#

// C# Program to find
// the bitwise OR of all
// the integers 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.

PHP

<?php
// PHP Program to find the
// bitwise OR of all the
// integers 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.
?>

Javascript

<script>
    // Javascript Program to find
    // the bitwise OR of all
    // the integers in range L-R

    // Returns the Most Significant
    // Bit Position (MSB)
    function MSBPosition(N)
    {
        let 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
    function findBitwiseOR(L, R)
    {
        let res = 0;

        // Find the MSB
        // position in L
        let msb_p1 = MSBPosition(L);

        // Find the MSB
        // position in R
        let msb_p2 = MSBPosition(R);

        while (msb_p1 == msb_p2)
        {
            let 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 (let i = msb_p1; i >= 0; i--)
        {
            let res_val = (1 << i);
            res += res_val;
        }
        return res;
    }

    let L = 12, R = 18;
    document.write(findBitwiseOR(L, R));

</script>

Output:

31

Time Complexity: O(N), where N is the most significant bit. 
Space Complexity : O(1)