HackerRank #40 | Java Dequeue | 🇧🇷
Tags: java, hackerrank, queue
Published: 2021-11-22 20:35:53

[Esse exercício](https://www.hackerrank.com/challenges/java-dequeue/problem) recebe dois inputs iniciais: um `integer` N, relativo à quantidade de números em um array, e um `integer` M, relativo a um subarray deslocável que fará a "varredura" dentro do array principal.

![HackerRank Dequeue Imagem](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/622ln99nqilnyx4ludyb.png)

N = quantidade de números do array
M = tamanho do subarray que varrerá o array principal

Dessa forma, os arrays estruturados com M = 3 serão:

[5, 3, 5]
 . . . [3, 5, 2]
  . . . . . [5, 2, 3]
  .  . . . . . . [2, 3, 2]

Como todos os subarrays precisam ter M números, nesse caso esses serão os subarrays possíveis.

Depois disso, precisamos que o programa contabilize qual é o máximo de números únicos existentes em um subarray de tamanho M.

[5, 3, 5] = 2 números únicos
[3, 5, 2] = 3 números únicos
[5, 2, 3] = 3 números únicos
[2, 3, 2] = 2 números únicos

Sendo assim, o máximo de números únicos em um subarray será 3. Esse precisa ser o output.

Vamos para a solução, dividida em partes:

- Primeiro declaramos um Array de Integers de nome deque.
- Declaramos também um Hashset de Integers de nome hashset. Lembrando que um [Hashset não repete números](https://dev.to/beatrizmaciel/hackerrank-39-hashset-3jb3), e isso vai ser útil para que possamos contabilizar números únicos.
- Depois escaneamos os ints `N`, `M` e `maxUniqueIntegers` (nossa resposta final)
- Dentro de uma iteração, pegaremos, através de um input, os números do array. Lembrando: a quantidade de números do array é delimitada por N, mas será inserida pelo usuário.
- Vamos adicionar todos os números do input no `Array deque` e no `Hashset hashset` através do `.add`
- Faremos uma condicional que diz que nosso Array deque, tendo o mesmo tamanho de M, fará com que o hashset receba o maxUniqueIntegers para ir contabilizando as entradas de números únicos. Como o hashset só permite números únicos, o maxUniqueIntegers também só receberá a quantidade de números únicos.
- Depois, declararemos uma variável firstQueueNumber que fará a remoção do primeiro número do nosso array deque. A propriedade .remove sempre remove o primeiro elemento, ou o elemento que tem a menor posição i (leia mais sobre isso nas referências)
- Por fim, imprimimos o maxUniqueNumbers, com a quantidade de números únicos.

O código final fica assim:


```
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Deque<Integer> deque = new ArrayDeque<>();
        HashSet<Integer> hashset = new HashSet<>();
        
        int n = in.nextInt();
        int m = in.nextInt();
        int maxUniqueIntegers = 0;

        for (int i = 0; i < n; i++) {
            int num = in.nextInt();
            
            deque.add(num);
            hashset.add(num);
            
            if (deque.size() == m) {
                if (hashset.size() > maxUniqueIntegers) {
                    maxUniqueIntegers = hashset.size();
                }
                int firstQueueNumber = deque.remove();
                if (!deque.contains(firstQueueNumber)) {
                    hashset.remove(firstQueueNumber);
                } 
            }
        }
        
        System.out.println(maxUniqueIntegers);
    }
}
```

=======

#### Referências:

[ArrayList](https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#remove-int-) : Oracle

============

Essa publicação faz parte de uma série de exercícios resolvidos em Java no HackerRank. Acesse a série completa:

- [HackerRank #6 | Scanner e End-of-file](https://dev.to/beatrizmaciel/hackerrank-6-scanner-e-endoffile-462c)
- [HackerRank #7 | Int to String / String to Int](https://dev.to/beatrizmaciel/hackerrank-7-int-em-string-e-vice-versa-4n1e)
- [HackerRank #8 | Date and Time](https://dev.to/beatrizmaciel/hackerrank-8-date-and-time-1f78)
- [HackerRank #9 | Static Initializer Block](https://dev.to/beatrizmaciel/hackerrank-9-static-initializer-block-48ha)
- [HackerRank #10 | Currency Formatter](https://dev.to/beatrizmaciel/hackerrank-10-currency-formatter-22oj)
- [HackerRank #11 | DataTypes](https://dev.to/beatrizmaciel/hackerrank-11-datatypes-2e9h)
- [HackerRank #12 | Strings Introduction](https://dev.to/beatrizmaciel/hackerrank-12-strings-introduction-2d1n)
- [HackerRank #13 | Substring Comparisons](https://dev.to/beatrizmaciel/hackerrank-13-substring-comparisons-57ha)
- [HackerRank #14 | Abstract Class](https://dev.to/beatrizmaciel/hackerrank-14-abstract-class-3h5d)
- [HackerRank #18 | BigInteger](https://dev.to/beatrizmaciel/hackerrank-18-biginteger-4jad)
- [HackerRank #19 | Loops II](https://dev.to/beatrizmaciel/hackerrank-19-loops-ii-385n)
- [HackerRank #20 | String Reverse](https://dev.to/beatrizmaciel/hackerrank-20-string-reverse-nec)
- [HackerRank #23 | Instanceof keyword](https://dev.to/beatrizmaciel/hackerrank-23-instanceof-keyword-3lh6)
- [HackerRank #26 | Generics](https://dev.to/beatrizmaciel/hackerrank-26-generics-55p8)
- [HackerRank #27 | 1D Array](https://dev.to/beatrizmaciel/hackerrank-27-1d-array-5f80)
- [HackerRank #28 | Anagrams](https://dev.to/beatrizmaciel/hackerrank-28-anagrams-boi)
- [HackerRank #33 | Arraylist](https://dev.to/beatrizmaciel/hackerrank-33-arraylist-2lj1)
- [HackerRank #34 | Exception Handling Try / Catch](https://dev.to/beatrizmaciel/hackerrank-34-exception-handling-try-catch-144f)
- [HackerRank #36 | Exception Handling](https://dev.to/beatrizmaciel/hackerrank-35-exception-handling-44e)
- [HackerRank #37 | List](https://dev.to/beatrizmaciel/hackerrank-37-list-4gmj)
- [HackerRank #38 | SubArray](https://dev.to/beatrizmaciel/hackerrank-38-subarray-1693)
- [HackerRank #39 | HashSet](https://dev.to/beatrizmaciel/hackerrank-39-hashset-3jb3)
- HackerRank #40 | Java Dequeue