Como comparar itens repitidos no vetor java

Neste artigo você vai aprender a como remover elementos repetidos de um vetor em JavaScript – os conhecidos arrays da linguagem JS

Índice Show

Linguagem C
Solução na linguagem C
Linguagem Python
Solução na linguagem Python
Linguagem JavaScript (Node.js)
Solução na linguagem JavaScript (Node.js)

Fala programador(a), beleza? Bora aprender a como remover elementos repetidos de um vetor em JS!

Temos uma maneira muito fácil para fazer esta ação de remover duplicidade em arrays, o método filter é muito interessante para esta aplicação

Ele tem justamente esta função, realizar um filtro sobre uma variável que tem o tipo de dado array

Vamos ver a aplicação na prática:

var arr = [1, 3, 4, 6, 1, 2, 3, 4, 5, 7, 8, 6]; var semRepetidos = arr.filter(function(el, i) { return arr.indexOf(el) === i; }); console.log(semRepetidos);

Veja que há uma comparação entre o primeiro elemento encontrado no array pelo índice por meio de indexOf com o elemento atual da iteração

Isso faz com que apenas um elemento com o mesmo valor seja retornado, eliminando os elementos repetidos no vetor

Desta maneira resolvemos nosso problema de forma simples

Vale a ressalva que o filter é uma função um pouco recente, tornando a sua utilização em navegadores antigos impossibilitada

Mas você tem uma alternativa chamada Polyfill, veja neste link

Desta forma você vai conseguir rodar a função filter em qualquer versão de qualquer navegador, pois este código é feito com recursos já padronizados

É disto que o Polyfill trata =)

Conclusão

Neste artigo vimos como remover elementos repetidos de um vetor em JavaScript, ou seja, eliminar os elementos que se repetem no array

A função filter encaixa com uma luva para esta ação, podendo ser feito um filtro no array alvo

E sendo retornado apenas os elementos que passam neste filtro, conforme foi exibido anteriormente no post

Um cuidado interessante é utilizar o Polyfill caso sua aplicação precisa garantir compatibilidade entre os navegadores mais antigos também

O Polyfill é uma versão de uma função mais moderna, só que utilizando código já padronizado de JS pelos navegadores

Confira também nosso catálogo de cursos gratuitos, com aulas semanais no YouTube

Faça um programa que identifique se em um determinado vetor, existem ou não valores repetidos.

Linguagem C

#include <stdio.h> #include <assert.h> int main() { int vet[5], tamanho = 5; // vetor e tamanho do vetor int i, j, resp = 0; // auxiliares // Aqui entra a lógica do programa. // // Teste // assert(1 == resp); return (0); }

Solução na linguagem C

#include <stdio.h> #include <assert.h> int main() { int vet[5], tamanho = 5; // vetor e tamanho do vetor int i, j, resp = 0; // auxiliares vet[0] = 100; vet[1] = 200; vet[2] = 300; vet[3] = 300; // valor repetido vet[4] = 500; for (i = 0; i <= tamanho; i++) { for (j = i + 1; j < tamanho; j++) { if (vet[j] == vet[i]) { resp = 1; // há um valor repetido } } } // // Teste // assert(1 == resp); return (0); }

Linguagem Python

Dica: em Python tente remover os duplicados e depois comparar os tamanhos das listas.

Se os tamanhos forem iguais sabemos que não houve alteração, nem tão pouco valores repetidos.

Se os tamanhos forem diferentes é porque houve valores repetidos.

# -*- coding: utf-8 -*- # # Sua lógica... # def haDuplicados(lista): pass # # Testes # assert haDuplicados([100, 200, 300, 300, 500]) assert not haDuplicados([100, 200, 300, 400, 500])

Solução na linguagem Python

Este exercício de lógica é para praticar laços de repetição, então aí vai a primeira solução….

def haDuplicados(lista): _lis = [] # removendo duplicados for x in lista: if x not in _lis: _lis.append(x) # comparando os tamanhos if len(lista) != len(_lis): return True else: return False

Olhando para o código percebo que tenho uma função com duas responsabilidades: a) remover duplicados e b) comparar tamanhos.

Resolvo separar as obrigações em duas funções…

def removerDuplicados(duplicado): _lis = [] for x in duplicado: if x not in _lis: _lis.append(x) return _lis def haDuplicados(lista): if len(lista) != len(removerDuplicados(lista)): return True else: return False

Já melhorou! Agora é nítido que o código funciona em duas etapas. Isso faz toda a diferença, por que agora estou olhando individualmente para cada função.

Estou olhando para removerDuplicados() e me pergunto dá para simplificar?

Fuçando na Internet descobri que posso resolver a função em uma única linha utilizando set().

def removerDuplicados(duplicado): return set(duplicado) def haDuplicados(lista): if len(lista) != len(removerDuplicados(lista)): return True else: return False

Olha que lindo! Eu gosto do código acima porque ele deixa bem claro qual é a intenção e o significado, mesmo para quem não conhece a linguagem a fundo.

Porém, a função ficou tão pequena que resolvi eliminá-la.

def haDuplicados(lista): if len(lista) != len(set(lista)): return True else: return False

Quem não conhece a função set() do Python vai ficar meio na dúvida do funcionamento do código. Neste caso, nada que um bom comentário não resolva.

# Descobre se há duplicados em duas etapas. # 1- remove os duplicados `set()` # 2- compara se os tamanhos foram alterados def haDuplicados(lista): ...

Estando tudo no lugar, sobrou tempo para raciocinar melhor e percebemos que a expressão é o próprio resultado, então…

def haDuplicados(lista): return len(lista) != len(set(lista))

Agora ficou ninja! Resolvemos tudo em um única linha.

Linguagem JavaScript (Node.js)

Abaixo nosso código inicial escrito em JavaScript (Node.js), utilize ele para resolver o problema.

Solução na linguagem JavaScript (Node.js)

Nós poderíamos imitar a linguagem C na solução, mas não precisamos nem perder o nosso tempo com isso. Também poderíamos resolver em 2 passos, semelhante a solução em Python (removemos e depois comparamos o tamanho das listas). Mas eu quero tentar algo diferente, será que conseguiremos descobrir se há ou não repetidos sem mexer no array?

Sim! Veja o código…

Vou explicar o truque.

O segredo está na utilização da função embutida indexOf(), ela retorna o índice do valor procurado, por exemplo…

var arr = [100, 200, 300, 300, 500]; console.log(arr.indexOf(100)); // 0 console.log(arr.indexOf(200)); // 1 console.log(arr.indexOf(300)); // 2 console.log(arr.indexOf(300)); // 2 <--- atenção console.log(arr.indexOf(500)); // 4

A função retorná sempre o primeiro valor encontrado e aqui está a mágica. Quando houver repetido, teremos um pequeno desencontro entre valor e índice, veja as expressões abaixo…

arr.indexOf(100) == 0; // true arr.indexOf(200) == 1; // true arr.indexOf(300) == 2; // true arr.indexOf(300) == 3; // false <--- aqui temos o valor repetido arr.indexOf(500) == 4; // true

Resumindo, sempre que houver valores repetidos teremos ao menos um valor false, logo basta percorrer o array e checar se o valor atual bate com o índice (do laço, da iteração). Se ainda não entendeu, veja o código comentado abaixo.