10 KiB
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
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]);
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étodoreduce()
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]);
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
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.