Resolvendo problemas no HackerRank: Entre notas e velinhas.
Tags: javascript, programming
Published: 2023-01-27 12:50:45

Com foco em melhorar ainda mais o rendimento e aprendizado em uma linguagem, também exercendo a lógica da programação, nessa nova série de resoluções irei demonstrar como resolvi certos conflitos de lógica: alguns simples, outros que necessitam de mais esforço.



**Compare the Triples**

Nesse primeiro exercício, os personagens Ana e Bob criaram um array de números. Nosso objetivo é simple: fazer uma análise dos parâmetros que estão guardados na função comapareTriples(a,b), que representam os dois personagens nessa exata ordem e caso Ana tenha um ponto maior no array respectivo ao do Bob, ela recebe ponto. O raciocínio é feito também para o Bob, e caso os dois tenham resultados iguais, ninguém recebe.  Veja mais a seguir ->

_"The task is to find their comparison points by comparing a[0] with b[0], a[1] with b[1], and a[2] with b[2].

If a[i] > b[i], then Alice is awarded 1 point.
If a[i] < b[i], then Bob is awarded 1 point.
If a[i] = b[i], then neither person receives a point."_


O desafio nos dá um exemplo de como deseja que sigamos o raciocínio:

```
[5 6 7] //sendo Alice
[3 6 10] // sendo Bob
/*Apenas para viés de informação dos que estão iniciando programação também: cada primeiro parâmetro de array, quando colocado em posições, representa o valor 0, não 1. 
Exe: [5 6 7], representaria 0[5], 1[6] e 2[7]*/
```


É possível resolver esse desafio de muitas formas. A forma que fiz foi a seguinte:


```
function compareTriples(a,b){

return a.reduce((acum,cur,i) => {
    let alicePoints = cur
    let bobPoints = b[i]
      if(alicePoints > bobPoints) acum[0]++
      else if(bobPoints > alicePoints) acum[1]++
  return (acum)
  },[0,0])
}
```

(Nesse caso acima feito por mim, baseado em uma resolução alternativa.)

A função compara cada elemento correspondente dos dois arrays e retorna um array com duas contagens. No primeiro caso é contado o número de vezes que `a` foi maior que `b`, assim como vice-versa. 

A função "reduce" recebe como primeiro argumento uma função de callback, que é chamada para cada elemento do array, e um valor inicial, que é [0,0] no nosso caso. Dentro da função de callback, as variáveis "aliceNote" e "bobNote" armazenam os valores dos elementos correspondentes deles.



**birthdayCakeCandles**

Já nesse caso, existem 4 velas em um bolo de aniversário. Nosso objetivo é contar quais as velas mais altas.

Abaixo o exemplo que ele nos dá para segur:

```
4 // representa o número de velas que tem, nada mais.
3 2 1 3 //existem duas velas com tamanho 3, nosso objetivo é agarrar essas duas velas.


//ele espera o resultado 2, baseado no número de elementos mais altos
```

É possível resolver esse desafio de muitas formas. A forma que fiz foi a seguinte:

```
function birthdayCakeCandles(candles) {
    let candleTall = Math.max(...candles);
    let result = candles.filter(vela => vela === candlTall).length
    
    return result
}
```

No caso acima, declaramos uma variável candleTall que serve para retirar as velas mais altas. Essa variável recebe o objeto Math.max que irá pegar os maiores valores da variável, mas queremos que ele pegue os números da lista `candles` que estão dentro do bCC, portanto desestruturamos o que está dentro do `candles`.

Logo após isso criamos uma variável `result` que irá pegar todo o procedimento e retornar o desejado. Esta recebe a lista candles.filtes, que irá ser o um parâmetro vela, e irá receber candle IGUAL a variável candleTall,se livrando dos outros valores da função declarada e pegando só os mais altos. O `.length` se refere a transormar a lista que tem dois elementos [3,3] em 2.

Depois retornamos o result e vemos ele fazer o processo.


Obrigado por ler e até a próxima.