Maximum OR value of a pair in an Array without using OR operator
Last Updated :
09 Nov, 2021
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 complement 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++
#include <bits/stdc++.h>
using namespace std;
int maxOR( int arr[], int n)
{
int max_value
= *max_element(arr, arr + n);
int number_of_bits
= floor (log2(max_value)) + 1;
int complement
= ((1 << number_of_bits) - 1)
^ max_value;
int c = 0;
for ( int i = 0; i < n; i++) {
if (arr[i] != max_value) {
c = max(c, (complement & arr[i]));
}
}
return (max_value + c);
}
int main()
{
int arr[] = { 3, 6, 8, 16 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << maxOR(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int maxOR( int arr[], int n)
{
int max_value =
Arrays.stream(arr).max().getAsInt();
int number_of_bits =
( int )((Math.log(max_value))) + 2 ;
int complement = (( 1 << number_of_bits) - 1 ) ^
max_value;
int c = 0 ;
for ( int i = 0 ; i < n; i++)
{
if (arr[i] != max_value)
{
c = Math.max(c,
(complement & arr[i]));
}
}
return (max_value + c);
}
public static void main(String[] args)
{
int arr[] = { 3 , 6 , 8 , 16 };
int n = arr.length;
System.out.print(maxOR(arr, n));
}
}
|
Python3
from math import log2, floor
def maxOR(arr, n):
max_value = max (arr)
number_of_bits = floor(log2(max_value)) + 1
complement = ((( 1 << number_of_bits) - 1 ) ^
max_value)
c = 0
for i in range (n):
if (arr[i] ! = max_value):
c = max (c, (complement & arr[i]))
return (max_value + c)
if __name__ = = '__main__' :
arr = [ 3 , 6 , 8 , 16 ]
n = len (arr)
print (maxOR(arr, n))
|
C#
using System;
using System.Linq;
class GFG{
static int maxOR( int [] arr, int n)
{
int max_value = arr.Max();
int number_of_bits = ( int )(Math.Log(max_value)) + 2;
int complement = ((1 << number_of_bits) - 1) ^
max_value;
int c = 0;
for ( int i = 0; i < n; i++)
{
if (arr[i] != max_value)
{
c = Math.Max(c,
(complement & arr[i]));
}
}
return (max_value + c);
}
public static void Main()
{
int [] arr = { 3, 6, 8, 16 };
int n = arr.Length;
Console.Write(maxOR(arr, n));
}
}
|
Javascript
<script>
function maxOR(arr , n) {
var max_value = Math.max.apply(Math,arr);
var number_of_bits = parseInt( ((Math.log(max_value)))) + 2;
var complement = ((1 << number_of_bits) - 1) ^ max_value;
var c = 0;
for (i = 0; i < n; i++) {
if (arr[i] != max_value) {
c = Math.max(c, (complement & arr[i]));
}
}
return (max_value + c);
}
var arr = [ 3, 6, 8, 16 ];
var n = arr.length;
document.write(maxOR(arr, n));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...