Encuentra un elemento adicional en la segunda array

Dadas dos arrays A[] y B[] . La segunda array B[] contiene todos los elementos de A[] excepto 1 elemento adicional. La tarea es encontrar ese elemento extra.
Ejemplos: 
 

Entrada: A[] = { 1, 2, 3 }, B[] = {1, 2, 3, 4} 
Salida: 4  El
elemento 4 no está presente en la array
Entrada: A[] = {10, 15, 5} , B[] = {10, 100, 15, 5} 
Salida: 100 
 

Enfoque ingenuo: ejecute bucles anidados y encuentre el elemento en B[] que no está presente en A[] . La complejidad temporal de este enfoque será O(n ² ) .
Enfoque eficiente: si todos los elementos de A[] y B[] se combinan con XOR, entonces cada elemento de A[] dará 0 con su aparición en B[] y el elemento adicional dice X cuando se XOR con 0 dará (X XOR 0) = X que es el resultado.
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 extra
// element in B[]
int extraElement(int A[], int B[], int n)
{
 
    // To store the result
    int ans = 0;
 
    // Find the XOR of all the element
    // of array A[] and array B[]
    for (int i = 0; i < n; i++)
        ans ^= A[i];
    for (int i = 0; i < n + 1; i++)
        ans ^= B[i];
 
    return ans;
}
 
// Driver code
int main()
{
    int A[] = { 10, 15, 5 };
    int B[] = { 10, 100, 15, 5 };
    int n = sizeof(A) / sizeof(int);
 
    cout << extraElement(A, B, n);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
     
    // Function to return the extra
    // element in B[]
    static int extraElement(int A[], int B[], int n)
    {
     
        // To store the result
        int ans = 0;
     
        // Find the XOR of all the element
        // of array A[] and array B[]
        for (int i = 0; i < n; i++)
            ans ^= A[i];
        for (int i = 0; i < n + 1; i++)
            ans ^= B[i];
     
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int A[] = { 10, 15, 5 };
        int B[] = { 10, 100, 15, 5 };
        int n = A.length;
     
        System.out.println(extraElement(A, B, n));
    }
}
 
// This code is contributed by kanugargng

# Python3 implementation of the approach
# Function to return the extra
# element in B[]
def extraElement(A, B, n):
 
    # To store the result
    ans = 0;
 
    # Find the XOR of all the element
    # of array A[] and array B[]
    for i in range(n):
        ans ^= A[i];
    for i in range(n + 1):
        ans ^= B[i];
 
    return ans;
 
# Driver code
A = [ 10, 15, 5 ];
B = [ 10, 100, 15, 5 ];
n = len(A);
 
print(extraElement(A, B, n));
 
# This code is contributed by 29AjayKumar

// C# implementation of the approach
using System;
     
class GFG
{
     
    // Function to return the extra
    // element in B[]
    static int extraElement(int []A,
                            int []B, int n)
    {
     
        // To store the result
        int ans = 0;
     
        // Find the XOR of all the element
        // of array A[] and array B[]
        for (int i = 0; i < n; i++)
            ans ^= A[i];
        for (int i = 0; i < n + 1; i++)
            ans ^= B[i];
     
        return ans;
    }
     
    // Driver code
    public static void Main (String[] args)
    {
        int []A = { 10, 15, 5 };
        int []B = { 10, 100, 15, 5 };
        int n = A.Length;
     
        Console.WriteLine(extraElement(A, B, n));
    }
}
 
// This code is contributed by 29AjayKumar

<script>
// Javascript implementation of the approach
 
// Function to return the extra
// element in B[]
function extraElement(A, B, n)
{
 
    // To store the result
    let ans = 0;
 
    // Find the XOR of all the element
    // of array A[] and array B[]
    for (let i = 0; i < n; i++)
        ans ^= A[i];
    for (let i = 0; i < n + 1; i++)
        ans ^= B[i];
 
    return ans;
}
 
// Driver code
    let A = [ 10, 15, 5 ];
    let B = [ 10, 100, 15, 5 ];
    let n = A.length;
 
    document.write(extraElement(A, B, n));
 
// This code is contributed by subhammahato348.
</script>

100

Complejidad de tiempo: O(N) 
Complejidad de espacio: O(1)