[Dúvida] Remover duplicados de um Array | Java | Alura

Estou fazendo um exercício do site Leet Code.

Dado um array inteiro numsclassificado em ordem não decrescente , remova as duplicatas no local de forma que cada elemento único apareça apenas uma vez . A ordem relativa dos elementos deve ser mantida a mesma . Em seguida, retorne o número de elementos exclusivos emnums .

Considere o número de elementos exclusivos de numsto be k, para ser aceito, você precisa fazer o seguinte:

Altere a matriz numsde forma que os primeiros kelementos de numscontenham os elementos exclusivos na ordem em que estavam presentes numsinicialmente. Os elementos restantes de numsnão são importantes, assim como o tamanho de nums. Retornar k. Juiz personalizado:

O juiz testará sua solução com o seguinte código:

int[] num = [...]; // Array de entrada int[]Nums esperados = [...]; // A resposta esperada com comprimento correto

int k = removeDuplicates(nums); // Chama sua implementação

assert k == esperadoNums.length; for (int i = 0; i < k; i++) { assert nums[i] == esperadoNums[i]; } Se todas as asserções forem aprovadas, sua solução será aceita .

Exemplo 1:

Entrada: nums = [1,1,2] Saída: 2, nums = [1,2,_] Explicação: Sua função deve retornar k = 2, com os dois primeiros elementos de nums sendo 1 e 2 respectivamente. Não importa o que você deixa além do k retornado (portanto, são sublinhados). Exemplo 2:

Entrada: nums = [0,0,1,1,1,2,2,3,3,4] Saída: 5, nums = [0,1,2,3,4,,_,,_, _] Explicação: Sua função deve retornar k = 5, com os cinco primeiros elementos de nums sendo 0, 1, 2, 3 e 4, respectivamente. Não importa o que você deixa além do k retornado (portanto, são sublinhados).

Eu fiz assim, no eclipse deu certo, mas no site não está dando certo:

import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set;

class Solucao { public static void main(String[] args) {

    List<Integer> nums = new ArrayList<>();
    nums.add(1);
    nums.add(2);
    nums.add(3);
    nums.add(3);
    nums.add(4);
    nums.add(2);

    Set<Integer> sets = new HashSet<>(nums);
    System.out.println(sets);

}

}

Oi, Patrícia, tudo bem?

Desculpe a demora em te responder!

Sites que nos ajudam a praticar códigos como, por exemplo, o LeetCode avaliam o código que construímos com base em teste estabelecidos pela plataforma em relação às boas práticas, tempo de execução, performance, nome de variáveis, dentre outros.

O exercício pede que dada uma matriz classificada nums, seja removida as duplicatas no local de forma que cada elemento apareça apenas uma vez e retorne o novo comprimento.

Para solucionar o problema levamos em consideração que a matriz está classificada . Isso significa que todos os elementos duplicados serão adjacentes uns aos outros, ou seja, no array [1,2,2,3,4,4,4,5,5,6,7], vemos que todos os elementos duplicados são adjacentes uns aos outros. Dessa forma, podemos usando as seguintes etapas:

Verifique se a corrente e o próximo elemento são iguais.
Se estiverem, pularemos o próximo elemento e continuaremos o procedimento enquanto encontrarmos as duplicatas.
Se os elementos não estiverem duplicados, colocaremos o próximo elemento (diferente) ao lado do elemento atual.

O código para a resolução do exercício, ficaria assim:

class Solution {
    public int removeDuplicates(int[] nums) {
         int count = 0;
        // Loop for all the elements in the array
        for (int i = 0; i < nums.length; i++) {
            // If the current element is equal to the next element, we skip
            if (i < nums.length - 1 && nums[i] == nums[i + 1]) {
                continue;
            }
            // We will update the array in place
            nums[count] = nums[i];
            count++;
        }
        return count;
    }
}

O código acima começa por declarar o método como público, acessível de fora da classe, que aceita um array de números inteiros chamado nums como parâmetro, retornando um inteiro que representa o comprimento do novo array após a remoção das duplicatas.

Em seguida uma variável counté declarada e inicializada com zero. Essa variável será usada para manter o índice onde o próximo elemento único será colocado no array.

Após isso, um loop for é iniciado, iterando por todos os elementos do array nums. Dentro do loop, a cada iteração, o código verifica se o elemento atual (indicado por nums[i]) é igual ao próximo elemento (indicado por nums[i + 1]). Se forem iguais, o continue é chamado, o que faz com que o loop pule para a próxima iteração.

No caso do elemento atual não ser uma duplicata, ele é copiado para a posição count no array nums, e o índice count é incrementado. Isso efetivamente remove as duplicatas, pois os elementos únicos são copiados para as primeiras posições do array. Após percorrer todo o loop e realizar as cópias necessárias, o método retorna o valor final de count, que representa o comprimento do novo array sem duplicatas.

Espero ter ajudado. Caso tenha dúvidas, não hesite em postar no fórum!

Abraços e bons estudos!

Caso este post tenha lhe ajudado, por favor, marcar como solucionado ✓. Bons Estudos!