Valor OR máximo de un par en un Array | conjunto 2

Dada una array arr[] de N elementos positivos, la tarea es encontrar el valor OR bit a bit máximo de un par de la array dada.
Ejemplos:

Entrada: arr[] = {3, 6, 8, 16} 
Salida: 24 
Explicación: 
El par que da el valor OR máximo es (8, 16) 
8|16 = 24
Entrada: arr[] = {8, 7, 3, 12} 
Salida: 15 
Explicación: 
Hay más de un par que nos da el valor OR máximo. 
8|7 = 15 
 

Enfoque ingenuo: consulte el valor OR máximo de un par en una array para el enfoque ingenuo. 
Enfoque eficiente: en este artículo, discutiremos una solución optimizada para el problema dado.
Siga los pasos a continuación para resolver el problema:

• Encuentra el elemento más grande de la array.
• Realice Bitwise OR entre el elemento más grande y los elementos restantes de la array uno por uno. Esto se debe a que la disposición de los bits establecidos en el elemento más grande contribuirá al valor OR máximo posible de los elementos de la array.
• Imprime el valor OR máximo obtenido realizando el paso anterior.

A continuación se muestra la implementación del enfoque anterior:

// C++ implementation of
// the approach above
 
#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 the maximum
    // element in the array
    int max_value
        = *max_element(arr,
                       arr + n);
 
    // Stores the maximum
    // OR value
    int ans = 0;
 
    // Traverse the array and
    // perform Bitwise OR
    // between every array element
    // with the maximum element
    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 implementation of
// the approach above
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.
static int maxOR(int []arr, int n)
{
    // Find the maximum
    // element in the array
    int max_value = Arrays.stream(arr).max().getAsInt();
 
    // Stores the maximum
    // OR value
    int ans = 0;
 
    // Traverse the array and
    // perform Bitwise OR
    // between every array element
    // with the maximum element
    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[] = new int[]{ 3, 6, 8, 16 };
    int n = 4;
 
    System.out.print(maxOR(arr, n));
}
}
 
// This code is contributed by Ritik Bansal

# Python3 implementation of
# the approach above
 
# Function to return the maximum
# bitwise OR for any pair of the
# given array in O(n) time complexity.
def maxOR(arr, n):
 
    # Find the maximum
    # element in
    max_value = max(arr)
     
    # Stores the maximum
    # OR value the array
    ans = 0
 
    # Traverse the array and
    # perform Bitwise OR
    # between every array element
    # with the maximum element
    for i in range(n):
        ans = max(ans, (max_value | 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 jana_sayantan

// C# implementation of
// the approach above
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 the maximum
    // element in the array
    int max_value = arr.Max();
 
    // Stores the maximum
    // OR value
    int ans = 0;
 
    // Traverse the array and
    // perform Bitwise OR
    // between every array element
    // with the maximum element
    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 = 4;
 
    Console.Write(maxOR(arr, n));
}
}
 
// This code is contributed by 29AjayKumar

<script>
// Javascript implementation of
// the above approach
 
// Function to return the maximum
// bitwise OR for any pair of the
// given array in O(n) time complexity.
function maxOR(arr, n)
{
 
    // Find the maximum
    // element in the array
    let max_value = Math.max(...arr);
   
    // Stores the maximum
    // OR value
    let ans = 0;
   
    // Traverse the array and
    // perform Bitwise OR
    // between every array element
    // with the maximum element
    for (let i = 0; i < n; i++)
    {
        ans = Math.max(ans, (max_value | arr[i]));
    }
    return ans;
}
 
    // Driver Code
    let arr = [ 3, 6, 8, 16 ];
    let n = 4;
       document.write(maxOR(arr, n));
 
// This code is contributed by souravghosh0416.
</script>

24

Complejidad temporal: O(N) 
Espacio auxiliar: O(1)