HackerRank #33 | Arraylist | 🇧🇷
Tags: java, arraylist, array, wecoded
Published: 2021-09-09 20:34:53

[Neste exercício](https://www.hackerrank.com/challenges/java-arraylist/problem) devemos receber vários inputs diferentes.
O exercício é bem complexo de ser compreendido (precisei de ajuda pra entender o enunciado) e vou tentar explicar da melhor forma possível. Para isso, vou dividir o exercício em duas partes:

=========

#### Parte I

* Recebemos um `int n`.  Este `int` delimita a quantidade de Arrays que teremos na lista.
* Recebemos um `int d`. Este `int` delimita a quantidade de elementos dentro do array.

Exemplo (n = 2 | d = 3, 4):

```
2
3 11 22 33
4 54 12 3 12
```

Logo, todos os primeiros números estão, na verdade, ordenando a quantidade de listas ou a quantidade de elementos da lista.

Para resolver essa primeira parte do problema segui o seguinte passo a passo:

* Fiz o `Scanner`
* Peguei o `int n` a partir desse `Scanner`
* Criei um `ArrayList[] nArray = new ArrayList[n]` (`n` significa que o número de arrays obedecerá o `input n`
* Fiz um `for` que pega, através do `scanner.nextInt()` cada novo `Array` através de `d`.
* Dentro do `for`, fiz outro `for` declarando um `int j` que fará a substituição de cada posição [i] dos arrays.

Ficou mais ou menos assim:

```
        Scanner scanner = new Scanner(new File("input.txt"));
        int n = scanner.nextInt();
        int d;

        ArrayList[] nArray = new ArrayList[n]; // n é a quantidade de arrays

            for (int i = 0; i < n; i++) {
                d = scanner.nextInt();
                nArray[i] = new ArrayList();
                for (int j = 0; j < d; j++){
                    nArray[i].add(scanner.nextInt());
            }
        }
```

Perceba que o primeiro `for` percorre o tamanho de `n` enquanto que o segundo `for` percorre o tamanho de `d`. Isso significa que só fazemos o segundo array depois que passamos por todos os elementos dele e assim até que o número de arrays seja menor `<` do que `n`

=========

#### Parte II

Agora vem a segunda parte do problema. Aqui recebemos outro `int` chamado `q` e é ele que delimita a quantidade de linhas (chamadas) que vamos ter.
Aqui, escolhemos dois números, `x` e `y`. `x` especifica o número da linha e `y` especifica o número da coluna. Isso quer dizer que vamos "pegar" um elemento de cada array que declaramos anteriormente através de `x` e `y`.
A ilustração do problema pode ser mais clara:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vt3o061btvodu5djjevb.png)

Aqui a ilustração que fiz para entender melhor os `ints` `n`, `d` e `q`.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k9lr19w71uabs3ihotpo.png)

Para resolver a segunda parte, fiz o seguinte passo a passo:

* Declarei o `int q = scanner.nextInt()`
* Declarei também `x` e `y`, sem inicializá-los. 
> É importante declará-los fora do `for` que vamos fazer, porque usaremos mesmo quando a iteração acabar.
* O `for` consiste em iterar a letra h até que o tamanho seja menor `<` do que `q` e escanear `x` e `y`. Assim:

```
            int q = scanner.nextInt();
            int x;
            int y;

            for (int h = 0; h < q; h++){
                x = scanner.nextInt();
                y = scanner.nextInt();
```

Por fim, para que o console devolva a mensagem `ERROR!` caso `x` e `y` não convirjam, é necessário fazer um `try / catch`. Nesse caso, como os Arrays começam na posição 0 (e não levamos isso em consideração para declarar as posições em `x` e `y`), precisamos especificar no `try` que a posição que queremos é, na verdade, `x - 1` e `y - 1`.
No `catch` declaramos que a `Exception e` gera um `System.out.println("ERROR!");`.

O código final fica assim:

```
public class Solution {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int d;

        ArrayList[] nArray = new ArrayList[n];

            for (int i = 0; i < n; i++) {
                d = scanner.nextInt();
                nArray[i] = new ArrayList();
                for (int j = 0; j < d; j++){
                    nArray[i].add(scanner.nextInt());
            }
        }
            int q = scanner.nextInt();
            int x;
            int y;

            for (int h = 0; h < q; h++){
                x = scanner.nextInt();
                y = scanner.nextInt();
                try{
                    System.out.println(nArray[x-1].get(y-1));
                } catch(Exception e){
                    System.out.println("ERROR!");
                }
            }

        scanner.close();
    }
}
```

=========

#### Referências

[ArrayList](https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html) : 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
- [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](https://dev.to/beatrizmaciel/hackerrank-40-java-dequeue--497h)