# 12/30 - 30 Dias de HackerRank

> ## [Divisible Sum Pairs](https://www.hackerrank.com/challenges/divisible-sum-pairs/)
> 
> Dada uma *array* de números inteiros e um inteiro positivo \\(k\\), determine o número de pares \\((i, j)\\) com \\(i < j\\) e que \\(ar[i] + ar[j]\\) é divisível por \\(k\\).
> 
> 
> **Exemplo:**<br>
> \\(ar = [1, 2, 3, 4, 5, 6]\\)<br>
> \\(k = 5\\)
> 
> Três pares atendem aos critérios: \\([1, 4]\\), \\([2, 3]\\) e \\([4, 6]\\).


Para descobrir quantos pares desses existem, podemos seguir os seguintes passos:
1. Inicializar uma variável contadora com 0;
2. Iterar pela array para iniciar os cálculos;
3. Iterar novamente pela array, definindo como início do loop o índice do elemento ativo do loop anterior + 1;
4. Somar os elementos ativos dos dois laços;
5. Se o resultado da soma for divisível pela variável k, adicionar 1 ao contador
6. Ao final dos loops, retornar o contador.

Assim como no desafio de [ontem](https://lnabesima.hashnode.dev/1130-30-dias-de-hackerrank), a primeira coisa a se fazer é inicializar uma variável contadora, porque iremos verificar a quantidade de pares que existem dentro das condições especificadas.<br>
Além disso, é especificado que ela recebe os seguintes argumentos:

- `n`, que é o comprimento da lista de inteiros `ar`;
- `k`, o número que será o divisor da soma de pares e;
- `ar`, a *array* de valores nos quais verificaremos a divisão da soma dos pares.

```JS
function divisibleSumPairs(n, k, ar) {
  let counter = 0;
}
``` 

Em seguida, vamos iterar pela *array* `ar`, para selecionarmos o primeiro item do par \\((i, j)\\). Poderíamos usar o método [Array.forEach()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach), mas como vamos construir um segundo laço que depende o índice do primeiro, achei melhor usar um [for](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/for) simples mesmo. <br>
Depois desse primeiro *loop* vamos construir outro *for*, porém esse terá como índice inicial o índice do elemento ativo do primeiro *loop* + 1.

```JS
function divisibleSumPairs(n, k, ar) {
  let counter = 0;
  for (let i = 0; i < ar.length; i++) {
    for (let j = i + 1; j < ar.length; j++) {}
  }
  return counter;
}
```
Fazemos isso para atender o requerimento que pede que \\(i\\) seja **menor** que \\(j\\).

Com isso já conseguimos andar pela *array* e pegar todos os pares possíveis para \\((i, j)\\). Agora só precisamos inserir o cálculo dentro do laço interno. O problema pede que contemos quantos pares tem o valor da soma de seus elementos divisível por \\(k\\). <br>
Para verificarmos se algum número é divisível por outro, podemos verificar se o resto da divisão entre os dois é igual a zero. Caso for, o número é divisível. Aplicando isso ao código, temos a seguinte situação:

```JS
function divisibleSumPairs(n, k, ar) {
  let counter = 0;
  for (let i = 0; i < ar.length; i++) {
    for (let j = i + 1; j < ar.length; j++) {
      (ar[i] + ar[j]) % k === 0 ? counter++ : null;
    }
  }
  return counter;
}
```

Para tornar o código um pouco mais conciso (já que existem dois laços *for* 😵), usei o [operador ternário](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) ao invés de um *if*. Caso a condição for verdadeira, a variável `counter` é incrementada em um. Caso contrário, nada é realizado.

Agora, é só verificar se a lógica está correta!

![image.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1670258074719/jWQmOG4rp.png align="center")

🔝<br>
Até o próximo desafio!