Skip to content
Related Articles

Related Articles

Maximum OR value of a pair in an array

View Discussion
Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 10 Jun, 2022
View Discussion
Improve Article
Save Article

Given an array arr[] of N positive elements. The task is to find the maximum bitwise OR value of a pair from the given array.
Examples: 

Input: arr[] = {4, 8, 12, 16} 
Output: 28 
(12, 16) is the pair with the maximum bitwise OR. 
12 | 16 = 28

Input: arr[] = {4, 8, 16, 2} 
Output: 24 

Approach: Iterate over all the possible pairs and calculate the OR value of these pairs. Finally, print the maximum of all the values.

Below is the implementation of the above approach: 

C++




// 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
int maxOR(int arr[], int n)
{
 
    // To store the maximum OR value
    int maxVal = 0;
 
    // For every possible pair
    for (int i = 0; i < n - 1; i++)
        for (int j = i + 1; j < n; j++) {
 
            // Update the maximum OR value
            maxVal = max(maxVal, arr[i] | arr[j]);
        }
 
    return maxVal;
}
 
// Driver code
int main()
{
    int arr[] = { 4, 8, 12, 16 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << maxOR(arr, n);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG {
 
    // Function to return the maximum bitwise OR
    // for any pair of the given array
    static int maxOR(int arr[], int n)
    {
 
        // To store the maximum OR value
        int maxVal = 0;
 
        // For every possible pair
        for (int i = 0; i < n - 1; i++)
            for (int j = i + 1; j < n; j++) {
 
                // Update the maximum OR value
                maxVal = Math.max(maxVal, arr[i] | arr[j]);
            }
 
        return maxVal;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 4, 8, 12, 16 };
        int n = arr.length;
 
        System.out.println(maxOR(arr, n));
    }
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of the approach
 
# Function to return the maximum bitwise OR
# for any pair of the given array
def maxOR(arr, n):
     
    # To store the maximum OR value
    maxVal = 0;
 
    # For every possible pair
    for i in range(n - 1):
        for j in range(i + 1, n):
             
            # Update the maximum OR value
            maxVal = max(maxVal, arr[i] | arr[j]);
 
    return maxVal;
 
# Driver code
if __name__ == '__main__':
    arr = [4, 8, 12, 16];
    n = len(arr);
 
    print(maxOR(arr, n));
 
# This code is contributed by 29AjayKumar

C#




// C# implementation of the approach
using System;
 
class GFG {
 
    // Function to return the maximum bitwise OR
    // for any pair of the given array
    static int maxOR(int[] arr, int n)
    {
 
        // To store the maximum OR value
        int maxVal = 0;
 
        // For every possible pair
        for (int i = 0; i < n - 1; i++)
            for (int j = i + 1; j < n; j++) {
 
                // Update the maximum OR value
                maxVal = Math.Max(maxVal, arr[i] | arr[j]);
            }
 
        return maxVal;
    }
 
    // Driver code
    static public void Main()
    {
        int[] arr = { 4, 8, 12, 16 };
        int n = arr.Length;
 
        Console.Write(maxOR(arr, n));
    }
}
 
// This code is contributed by ajit.

Javascript




<script>
    // Javascript implementation of the approach
     
      // Function to return the maximum bitwise OR
    // for any pair of the given array
    function maxOR(arr, n)
    {
  
        // To store the maximum OR value
        let maxVal = 0;
  
        // For every possible pair
        for (let i = 0; i < n - 1; i++)
            for (let j = i + 1; j < n; j++) {
  
                // Update the maximum OR value
                maxVal = Math.max(maxVal, arr[i] | arr[j]);
            }
  
        return maxVal;
    }
     
    let arr = [ 4, 8, 12, 16 ];
    let n = arr.length;
 
    document.write(maxOR(arr, n));
</script>

Output: 

28

 

Time Complexity: O(n*n)

Auxiliary Space: O(1)

Efficient Approach: In this problem effective approach would be to find the element which are highest number of  pairs in array. We have following steps for this approach:

  • First find the highest number in array and name it max_value.
  • iterate over the array and one by one check the maximum of bitwise or of max_value with all the numbers of array.

Below is implementation of above approach:

C++




// C++ implementation of the approach ( Linear time Complexity )
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum bitwise OR
// for any pair of the given array
// in O(n) time complexity.
int maxOR(int arr[], int n)
{
    // find maximum element in the array
    int max_value = *max_element(arr, arr + n);
 
    // To store the maximum OR value
    int ans = 0;
 
    // iterate over rest array elements and find maximum OR value pair
    for (int i = 0; i < n; i++) {
        ans = max(ans, (max_value | arr[i]));
    }
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 3, 6, 8, 16 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << maxOR(arr, n);
 
    return 0;
}

Java




// Java implementation of the approach
// (Linear time Complexity)
import java.util.Arrays;
 
class GFG{
     
// Function to return the maximum bitwise
// OR for any pair of the given array
// in O(n) time complexity.
public static int maxOR(int[] arr, int n)
{
     
    // Find maximum element in the array
    int max_value = Arrays.stream(arr).max().getAsInt();
     
    // To store the maximum OR value
    int ans = 0;
   
    // Iterate over rest array elements and
    // find maximum OR value pair
    for(int i = 0; i < n; i++)
    {
        ans = Math.max(ans, (max_value | arr[i]));
    }
    return ans;
}
 
// 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 divyeshrabadiya07

Python3




# Python3 implementation of the approach
# (Linear time Complexity)
  
# Function to return the maximum bitwise
# OR for any pair of the given array
def maxOR(arr, n):
      
    # To store the maximum element
    # of the array
    maxVal = max(arr)
     
    # To store the maximum OR value
    ans = 0
     
    # Iterate over rest array elements and
    # find maximum OR value pair
    for i in range(n - 1):
         
        # Update the maximum OR value
        ans = max(ans, maxVal | arr[i])
   
    return ans
   
# Driver code
if __name__ == '__main__':
     
    arr = [ 3, 6, 8, 16 ]
    n = len(arr)
     
    print(maxOR(arr, n))
     
# This code is contributed by math_lover

C#




// C# implementation of the approach
// (Linear time Complexity)
using System;
using System.Linq;
 
class GFG{
     
// Function to return the maximum bitwise
// OR for any pair of the given array
// in O(n) time complexity.
static int maxOR(int []arr, int n)
{
     
    // Find maximum element in the array
    int max_value = arr.Max();
 
    // To store the maximum OR value
    int ans = 0;
 
    // Iterate over rest array elements and
    // find maximum OR value pair
    for(int i = 0; i < n; i++)
    {
        ans = Math.Max(ans, (max_value | arr[i]));
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 3, 6, 8, 16 };
    int n = arr.Length;
 
    Console.Write(maxOR(arr, n));
}
}
 
// This code is contributed by doreamon_

Javascript




<script>
    // Javascript implementation of the approach
    // (Linear time Complexity)
     
    // Function to return the maximum bitwise
    // OR for any pair of the given array
    // in O(n) time complexity.
    function maxOR(arr, n)
    {
 
        // Find maximum element in the array
        let max_value = Number.MIN_VALUE;
        for(let i = 0; i < n; i++)
        {
            max_value = Math.max(max_value, arr[i]);
        }
 
        // To store the maximum OR value
        let ans = 0;
 
        // Iterate over rest array elements and
        // find maximum OR value pair
        for(let i = 0; i < n; i++)
        {
            ans = Math.max(ans, (max_value | arr[i]));
        }
        return ans;
    }
     
    let arr = [ 3, 6, 8, 16 ];
    let n = arr.length;
  
    document.write(maxOR(arr, n));
     
</script>

Output:

24

Time Complexity: O(n)

Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!