freeCodeCamp/guide/spanish/certifications/coding-interview-prep/algorithms/find-the-symmetric-difference/index.md

title	localeTitle
Find the Symmetric Difference	Encuentra la diferencia simétrica

Recuerda usar Read-Search-Ask si te atascas. Tratar de emparejar el programa y escribe tu propio código

Explicación del problema:

La diferencia simétrica (comúnmente denotada por Δ) de dos conjuntos es el conjunto de elementos que están en cualquiera de los dos conjuntos, pero no en ambos.

Por ejemplo, sym([1, 2, 3], [5, 2, 1, 4]) debe producir [3, 4, 5] .

Siguiendo la definición anterior, la diferencia simétrica de los tres conjuntos A , B y C se puede expresar como (A Δ B) Δ C

Enlaces relevantes

• Diferencia simétrica - Wikipedia
• Diferencia simétrica - YouTube

[## Sugerencia: 1

El objeto de argumentos es un objeto de tipo Array que solo hereda la propiedad Array.length . Por lo tanto, considere convertirlo en una matriz real.

intenta resolver el problema ahora

Sugerencia: 2

Decida escribir una función auxiliar que devuelva la diferencia simétrica de dos matrices en cada llamada en lugar de intentar diferenciar todos los conjuntos simultáneamente.

intenta resolver el problema ahora

Sugerencia: 3

Aplique la función de ayuda contra la matriz de argumentos creada, reduciendo sus elementos en forma recursiva por pares para formar el resultado esperado.

Nota En el caso de un número impar de conjuntos, la diferencia simétrica incluirá elementos idénticos presentes en todos los conjuntos dados. Por ejemplo;

A = {1, 2, 3} 
 B = {2, 3, 4} 
 C = {3, 4, 5} 
 
 (A ⋂ B) ⋂ C = {1, 4} &Intersection {3, 4, 5} 
 A ⋂ B = {1, 3, 5} 

intenta resolver el problema ahora

¡Alerta de spoiler!

¡Solución por delante!

Solución de código básico:

    function sym() { 
      var args = []; 
      for (var i = 0; i < arguments.length; i++) { 
        args.push(arguments[i]); 
      } 
 
      function symDiff(arrayOne, arrayTwo) { 
        var result = []; 
 
        arrayOne.forEach(function(item) { 
          if (arrayTwo.indexOf(item) < 0 && result.indexOf(item) < 0) { 
            result.push(item); 
          } 
        }); 
 
        arrayTwo.forEach(function(item) { 
          if (arrayOne.indexOf(item) < 0 && result.indexOf(item) < 0) { 
            result.push(item); 
          } 
        }); 
 
        return result; 
      } 
 
      // Apply reduce method to args array, using the symDiff function 
      return args.reduce(symDiff); 
    } 

```](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) 

 [![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:")](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) [Ejecutar código](https://repl.it/C4II/0)

### Explicación del código:

*   `push()` se utiliza para desglosar el objeto de _argumentos_ en una matriz, _args_ .
*   La función `symDiff` encuentra la diferencia simétrica entre dos conjuntos. Se utiliza como una función de devolución de llamada para el método `reduce()` llamado en _args_ .
*   `arrayOne.forEach()` empuja los elementos al _resultado_ que están presentes solo en _arrayOne_ y que no forman parte del _resultado_ .
*   `arrayTwo.forEach()` empuja los elementos al _resultado_ que están presentes solo en _arrayTwo_ y que no forman parte del _resultado_ .
*   Se devuelve el _resultado_ , que es la diferencia simétrica. Esta solución funciona para cualquier número de conjuntos.

#### Enlaces relevantes

*   [JavaScript para](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/statements/for)
*   [JavaScript Array.length](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
*   [JavaScript Array.prototype.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
*   [JavaScript Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
*   [JavaScript Array.prototype.indexOf ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)

## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:

```javascript
    function sym() { 
 
      // Convert the argument object into a proper array 
      var args = Array.prototype.slice.call(arguments); 
 
      // Return the symmetric difference of 2 arrays 
      var getDiff = function(arr1, arr2) { 
 
        // Returns items in arr1 that don't exist in arr2 
        function filterFunction(arr1, arr2) { 
          return arr1.filter(function(item) { 
            return arr2.indexOf(item) === -1; 
          }); 
        } 
 
        // Run filter function on each array against the other 
        return filterFunction(arr1, arr2) 
          .concat(filterFunction(arr2, arr1)); 
      }; 
 
      // Reduce all arguments getting the difference of them 
      var summary = args.reduce(getDiff, []); 
 
      // Run filter function to get the unique values 
      var unique = summary.filter(function(elem, index, self) { 
        return index === self.indexOf(elem); 
        }); 
      return unique; 
    } 
 
    // test here 
    sym([1, 2, 3], [5, 2, 1, 4]); 

Ejecutar código

Explicación del código:

• El método slice() se utiliza para desglosar el objeto de argumentos en una matriz, args .
• La función getDiff encuentra la diferencia simétrica entre dos conjuntos, arr1 y arr2 . Se utiliza como una función de devolución de llamada para el método reduce() llamado en args .
• El primer filterFunction() devuelve elementos en arr1 que no existen en arr2 .
• El siguiente filterFunction() se ejecuta en cada matriz contra la otra para verificar la inversa de la primera comprobación de singularidad y concatenarla.
• El resumen consiste en los argumentos reducidos.
• filter() se usa en el resumen para mantener solo los valores únicos y se devuelve unique .

Enlaces relevantes

• JavaScript Array.prototype.slice ()
• JavaScript Array.prototype.filter ()
• JavaScript Array.prototype.concat ()

Solución avanzada de código:

    function sym() { 
      let argv = Array.from(arguments).reduce(diffArray); 
      return argv.filter((element, index, array) => index === array.indexOf(element));//remove duplicates 
    } 
 
    function diffArray(arr1, arr2) { 
      return arr1 
        .filter(element => !arr2.includes(element)) 
        .concat(arr2.filter(element => !arr1.includes(element))); 
    } 
 
    // test here 
    sym([1, 2, 3], [5, 2, 1, 4]); 

Ejecutar código

Explicación del código:

• La función principal sym () crea una matriz a partir de argumentos y reduce sus elementos utilizando la función helper diffArray () a una sola matriz.

• La función diffArray () devuelve la diferencia simétrica de dos matrices seleccionando elementos únicos en matrices parametrizadas; arr1 y arr2 .

Enlaces relevantes

• JavaScript Array.from ()
• JavaScript Array.prototype.filter ()

NOTAS PARA LAS CONTRIBUCIONES:

• NO agregue soluciones que sean similares a las soluciones existentes. Si cree que es similar pero mejor , intente fusionar (o reemplazar) la solución similar existente.
• Agregue una explicación de su solución.
• Categorice la solución en una de las siguientes categorías: Básica , Intermedia y Avanzada .
• Agregue su nombre de usuario solo si ha agregado algún contenido principal relevante . ( NO elimine ningún nombre de usuario existente )

Ver Wiki Challenge Solution Template para referencia.