Given a range **[L, R]**, the task is to find a pair **(X, Y)** such that **L ≤ X, Y ≤ R** and **(X | Y)** is maximum among all the possible pairs then print the bitwise OR of the found pair.**Examples:**

Input:L = 4, R = 5Output:5

The only pair is (4, 5) and (4 | 5) = 5.Input:L = 14, R = 2500Output:4095

**Naive approach:** Iterate from **L** to **R** and check the bitwise OR for every possible pair and print the maximum value in the end.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <climits>` `#include <iostream>` `using` `namespace` `std;` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `int` `maxOR(` `int` `L, ` `int` `R)` `{` ` ` `int` `maximum = INT_MIN;` ` ` `// Check for every possible pair` ` ` `for` `(` `int` `i = L; i < R; i++)` ` ` `for` `(` `int` `j = i + 1; j <= R; j++)` ` ` `// Maximum among all (i, j) pairs` ` ` `maximum = max(maximum, (i | j));` ` ` `return` `maximum;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `L = 4, R = 5;` ` ` `cout << maxOR(L, R);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `static` `int` `maxOR(` `int` `L, ` `int` `R)` `{` ` ` `int` `maximum = Integer.MIN_VALUE;` ` ` `// Check for every possible pair` ` ` `for` `(` `int` `i = L; i < R; i++)` ` ` `for` `(` `int` `j = i + ` `1` `; j <= R; j++)` ` ` `// Maximum among all (i, j) pairs` ` ` `maximum = Math.max(maximum, (i | j));` ` ` `return` `maximum;` `}` `// Driver code` `public` `static` `void` `main(String []args)` `{` ` ` `int` `L = ` `4` `, R = ` `5` `;` ` ` `System.out.println(maxOR(L, R));` `}` `}` `// This code is contributed by Rajput-Ji` |

## Python3

`# Python3 implementation of the approach` `# Function to return the maximum bitwise OR` `# possible among all the possible pairs` `def` `maxOR(L, R):` ` ` `maximum ` `=` `-` `10` `*` `*` `9` ` ` `# Check for every possible pair` ` ` `for` `i ` `in` `range` `(L, R):` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, R ` `+` `1` `):` ` ` `# Maximum among all (i, j) pairs` ` ` `maximum ` `=` `max` `(maximum, (i | j))` ` ` `return` `maximum` `# Driver code` `L ` `=` `4` `R ` `=` `5` `print` `(maxOR(L, R))` `# This code is contributed by Mohit Kumar` |

## C#

`// C# implementation of the approach` `using` `System;` ` ` `class` `GFG` `{` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `static` `int` `maxOR(` `int` `L, ` `int` `R)` `{` ` ` `int` `maximum = ` `int` `.MinValue;` ` ` `// Check for every possible pair` ` ` `for` `(` `int` `i = L; i < R; i++)` ` ` `for` `(` `int` `j = i + 1; j <= R; j++)` ` ` `// Maximum among all (i, j) pairs` ` ` `maximum = Math.Max(maximum, (i | j));` ` ` `return` `maximum;` `}` `// Driver code` `public` `static` `void` `Main(String []args)` `{` ` ` `int` `L = 4, R = 5;` ` ` `Console.WriteLine(maxOR(L, R));` `}` `}` `// This code is contributed by Rajput-Ji` |

## Javascript

`<script>` `// JavaScript implementation of the approach` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `function` `maxOR(L, R)` `{` ` ` `let maximum = Number.MIN_VALUE;` ` ` `// Check for every possible pair` ` ` `for` `(let i = L; i < R; i++)` ` ` `for` `(let j = i + 1; j <= R; j++)` ` ` `// Maximum among all (i, j) pairs` ` ` `maximum = Math.max(maximum, (i | j));` ` ` `return` `maximum;` `}` `// Driver code` ` ` `let L = 4, R = 5;` ` ` `document.write(maxOR(L, R));` `// This code is contributed by shivanisinghss2110` `</script>` |

**Output:**

5

**Time Complexity:** O(n^{2})**Efficient approach:** OR operation sets the **i ^{th}** bit if either of the operands has the

**i**bit set. Our aim is to maximize the number of set bits.

^{th}Now the task is to find the most significant bit

**B**where

**L**and

**R**differ.

**B**bit will be set in

^{th}**R**and not set in

**L**. The maximum OR that can be generated will have all the bits significant to bit

**B**same as

**L**and

**R**and all the bits less significant than

**B**will be set as they will be inclusive in the range.

**B**bit will be 1 in the OR as 1 | 0 will be 1.

^{th}Now, consider the binary representations of both

**L**and

**R**, from the most significant bit (MSB) to least significant bit (LSB). Suppose the first

**x**bits are the same for both

**L**and

**R**. Then all possible A and B have the first

**x**bits the same as

**L**and

**R**, since even if a single bit among these

**x**bits change, the value shall move outside range

**[L, R]**which is not allowed.

Next, all the bits less significant than the difference bit

**B**will be set, including

**B**.

Consider the following example,

L = 001100010

R = 001100110

First six bits are same for

**L**and

**R**, so all numbers N, such that

**L≤ N < R**holds, will have their first six bits same as

**L**(or

**R**) and also OR of any two numbers in the range will have same first six bits.

Now, ignoring the first

**x**bits, we find a mismatch at the bit. At this point, A can be constructed such that the mismatched bit is not set for A and all bits less significant than the current bit is set. Similarly, B can be constructed such that mismatch bit is set for B and all subsequent bits are not set in B.

Their OR shall have all bits including mismatch bit set.

Applying this logic to our example, we have A = 001100011 and B = 001100100 and their OR is 001100111 which is maximum possible.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <iostream>` `using` `namespace` `std;` `const` `int` `MAX = 64;` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `int` `maxOR(` `int` `L, ` `int` `R)` `{` ` ` `// If there is only a single value` ` ` `// in the range [L, R]` ` ` `if` `(L == R) {` ` ` `return` `L;` ` ` `}` ` ` `int` `ans = 0;` ` ` `// Loop through each bit from MSB to LSB` ` ` `for` `(` `int` `i = MAX - 1; i >= 0; i--) {` ` ` `int` `p, lbit, rbit;` ` ` `p = 1 << i;` ` ` `lbit = (L >> i) & 1; ` `// bit of left limit` ` ` `rbit = (R >> i) & 1; ` `// bit of right limit` ` ` `// MSBs where the bits differ,` ` ` `// all bits from that bit are set` ` ` `if` `((rbit == 1) && (lbit == 0)) {` ` ` `ans += (p << 1) - 1;` ` ` `break` `;` ` ` `}` ` ` `// If MSBs are same, then ans` ` ` `// bit is same as that of` ` ` `// bit of right or left limit` ` ` `if` `(rbit == 1) {` ` ` `ans += p;` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `L = 4, R = 5;` ` ` `cout << maxOR(L, R);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` `static` `int` `MAX = ` `64` `;` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `static` `int` `maxOR(` `int` `L, ` `int` `R)` `{` ` ` `// If there is only a single value` ` ` `// in the range [L, R]` ` ` `if` `(L == R)` ` ` `{` ` ` `return` `L;` ` ` `}` ` ` `int` `ans = ` `0` `;` ` ` `// Loop through each bit from MSB to LSB` ` ` `for` `(` `int` `i = MAX - ` `1` `; i >= ` `0` `; i--)` ` ` `{` ` ` `int` `p, lbit, rbit;` ` ` `p = ` `1` `<< i;` ` ` `lbit = (L >> i) & ` `1` `; ` `// bit of left limit` ` ` `rbit = (R >> i) & ` `1` `; ` `// bit of right limit` ` ` `// MSBs where the bits differ,` ` ` `// all bits from that bit are set` ` ` `if` `((rbit == ` `1` `) && (lbit == ` `0` `))` ` ` `{` ` ` `ans += (p << ` `1` `) - ` `1` `;` ` ` `break` `;` ` ` `}` ` ` `// If MSBs are same, then ans` ` ` `// bit is same as that of` ` ` `// bit of right or left limit` ` ` `if` `(rbit == ` `1` `)` ` ` `{` ` ` `ans += p;` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `L = ` `4` `, R = ` `5` `;` ` ` `System.out.println(maxOR(L, R));` `}` `}` `// This code is contributed by Rajput-Ji` |

## Python3

`# Python3 implementation of the approach` `MAX` `=` `64` `;` `# Function to return the maximum bitwise OR` `# possible among all the possible pairs` `def` `maxOR(L, R) :` ` ` `# If there is only a single value` ` ` `# in the range [L, R]` ` ` `if` `(L ` `=` `=` `R) :` ` ` `return` `L;` ` ` `ans ` `=` `0` `;` ` ` `# Loop through each bit from MSB to LSB` ` ` `for` `i ` `in` `range` `(` `MAX` `-` `1` `, ` `-` `1` `, ` `-` `1` `) :` ` ` `p ` `=` `1` `<< i;` ` ` `lbit ` `=` `(L >> i) & ` `1` `; ` `# bit of left limit` ` ` `rbit ` `=` `(R >> i) & ` `1` `; ` `# bit of right limit` ` ` `# MSBs where the bits differ,` ` ` `# all bits from that bit are set` ` ` `if` `((rbit ` `=` `=` `1` `) ` `and` `(lbit ` `=` `=` `0` `)) :` ` ` `ans ` `+` `=` `(p << ` `1` `) ` `-` `1` `;` ` ` `break` `;` ` ` `# If MSBs are same, then ans` ` ` `# bit is same as that of` ` ` `# bit of right or left limit` ` ` `if` `(rbit ` `=` `=` `1` `) :` ` ` `ans ` `+` `=` `p;` ` ` ` ` `return` `ans;` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `L ` `=` `4` `; R ` `=` `5` `;` ` ` `print` `(maxOR(L, R));` ` ` `# This code is contributed by kanugargng` |

## C#

`// C# implementation of the above approach` `using` `System;` ` ` `class` `GFG` `{` `static` `int` `MAX = 64;` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `static` `int` `maxOR(` `int` `L, ` `int` `R)` `{` ` ` `// If there is only a single value` ` ` `// in the range [L, R]` ` ` `if` `(L == R)` ` ` `{` ` ` `return` `L;` ` ` `}` ` ` `int` `ans = 0;` ` ` `// Loop through each bit from MSB to LSB` ` ` `for` `(` `int` `i = MAX - 1; i >= 0; i--)` ` ` `{` ` ` `int` `p, lbit, rbit;` ` ` `p = 1 << i;` ` ` `lbit = (L >> i) & 1; ` `// bit of left limit` ` ` `rbit = (R >> i) & 1; ` `// bit of right limit` ` ` `// MSBs where the bits differ,` ` ` `// all bits from that bit are set` ` ` `if` `((rbit == 1) && (lbit == 0))` ` ` `{` ` ` `ans += (p << 1) - 1;` ` ` `break` `;` ` ` `}` ` ` `// If MSBs are same, then ans` ` ` `// bit is same as that of` ` ` `// bit of right or left limit` ` ` `if` `(rbit == 1)` ` ` `{` ` ` `ans += p;` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `L = 4, R = 5;` ` ` `Console.WriteLine(maxOR(L, R));` `}` `}` `// This code is contributed by PrinciRaj1992` |

## Javascript

`<script>` `// Javascript implementation of the approach` `let MAX = 64;` `// Function to return the maximum bitwise OR` `// possible among all the possible pairs` `function` `maxOR(L,R)` `{` ` ` `// If there is only a single value` ` ` `// in the range [L, R]` ` ` `if` `(L == R)` ` ` `{` ` ` `return` `L;` ` ` `}` ` ` ` ` `let ans = 0;` ` ` ` ` `// Loop through each bit from MSB to LSB` ` ` `for` `(let i = MAX - 1; i >= 0; i--)` ` ` `{` ` ` `let p, lbit, rbit;` ` ` `p = 1 << i;` ` ` `lbit = (L >> i) & 1; ` `// bit of left limit` ` ` `rbit = (R >> i) & 1; ` `// bit of right limit` ` ` ` ` `// MSBs where the bits differ,` ` ` `// all bits from that bit are set` ` ` `if` `((rbit == 1) && (lbit == 0))` ` ` `{` ` ` `ans += (p << 1) - 1;` ` ` `break` `;` ` ` `}` ` ` ` ` `// If MSBs are same, then ans` ` ` `// bit is same as that of` ` ` `// bit of right or left limit` ` ` `if` `(rbit == 1)` ` ` `{` ` ` `ans += p;` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `let L = 4, R = 5;` ` ` `document.write(maxOR(L, R));` `// This code is contributed by unknown2108` `</script>` |

**Output:**

5

**Time Complexity:** O(log_{2}(R)), where R is the upper limit of the range.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live**