Zerando HackerRank: Simple Array Sum e Compare the Triplets
Tags: javascript, tutorial, programming, braziliandevs
Published: 2023-01-27 13:26:48

O HackerRank é uma plataforma de contratação de tecnologia que é o padrão para avaliar as habilidades de desenvolvedores para mais de 3.000 empresas em todo o mundo. Ao permitir que recrutadores de tecnologia e gerentes de contratação avaliem objetivamente o talento em todas as etapas do processo de recrutamento, o HackerRank ajuda as empresas a contratar desenvolvedores qualificados e inovar mais rapidamente.

Além disso, é um ambiente digital com assuntos que vão testá-lo(a) para aprimorar, cada vez mais, a sua habilidade de resolver os problemas e o seu raciocínio lógico. 

Nesse tutorial, irei lhe ajudar a entender como solucionar alguns desafios que você encontrará no HackerRank, usando a linguagem TypeScript.

Desafios que abordaremos:

1. Simple Array Sum 
2. Compare the Triplets


## Simple Array Sum

Nesse desafio, dado um array de números inteiros, ele pede que você encontre a soma de todos os itens do array. Você deverá completar a função `simpleArraySum` para retornar a soma de todos os itens do array como um inteiro. Caso queira fazer o desafio no HackerRank, acesse o [link desse desafio](https://www.hackerrank.com/challenges/simple-array-sum/problem?isFullScreen=true).

Ele espera receber esse valor como entrada:

```jsx
6
1 2 3 4 10 11
```

E a soma dos valores como saída:

```jsx
31
```

Para solucionar esse desafio, iremos usar o método `reduce()`. 
Como o nome sugere, o `reduce()` busca reduzir um array. Ele iterará por cada elemento dessa lista com o objetivo de ao final gerar um único valor (de qualquer tipo), como por exemplo a soma de todos os elementos desse array.

```jsx
 function simpleArraySum(ar: number[]): number {
  const calculateNumbers = ar.reduce((total, num) => total + num, 0);

  return calculateNumbers;
}
```

Vamos entender o que está acontecendo na função acima. A função `simpleArraySum` espera receber o array `ar` como argumento, que é um array de números do tipo `number[]` (tipagem do typescript). O `:number` indica que a função retornará um número, que no caso estamos retornando a variável `calculateNumbers`, que é a soma de todos os itens do array. 

Em seguida, estamos usando o método `reduce()` com dois parâmetros: uma função de acumulador e um valor inicial.

A função callback do acumulador `(total, num) => total + num` é chamada para cada item do array. O primeiro parâmetro é o acumulador **(total)** que guarda o valor acumulado até o momento e o valor atual `(num)`, que é o item atual do array que está sendo processado. A função retorna o novo valor do acumulador, que é a soma do acumulador antigo e do valor atual.

O valor inicial **(0)** é o valor inicial do acumulador. O método `reduce()` retorna o valor final do acumulador, que é a soma de todos os itens do array.

## Compare the Triplets

O desafio Compare the Triplets, pede uma comparação dos pontos de Alice e Bob. Se os pontos de Alice forem maiores que os pontos de Bob, precisamos atribuir 1 ponto para Alice. Se os pontos de Bob forem maiores que o de Alice, também atribuímos 1 ponto para Bob. Caso os pontos sejam iguais, ambos não recebem pontos. Você pode conferir o desafio nesse [link](https://www.hackerrank.com/challenges/compare-the-triplets/problem?isFullScreen=true).

E por fim, devemos retornar os pontos de Alice na primeira posição do array e os pontos de Bob na segunda posição do array.

O desafio pede para solucionar o desafio na função `compareTriplets`. Vamos começar atribuindo os pontos de Alice e Bob a uma variável `let` com o valor inicial de zero, para que possamos incrementar os valores de acordo com a comparação que faremos a seguir:

```jsx
function compareTriplets(a: number[], b: number[]): number[] {
  let alicePoints = 0;
  let bobPoints = 0;
}

```

Em seguida, iremos usar o método `forEach()` para iterar sobre cada item do array e incrementar pontos de acordo com a comparação, retornando os pontos de Alice e Bob:

```jsx
function compareTriplets(a: number[], b: number[]): number[] {
  let alicePoints = 0;
  let bobPoints = 0;

  a.forEach((aliceNote, i) => {
    if (aliceNote > b[i]) alicePoints++;
    if (b[i] > aliceNote) bobPoints++;
  });

  return [alicePoints, bobPoints];
}

```
Vamos entender o que a função acima está fazendo. Estamos comparando dois arrays de números `a` e `b`, que representam os pontos de Alice e Bob. Estamos usando o método `forEach()` para iterar sobre cada item do array `a` e para cada item, estamos comparando o valor de `a` com o valor do array `b`, usando o índice `[i]` para definir as posições. Estamos fazendo as seguintes verificações:

- Se o valor atual no array `a` for maior que o valor do array `b`, a variável `alicePoints` é incrementada com 1 ponto.

- Se o valor atual no array `b` for maior que o valor do array `a`, a variável `bobPoints` é incrementada com 1 ponto. 

Não precisamos usar o `else`, porque de acordo com o que o desafio pede, se as notas forem iguais, não precisamos fazer nada.

Por fim, a função retorna um array com as pontuações de Alice e Bob. Com Alice na primeira posição e Bob na segunda, assim como foi definido no desafio.

## Obrigado por ler!

Espero que tenha gostado do artigo, em breve irei postar mais soluções de desafios do HackerHank.