CS50: S1 | E o problema do Mario
Tags: braziliandevs
Published: 2022-04-27 14:18:57

É interessante como um material tão enriquecedor esteja disponivel para estudo, e acompanhamento. Tenho tido bastante alegria em começar a acompanhar o CS50 de forma semanal - como é o esperado - já que cada unidade é tratado por semanas. Dessa forma, eu acredito que evito as chances de ter um **burnout** e consigo, por ventura, solidificar o aprendizado em diversos assuntos.

## Problems Set 1

No [post anterior](https://dev.to/mpfdev/cs50-semana-1-1ib3) apresentei sobre o que foi a semana 1 do curso de Introdução a Ciência da Computação (CS50) ministrado em Harvard. Ao terminar a primeira aula, somos levados para a primeira lista que podemos chamar de dever de casa, onde são dados duas opções:

- Uma versão simples
- Uma versão complexa

O que não muda e nem impede a sua capacidade de ser um programador. Tendo, é claro, que respeitar a sua jornada. Se, você preferiu fazer só as versões mais simples, meus parabéns! 
Você resolveu problemas, e encontrou soluções!

O que se espera na resolução desses problemas, é:

- Assistir a aula correspondente a semana 1: C
- Se familiarizar com a IDE do CS50 na nuvem
- Entender sobre como utilizar os comandos linux no terminal
- Ficar confortável com os blocos fundamentais da programação: condicionais, loops, operadores, e tipos de dados.
- Entender a função prototipo na linguagem C

Com a resolução, seja do exercicio em sua versão simples, ou em sua versão complexa, te dará familiariadade com todos esses temas. E caso, não tenha conseguido resolver, não desista! Peça ajuda! A comunidade brasileira de desenvolvedores é muito receptiva, e mesmo que não tenham feito esse problema em especifico, eles te ajudarão a dar um norte para melhorar o seu algoritmo.

## Mario: Simples

Quero mostrar o começo dos exercicios nas próximas semanas que virão, então darei ênfase, na escrita, para suas versões mais simples.

A ideia aqui é gerar apenas um lado da pirâmide. Replicando as escadas geradas no mapa 1-1 do Super Mario para SNES. Como podemos ver na imagem abaixo:

![https://cs50.harvard.edu/x/2022/psets/1/mario/less/pyramid.png](https://cs50.harvard.edu/x/2022/psets/1/mario/less/pyramid.png)

Tirando a parte gráfica, o céu azul e o cano verde, a expectativa em nosso terminal é algo como:

```bash
       #
      ##
     ###
    ####
   #####
  ######
 #######
########
``` 

E a sua altura se dará por um número dado pelo usuário que informará quanto será.

Neste primeiro momento, como o programa terá que produzir atividades repetitivas, podemos pensar em um **laço de repetição** que é um dos blocos fundamentais da linguagem de programação.

Partindo do príncipio que o triangulo acima tenha altura igual a 8.

Vemos uma sequência de etapas, sendo produzida como:

- Primeira linha: 7 espaços vazios e 1 bloco preenchido
- Segunda linha: 6 espaços vazios e 2 blocos preenchidos
- Terceira linha: 5 espaços vazios e 3 blocos preenchidos
- ...
- Oitava linha: 0 blocos vazios e 8 blocos preenchidos

Conseguimos ver um **padrão repetitivo**.

Antes de escrever qualquer código, precisamos observar o ambiente para pensar nessa sequência de etapas que está sendo executada. Tanto faz a linguagem de programação, seja C, Python, JavaScript, o que for.

Linguagens de programação são apenas ferramentas para te auxiliar na construção de um algoritmo, por isso, aprender bem os blocos fundamentais tornam o seu aprendizado horizontal, caso você precise mudar de ferramenta, o seu conhecimento continua sendo válido, só mudando a sua sintaxe, e as particularidades de cada linguagem.

Desta maneira, voltarei a resolução do exercicio. E aqui, **deixo claro**, não existe solução única, nem o jeito certo de fazer o problema. Toda solução pode ser otimizada, mas a solução é aquela que você consegue resolver o problema.

### Resolução

```c
#include <cs50.h>
#include <stdio.h>

int get_height();

int main(void)
{
    int height = get_height();
    while(height < 1 || height > 8) {
        height = get_height();
    }

    int counter = 1;
    while (counter <= height) {
        int spaces = height - counter;
        for(int i = 0; i < spaces; i++) {
            printf(" ");
        }
        for(int i = 0; i < counter; i++) {
            printf("#");
        }
        printf("\n");
        counter++;
    }
}

int get_height() {
    return get_int("Height: ");
}
```

Valendo-se do conceito de prototipo introduzido na primeira aula, crio uma função `get_height()` que pedirá ao usuário para informar a altura que o triângulo deve ter.

Ali são as **condições de contorno** estipuladas pelo próprio exercicio, onde caso a altura seja um número que não esteja dentro do intervalo, a função será chamada novamente até atender o que se pede.

E depois, entra no **laço de repetição** onde encontrei um padrão de repetição lá em cima.

Vamos partir do principio aqui que o usuário informou que a altura é igual a 8.

```c
int counter = 1;
    while (counter <= height) {
        int spaces = height - counter;
        for(int i = 0; i < spaces; i++) {
            printf(" ");
        }
        for(int i = 0; i < counter; i++) {
            printf("#");
        }
        printf("\n");
        counter++;
    }
```
- Primeira linha

counter = 1;
height = 8; 
spaces = 8 - 1 = 7; 

Na primeira linha serão gerados **7 espaços e 1 bloco construido**

- Segunda linha

counter = 2;
height = 8;
spaces = 8 - 2 = 6;

Na segunda linha serão gerados **6 espaços e 2 blocos construidos**

- Terceira linha

counter = 3;
height = 8;
spaces = 8 - 3 = 5;

Na terceira linha serão gerados **5 espaços e 3 blocos construidos**

### Conclusão

Desta maneira conseguimos repetir por meio de uma **ferramenta** o mesmo padrão do problema suposto, e assim replicar o triângulo gerado para todos os casos dentro da **condição de contorno** estabelecido pelo Problem Set da aula.

Em um próximo post, falarei sobre o outro exercicio simples, onde trabalharemos com **tipos de dados** e **operadores**.