Maximum OR value of a pair in an Array without using OR operator

Given an array arr[] containing N positive integers, the task is to find the maximum bitwise OR value of a pair in the given array without using the Bitwise OR operator.
Examples:

Input: arr[] = {3, 6, 8, 16} 
Output: 24 
Explanation: 
The pair giving maximum OR value is (8, 16) => 8|16 = 24

Input: arr[] = {8, 7, 3, 12} 
Output: 15 
Explanation: 
There are more than one pair giving us the maximum OR value. One among them => 8|7 = 15

Approach: The idea is to find the two numbers which have the most count of set bits at distinct indices. In this way, the resultant number will have all those indices as a set bit, and this can be done without using the OR operator

  • Find out the maximum element in the array and then find the particular element in the remaining array that will have the set bit at the indexes where the maximum element has an unset bit.
  • To maximize our output we have to find such an element that will have a set bit in such a manner that will maximize our output.
  • Calculate the complement of the maximum element in the array and find the maximum AND value with the other numbers.
  • The maximum AND value of this compliment with other array elements will give us the maximum unset bits that could be set in our answer due to other array elements.
  • Adding maximum elements with this maximum AND value will give us our desired maximum OR value pair without using OR operation.

Below is the implementation of the above approach:



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the maximum bitwise OR
// for any pair of the given array
// without using bitwise OR operation
int maxOR(int arr[], int n)
{
  
    // find maximum element in the array
    int max_value
        = *max_element(arr, arr + n);
  
    int number_of_bits
        = floor(log2(max_value)) + 1;
  
    // finding compliment will set
    // all unset bits in a number
    int compliment
        = ((1 << number_of_bits) - 1)
          ^ max_value;
  
    int c = 0;
  
    // iterate through all other
    // array elements to find
    // maximum AND value
    for (int i = 0; i < n; i++) {
        if (arr[i] != max_value) {
            c = max(c, (compliment & arr[i]));
        }
    }
  
    // c will give the maximum value
    // that could be added to max_value
    // to produce maximum OR value
    return (max_value + c);
}
  
// Driver code
int main()
{
    int arr[] = { 3, 6, 8, 16 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << maxOR(arr, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation 
// of the approach
import java.util.*;
class GFG{
  
// Function to return the maximum 
// bitwise OR for any pair of the 
// given array without using bitwise 
// OR operation
static int maxOR(int arr[], int n)
{
  
    // find maximum element in the array
    int max_value = 
        Arrays.stream(arr).max().getAsInt();
  
    int number_of_bits = 
        (int)((Math.log(max_value))) + 2;
  
    // finding compliment will set
    // all unset bits in a number
    int compliment = ((1 << number_of_bits) - 1) ^ 
                       max_value;
  
    int c = 0;
  
    // iterate through all other
    // array elements to find
    // maximum AND value
    for (int i = 0; i < n; i++) 
    {
        if (arr[i] != max_value) 
        {
            c = Math.max(c, 
                         (compliment & arr[i]));
        }
    }
  
    // c will give the maximum value
    // that could be added to max_value
    // to produce maximum OR value
    return (max_value + c);
}
  
// Driver code
public static void main(String[] args)
{
    int arr[] = {3, 6, 8, 16};
    int n = arr.length;
    System.out.print(maxOR(arr, n));
}
}
  
// This code is contributed by gauravrajput1

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
from math import log2, floor
  
# Function to return the maximum bitwise OR
# for any pair of the given array
# without using bitwise OR operation
def maxOR(arr, n):
      
    # Find maximum element in the array
    max_value = max(arr)
  
    number_of_bits = floor(log2(max_value)) + 1
  
    # Finding compliment will set
    # all unset bits in a number
    compliment = (((1 << number_of_bits) - 1) ^ 
                 max_value)
    c = 0
  
    # Iterate through all other
    # array elements to find
    # maximum AND value
    for i in range(n):
          
        if (arr[i] != max_value):
            c = max(c, (compliment & arr[i]))
  
    # c will give the maximum value
    # that could be added to max_value
    # to produce maximum OR value
    return (max_value + c)
  
# Driver code
if __name__ == '__main__':
      
    arr = [3, 6, 8, 16]
    n = len(arr)
  
    print(maxOR(arr, n))
  
# This code is contributed by Bhupendra_Singh

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach 
using System;
using System.Linq; 
  
class GFG{
  
// Function to return the maximum 
// bitwise OR for any pair of the 
// given array without using bitwise 
// OR operation
static int maxOR(int[] arr, int n)
{
  
    // Find maximum element in the array
    int max_value = arr.Max();
  
    int number_of_bits = (int)(Math.Log(max_value)) + 2;
  
    // Finding compliment will set
    // all unset bits in a number
    int compliment = ((1 << number_of_bits) - 1) ^ 
                      max_value;
  
    int c = 0;
  
    // Iterate through all other
    // array elements to find
    // maximum AND value
    for(int i = 0; i < n; i++) 
    {
        if (arr[i] != max_value) 
        {
            c = Math.Max(c, 
                        (compliment & arr[i]));
        }
    }
  
    // c will give the maximum value
    // that could be added to max_value
    // to produce maximum OR value
    return (max_value + c);
}
  
// Driver code
public static void Main()
{
    int[] arr = { 3, 6, 8, 16 };
    int n = arr.Length;
      
    Console.Write(maxOR(arr, n));
}
}
  
// This code is contributed by code_hunt

chevron_right


Output: 

24

Time Complexity: O(N) 

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.




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.