Valor máximo de XOR entre todos los tripletes de una array

Dada una array de enteros ‘arr’, la tarea es encontrar el valor XOR máximo de cualquier par de tripletes entre todos los pares de tripletes posibles. 
Nota: un elemento de array se puede utilizar más de una vez.
Ejemplos: 
 

Entrada: arr[] = {3, 4, 5, 6} 
Salida: 7 
El triplete con valor XOR máximo es {4, 5, 6}.
Entrada: arr[] = {1, 3, 8, 15} 
Salida: 15 
 

Acercarse: 
 

• Almacene todos los valores posibles de XOR entre todos los pares posibles de dos elementos de la array en un conjunto.
• La estructura de datos establecida se utiliza para evitar las repeticiones de valores XOR.
• Ahora, use XOR entre cada elemento del conjunto y el elemento de la array para obtener el valor máximo para cualquier par de tripletes.

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

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// function to count maximum
// XOR value for a triplet
void Maximum_xor_Triplet(int n, int a[])
{
    // set is used to avoid repetitions
    set<int> s;
 
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
 
            // store all possible unique
            // XOR value of pairs
            s.insert(a[i] ^ a[j]);
        }
    }
 
    int ans = 0;
 
    for (auto i : s) {
        for (int j = 0; j < n; j++) {
 
            // store maximum value
            ans = max(ans, i ^ a[j]);
        }
    }
 
    cout << ans << "\n";
}
 
// Driver code
int main()
{
    int a[] = { 1, 3, 8, 15 };
    int n = sizeof(a) / sizeof(a[0]);
    Maximum_xor_Triplet(n, a);
 
    return 0;
}

// Java implementation of the approach
 
import java.util.HashSet;
 
class GFG
{
 
    // function to count maximum
    // XOR value for a triplet
    static void Maximum_xor_Triplet(int n, int a[])
    {
        // set is used to avoid repetitions
        HashSet<Integer> s = new HashSet<Integer>();
 
        for (int i = 0; i < n; i++)
        {
            for (int j = i; j < n; j++)
            {
 
                // store all possible unique
                // XOR value of pairs
                s.add(a[i] ^ a[j]);
            }
        }
 
        int ans = 0;
        for (Integer i : s)
        {
            for (int j = 0; j < n; j++)
            {
 
                // store maximum value
                ans = Math.max(ans, i ^ a[j]);
            }
        }
        System.out.println(ans);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a[] = {1, 3, 8, 15};
        int n = a.length;
        Maximum_xor_Triplet(n, a);
    }
}
 
// This code is contributed by 29AjayKumar

# Python3 implementation of the approach
 
# function to count maximum
# XOR value for a triplet
def Maximum_xor_Triplet(n, a):
 
    # set is used to avoid repetitions
    s = set()
 
    for i in range(0, n):
        for j in range(i, n):
 
            # store all possible unique
            # XOR value of pairs
            s.add(a[i] ^ a[j])
 
    ans = 0
    for i in s:
        for j in range(0, n):
 
            # store maximum value
            ans = max(ans, i ^ a[j])
 
    print(ans)
 
# Driver code
if __name__ == "__main__":
 
    a = [1, 3, 8, 15]
    n = len(a)
    Maximum_xor_Triplet(n, a)
 
# This code is contributed
# by Rituraj Jain

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // function to count maximum
    // XOR value for a triplet
    static void Maximum_xor_Triplet(int n, int []a)
    {
        // set is used to avoid repetitions
        HashSet<int> s = new HashSet<int>();
 
        for (int i = 0; i < n; i++)
        {
            for (int j = i; j < n; j++)
            {
 
                // store all possible unique
                // XOR value of pairs
                s.Add(a[i] ^ a[j]);
            }
        }
 
        int ans = 0;
        foreach (int i in s)
        {
            for (int j = 0; j < n; j++)
            {
 
                // store maximum value
                ans = Math.Max(ans, i ^ a[j]);
            }
        }
        Console.WriteLine(ans);
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []a = {1, 3, 8, 15};
        int n = a.Length;
        Maximum_xor_Triplet(n, a);
    }
}
 
/* This code has been contributed
by PrinciRaj1992*/

<script>
 
// JavaScript implementation of the approach
// function to count maximum
// XOR value for a triplet
function Maximum_xor_Triplet(n, a)
{
    // set is used to avoid repetitions
    let s = new Set();
 
    for (let i = 0; i < n; i++) {
        for (let j = i; j < n; j++) {
 
            // store all possible unique
            // XOR value of pairs
            s.add(a[i] ^ a[j]);
        }
    }
 
    let ans = 0;
 
    for (let i of s.values()) {
        for (let j = 0; j < n; j++) {
 
            // store maximum value
            ans = Math.max(ans, i ^ a[j]);
        }
    }
 
    document.write( ans, "<br>");
}
 
// Driver code
let a = [ 1, 3, 8, 15 ];
let n = a.length;
    Maximum_xor_Triplet(n, a);
 
</script>

15

Complejidad de tiempo: O(n*n*logn), ya que se utilizan bucles anidados
Espacio auxiliar: O(n), ya que se utiliza un espacio adicional de tamaño n para crear un conjunto