Eliminar un elemento para obtener el máximo XOR

Dada una array arr[] de N elementos, la tarea es eliminar un elemento de la array de modo que se maximice el valor XOR de la array. Imprime el valor maximizado.
Ejemplos: 
 

Entrada: arr[] = {1, 1, 3} 
Salida: 2 
Todas las formas posibles de eliminar un elemento y sus valores XOR correspondientes serán: 
a) Eliminar 1 -> (1 XOR 3) = 2 
b) Eliminar 1 -> (1 XOR 3) = 2 
c) Eliminar 3 -> (1 XOR 1) = 0 
Por lo tanto, la respuesta final es 2.
Entrada: arr[] = {3, 3, 3} 
Salida: 0 
 

Enfoque ingenuo: una forma será eliminar cada elemento uno por uno y luego encontrar el XOR de los elementos restantes. La complejidad temporal de este enfoque será O(N ² ).
Enfoque eficiente: 
 

• Encuentre XOR de todos los elementos de la array. Llamemos a este valor X .
• Para cada elemento arr[i] , realice Y = (X XOR arr[i]) y actualice la respuesta final como ans = max(Y, ans) .

El método anterior funciona porque si (A XOR B) = C entonces (C XOR B) = A. Para encontrar XOR(arr[0…i-1]) ^ XOR(arr[i+1…N-1]) , todo lo que tenemos que realizar es XOR(arr) ^ arr[i] donde XOR(arr) es el XOR de todos los elementos de la array.
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 return the maximized XOR
// after removing an element from the array
int maxXOR(int* arr, int n)
{
    // Find XOR of the complete array
    int xorArr = 0;
    for (int i = 0; i < n; i++)
        xorArr ^= arr[i];
 
    // To store the final answer
    int ans = 0;
 
    // Iterating through the array to find
    // the final answer
    for (int i = 0; i < n; i++)
        ans = max(ans, (xorArr ^ arr[i]));
 
    // Return the final answer
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 1, 3 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << maxXOR(arr, n);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
     
    // Function to return the maximized XOR
    // after removing an element from the array
    static int maxXOR(int arr[], int n)
    {
        // Find XOR of the complete array
        int xorArr = 0;
        for (int i = 0; i < n; i++)
            xorArr ^= arr[i];
     
        // To store the final answer
        int ans = 0;
     
        // Iterating through the array to find
        // the final answer
        for (int i = 0; i < n; i++)
            ans = Math.max(ans, (xorArr ^ arr[i]));
     
        // Return the final answer
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int arr[] = { 1, 1, 3 };
        int n = arr.length;
        System.out.println(maxXOR(arr, n));
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation of the approach
 
# Function to return the maximized XOR
# after removing an element from the array
def maxXOR(arr, n):
     
    # Find XOR of the complete array
    xorArr = 0
    for i in range(n):
        xorArr ^= arr[i]
 
    # To store the final answer
    ans = 0
 
    # Iterating through the array to find
    # the final answer
    for i in range(n):
        ans = max(ans, (xorArr ^ arr[i]))
 
    # Return the final answer
    return ans
 
# Driver code
arr = [1, 1, 3]
n = len(arr)
 
print(maxXOR(arr, n))
 
# This code is contributed by Mohit Kumar

// C# implementation of the approach
using System;
 
class GFG
{
     
    // Function to return the maximized XOR
    // after removing an element from the array
    static int maxXOR(int []arr, int n)
    {
        // Find XOR of the complete array
        int xorArr = 0;
        for (int i = 0; i < n; i++)
            xorArr ^= arr[i];
     
        // To store the readonly answer
        int ans = 0;
     
        // Iterating through the array to find
        // the readonly answer
        for (int i = 0; i < n; i++)
            ans = Math.Max(ans, (xorArr ^ arr[i]));
     
        // Return the readonly answer
        return ans;
    }
     
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = { 1, 1, 3 };
        int n = arr.Length;
        Console.WriteLine(maxXOR(arr, n));
    }
}
 
// This code is contributed by 29AjayKumar

<script>
// Javascript implementation of the approach
 
// Function to return the maximized XOR
// after removing an element from the array
function maxXOR(arr, n)
{
    // Find XOR of the complete array
    let xorArr = 0;
    for (let i = 0; i < n; i++)
        xorArr ^= arr[i];
 
    // To store the final answer
    let ans = 0;
 
    // Iterating through the array to find
    // the final answer
    for (let i = 0; i < n; i++)
        ans = Math.max(ans, (xorArr ^ arr[i]));
 
    // Return the final answer
    return ans;
}
 
// Driver code
    let arr = [ 1, 1, 3 ];
    let n = arr.length;
 
    document.write(maxXOR(arr, n));
 
</script>

2

Complejidad de tiempo: O(n)

Espacio Auxiliar: O(1)