DEV Community

Cover image for Zerando HackerRank: Simple Array Sum e Compare the Triplets
Ivan Trindade
Ivan Trindade

Posted on • Updated on

Zerando HackerRank: Simple Array Sum e Compare the Triplets

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.

Ele espera receber esse valor como entrada:

6
1 2 3 4 10 11
Enter fullscreen mode Exit fullscreen mode

E a soma dos valores como saída:

31
Enter fullscreen mode Exit fullscreen mode

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.

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

  return calculateNumbers;
}
Enter fullscreen mode Exit fullscreen mode

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.

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:

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

Enter fullscreen mode Exit fullscreen mode

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:

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];
}

Enter fullscreen mode Exit fullscreen mode

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.

Oldest comments (0)