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

title	localeTitle
Find the Symmetric Difference	Encontre a diferença simétrica

Lembre-se de usar Read-Search-Ask se você ficar preso. Tente emparelhar o programa e escreva seu próprio código

Explicação do Problema:

A diferença simétrica (comumente denotada por Δ) de dois conjuntos é o conjunto de elementos que estão em um dos dois conjuntos, mas não em ambos.

Por exemplo, sym([1, 2, 3], [5, 2, 1, 4]) deve render [3, 4, 5] .

Seguindo a definição acima, a diferença simétrica de três conjuntos A , B e C pode ser expressa como (A Δ B) Δ C

Links Relevantes

• Diferença simétrica - Wikipedia
• Diferença simétrica - YouTube

[## Sugestão: 1

O objeto arguments é um objeto do tipo Array que herda apenas a propriedade Array.length . Por isso, considere convertê-lo em um Array real.

tente resolver o problema agora

Dica: 2

Considere gravar uma função auxiliar que retorna a diferença simétrica de duas matrizes em cada chamada, em vez de tentar diferenciar todos os conjuntos simultaneamente.

tente resolver o problema agora

Dica: 3

Aplique a função auxiliar na matriz de argumentos criada, reduzindo seus elementos de forma pareada recursivamente para formar a saída esperada.

Nota No caso de um número ímpar de conjuntos, a diferença simétrica incluirá elementos idênticos presentes em todos os conjuntos dados. Por exemplo;

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} 

tente resolver o problema agora

Alerta de Spoiler!

Solução à frente!

Solução básica de código:

    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 ":foguete:")](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
### Explicação do código:

*   `push()` é usado para dividir o objeto _arguments_ em um array, _args_ .
*   A função `symDiff` encontra a diferença simétrica entre dois conjuntos. É usado como uma função de retorno de chamada para o método `reduce()` chamado _args_ .
*   `arrayOne.forEach()` envia os elementos para o _resultado_ que estão presentes apenas no _arrayOne_ , bem como não fazem parte do _resultado_ .
*   `arrayTwo.forEach()` empurra os elementos para o _resultado_ que estão presentes apenas no _arrayTwo_ , assim como não fazem parte do _resultado_ .
*   O _resultado_ , que é a diferença simétrica, é retornado. Esta solução funciona para qualquer número de conjuntos.

#### Links 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 ":girassol:") Solução de Código Intermediário:

```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]); 

Explicação do código:

• O método slice() é usado para dividir o objeto arguments em um array, args .
• A função getDiff encontra a diferença simétrica entre dois conjuntos, arr1 e arr2 . É usado como uma função de retorno de chamada para o método reduce() chamado args .
• O primeiro filterFunction() retorna elementos em arr1 que não existem em arr2 .
• O próximo filterFunction() é executado em cada array contra o outro para verificar o inverso da primeira verificação de exclusividade e concatená-lo.
• O resumo consiste nos argumentos reduzidos.
• filter() é usado no resumo para manter apenas os valores exclusivos e exclusivo é retornado.

Links Relevantes

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

Solução avançada 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]); 

Explicação do código:

• A função principal sym () cria um array a partir de argumentos e reduz seus elementos utilizando a função auxiliar diffArray () para um único array.

• A função diffArray () retorna a diferença simétrica de dois arrays escolhendo elementos únicos em arrays parametrizados; arr1 e arr2 .

Links Relevantes

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

NOTAS PARA CONTRIBUIÇÕES:

• NÃO adicione soluções semelhantes às soluções existentes. Se você acha que é semelhante, mas melhor , tente mesclar (ou substituir) a solução semelhante existente.
• Adicione uma explicação da sua solução.
• Categorize a solução em uma das seguintes categorias - Básica , Intermediária e Avançada .
• Por favor, adicione seu nome de usuário somente se você adicionou qualquer conteúdo principal relevante . ( NÃO remova nenhum nome de usuário existente )

Vejo Wiki Challenge Solution Template para referência.