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
Next

Maximum AND value of a pair in an array
Recommended Articles
Page :
Store duplicate keys-values pair and sort the key-value pair by key
26, Apr 20
Probability of a random pair being the maximum weighted pair
26, Nov 17
Pair formation such that maximum pair sum is minimized
30, May 18
Number of indices pair such that element pair sum from first Array is greater than second Array
25, Mar 20
Find a pair (n,r) in an integer array such that value of nPr is maximum
11, Oct 19
Find a pair (n,r) in an integer array such that value of nCr is maximum
11, Oct 19
Maximum OR value of a pair in an Array | Set 2
30, Jun 20
Maximum OR value of a pair in an Array without using OR operator
08, May 20
Maximum value of arr[i] + arr[j] + i – j for any pair of an array
14, Apr 21
Maximum value of (arr[i] * arr[j]) + (arr[j] - arr[i])) possible for any pair in an array
21, Apr 21
Maximum AND value of a pair in an array
24, Nov 17
Reduce Binary Array by replacing both 0s or both 1s pair with 0 and 10 or 01 pair with 1
14, Dec 21
Queries to check if any pair exists in an array having values at most equal to the given pair
04, Dec 20
Maximum sum of pair values such that value of pairs of same group should be a multiple of i in range [1, N]
22, Jul 21
Maximum XOR value of maximum and second maximum element among all possible subarrays
08, Jan 20
Kth smallest pair and number of pairs less than a given pair (x, y)
20, Jul 21
Count of quadruples with product of a pair equal to the product of the remaining pair
08, Feb 21
Pair with given product | Set 1 (Find if any pair exists)
03, Jun 16
Minimize operations to make minimum value of one array greater than maximum value of the other
20, Jul 21
Minimize value of x that minimizes value of |a1−x|^c+|a2−x|^c+···+|an−x|^c for value of c as 1 and 2
22, Nov 21
Minimum groups to split Array such that their each pair value difference and position difference are same
30, Jun 21
Maximize value of given expression by choosing pair from Array
24, Aug 22
Find the missing value from Array B formed by adding some value X to Array A
19, Oct 21
Probability that a random pair chosen from an array (a[i], a[j]) has the maximum sum
18, Oct 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Akshita207
@Akshita207
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!