Zerando o Hacker Rank: Fazendo a escadinha com TypeScript
Tags: tutorial, javascript, typescript, braziliandevs
Published: 2023-02-22 17:53:57

No tutorial de hoje, vou ajudá-lo a entender como resolver mais um dos desafios que você encontrará no HackerRank, usando a linguagem TypeScript.

## Starircase Detail

O desafio **"Starircase detail"** propôe que sejam impressas linhas contendo símbolos `#` e espaços em branco, de forma a criar uma escada de tamanho `n`. A escada deve ter base e altura iguais a `n`, e a última linha não deve ter espaços em branco antes dos símbolos `#`. 

O objetivo do desafio é implementar uma função que imprima a escada de acordo com essas especificações. Você pode conferir o desafio através desse [link](https://www.hackerrank.com/challenges/staircase/problem?isFullScreen=true). 

Vamos visualizar um exemplo de como o desafio espera a entrada e a saída:

Entrada:

```jsx
6
```

Saída:

```jsx
     #
    ##
   ###
  ####
 #####
######

```

## Solução proposta

Para solucionar o desafio, você devemos preencher a função `staircase`, que recebe um número inteiro `n` como parâmetro e não tem renorno (void). Iremos utilizar dois loops `for` na função, para iterar sobre as linhas da escada e os caracteres a serem impressos em cada linha. O código da função é o seguinte: 

```jsx
function staircase(n: number): void {
  for (let i = 1; i <= n; i++) {
    console.log("".repeat(n - i) + "#".repeat(i));
  }
}

```

O primeiro loop `for` é responsável por interar sobre as linhas da escada. Ele começa em 1 e vai até `n`, uma vez que a escada deve ter `n` linhas. A variável `i` representa o número da linha atual.

Dentro do primeiro loop `for`, a string a ser impressa é criada usando o método `repeat()` de strings do JavaScript. Esse métrodo recebe um número inteiro e retorna uma nova string contendo a string original, repetindo o número de vezes especificado. 

No caso da escada, são necessários dois tipos de strings: uma contendo espaços em branco e outra contendo símbolos `#`. Para criar essas strings, são utilizados os seguintes trechos de código:

```jsx
' '.repeat(n - i)
```

Esse trecho cria uma string contendo `n - i` espaços em branco. O método `repeat()` é utilizado para repetir o caractere espaço o número de vezes necessário.

```jsx
'#'.repeat(i)
```

Esse trecho cria uma string contendo `i` símbolos `#`. O método `repeat()` é utilizado para repetir o caractere `#` o número de vezes necessário.

Essas duas strings são concatenadas utilizando o operador `+`, e o resultado é impresso na tela utilizando a função `console.log()`. O resultado final é uma linha da escada contendo os caracteres `#` e espaços em branco, como especificado no desafio. 

## Testando solução

Para testar a solução, você pode executar na própria plataforma do HackerRank. Mas caso queira testar em seu editor, você deverá chamar a função `staircase` passando um valor de `n` como parâmetro. 

Por exemplo, para criar uma escada de tamanho 6, basta chamar a função da seguinte forma:

```jsx
const n = 6;
staircase(n);
```

Pronto! Agora você verá a seguinte escada impressa:

```jsx
     #
    ##
   ###
  ####
 #####
######

```

## Conclusão

Em resumo, a solução apresentada é bastante simples e eficiente para o problema proposto. Utilizando um loop `for` para iterar de 1 até o valor de `n` e o método `repeat()` para imprimir os caracteres desejados, é possível construir uma escada de forma rápida e sem a necessidade de criar uma grande quantidade de variáveis e condições.

Através dessa solução, foi possível abordar alguns conceitos importantes da linguagem TypeScript, como o uso de variáveis e tipos de dados, o uso de loops e a utilização de funções. Além disso, também foi possível explorar algumas funcionalidades nativas do JavaScript, como a função `repeat()`.

Por fim, é importante lembrar que existem diversas formas de resolver um problema em programação e a solução apresentada aqui é apenas uma das muitas possibilidades. Cada programador pode ter uma abordagem diferente para resolver um mesmo problema e, muitas vezes, a solução mais adequada irá depender das particularidades de cada situação. O importante é sempre buscar a melhor solução possível para cada desafio, levando em conta fatores como eficiência, legibilidade e manutenibilidade do código.