CS50: S1 | E o problema do Mario

É 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 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:

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

       #
      ##
     ###
    ####
   #####
  ######
 #######
########

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

#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.

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.