# 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```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++

 `// C++ Program to find the bitwise ` `// OR of all the intgers in range L-R ` `#include ` `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 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. `

## Python3

 `# 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 `

## C#

 `// 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. `

## PHP

 `> 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. ` `?> `

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

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.