As estruturas de decisão: se-então-senão e escolha-caso

Objetivos:
Apresentar as estruturas de decisão, que, como o próprio nome sugere, permitem aos algoritmos tomarem decisões e selecionarem os blocos de comandos a serem executados de acordo com as condições estabelecidas.
Recursos e materiais:
Última atualização:
01/06/2020
Aulas do capítulo:

Em nossas últimas aulas, aprendemos a escrever pseudocódigos utilizando as operações aritméticas e os comandos para lermos e enviarmos informações ao usuário. Porém, os algoritmos que viermos a desenvolver precisarão também tomar decisões e selecionar suas ações dependendo se determinadas condições são ou não satisfeitas. Para isso, conheceremos na aula de hoje as estruturas de decisão, também chamadas de estruturas de seleção.

Estruturas de decisão simples: se-então

A estrutura de decisão simples é a forma mais básica que temos para permitir que nossos algoritmos executem um bloco de comandos somente quando uma determinada condição for satisfeita.

Conforme podemos observar na sintaxe abaixo, a estrutura de decisão “se-então” começa sempre com um teste, indicado pelo comando “se (condição) entao”. A condição mostrada entre parênteses é implementada através das expressões aritméticas, lógicas e relacionais, as mesmas já abordadas em nossa aula sobre operadores. Para que você possa extrair o máximo das estruturas de decisão, recomendamos que acesse essa aula e aprenda sobre essas operações.

se (condição) entao
   ação 1;
   ação 2;
   ….
   ação n;
fimse;

Quando inspecionada, a condição da estrutura de seleção simples pode gerar tanto um resultado verdadeiro quanto um falso. Se o resultado for verdadeiro, o algoritmo executa todo o bloco de comandos que vier a seguir, representado pelas ações de 1 a n. Por outro lado, caso a condição retorne um valor falso, o algoritmo segue direto para o comando “fimse;”, utilizado para indicar o término do bloco de comandos da estrutura de decisão.

Para entendermos melhor a utilização dessa estrutura, vejamos o exemplo de um algoritmo para ler 3 notas de um aluno, calcular a média aritmética e, caso ela seja maior ou igual a 60, informar que ele foi aprovado.

Programa para calcular a média das notas e informar ao aluno se ele foi aprovado
1
inicio;
//Início do algoritmo
2
    real: n1, n2, n3, media;
//Declaração das variáveis
3
    escreva (“Informe as suas notas: “);
//Mensagem para o usuário
4
    leia (n1, n2, n3);
//Leitura das notas
5
    media \leftarrow (n1+n2+n3)/3;
//Cálculo da média
6
    se (media>=60) entao
//Início da estrutura de decisão
7
        escreva (“Você foi aprovado!”);
//Ação para a condição verdadeira
8
        escreva (“Parabéns!”);
//Ação para a condição verdadeira
9
        escreva (“Continue assim!”);
//Ação para a condição verdadeira
10
    fimse;
//Fim da estrutura de decisão
11
fim.
//Fim do algoritmo

Nesse algoritmo, as notas informadas pelo usuário são atribuídas às variáveis n1, n2 e n3. Em seguida, a média é calculada e o resultado da operação armazenado na variável media. Se a condição testada na linha 6 for verdadeira, o programa imprime as mensagens nas linhas 7, 8 e 9. Por outro lado, se a condição for falsa, o algoritmo segue direto para a linha 10.

Podemos notar também que indentamos (deslocamos para a direita) o bloco de comandos dentro da estrutura de decisão. Essa é uma boa prática para que possamos identificar com mais facilidade o conteúdo dessas estruturas, principalmente quando nossos algoritmos aumentarem em tamanho e em complexidade.

Estruturas de decisão composta: se-então-senão

No exemplo do Algoritmo 1, apresentamos na tela do computador mensagens parabenizando o usuário caso ele tenha sido aprovado. Porém, como faríamos se desejássemos apresentar também outras mensagens caso o aluno obtivesse média menor que 60 e tivesse sido reprovado? Quando duas alternativas dependem da mesma condição, uma no caso de ela ser verdadeira e a outra no caso de ela ser falsa, podemos utilizar a estrutura de decisão composta “se-então-senão”.

Conforme podemos observar na sintaxe ilustrada abaixo, essa estrutura de decisão é muito parecida com a estrutura de seleção simples. A única diferença entre elas é a adição do comando “senao” e o bloco de comandos para o caso da condição testada na primeira linha retornar um valor falso. Assim, se o resultado da condição for verdadeiro, o bloco de comandos 1 é executado. Caso contrário, o bloco de comandos 2 é que é considerado pelo algoritmo.

se (condição) entao
   bloco de comandos 1;
senao
   bloco de comandos 2;
fimse;

Vejamos como ficaria o mesmo algoritmo para calcular a média aritmética de 3 notas, dessa vez apresentando para o aluno mensagens tanto nos casos de aprovação quanto de reprovação.

Programa para calcular a média das notas e informar ao aluno se ele foi aprovado ou reprovado
1
inicio;
//Início do algoritmo
2
    real: n1, n2, n3, media;
//Declaração das variáveis
3
    escreva (“Informe as suas notas: “);
//Mensagem para o usuário
4
    leia (n1, n2, n3);
//Leitura das notas
5
    media \leftarrow (n1+n2+n3)/3;
//Cálculo da média
6
    se (media>=60) entao
//Início da estrutura de seleção
7
        escreva (“Você foi aprovado!”);
//Ação para condição verdadeira
8
        escreva (“Parabéns!”);
//Ação para condição verdadeira
9
    senao
//Fim das ações p/ condição verdadeira
10
        escreva (“Você foi reprovado!”);
//Ação para condição falsa
11
        escreva (“Estude mais!”);
//Ação para condição falsa
12
    fimse;
//Fim da estrutura de seleção
13
fim.
//Fim do algoritmo

Simulando um suposto caso em que um aluno consegue notas de 10, 20 e 30 nessas três provas, o algoritmo seria executado conforme ilustrado na Tabela 1 a seguir. Se prestarmos atenção, a condição testada na linha 6 retorna um valor falso e, por isso, o algoritmo segue direto para a linha 10.

Simulando a execução do algoritmo para cálculo da idade em dias de um usuário
Linha n1 n2 n3 media media>=60? Tela
1 Início do algoritmo
2
3 Informe suas notas:
4 10 20 30 Informe a sua idade em anos: 10<ENTER>
20<ENTER>
30<ENTER>
5 10 20 30 20 Informe a sua idade em anos: 10
20
30
6 10 20 30 20 Falso Informe a sua idade em anos: 10
20
30
10 10 20 30 20 Falso Informe a sua idade em anos: 10
20
30
Você foi reprovado!
11 10 20 30 20 Falso Informe a sua idade em anos: 10
20
30
Você foi reprovado!
Estude mais
13 Fim do algoritmo

Já para o caso de o usuário tirar notas iguais a 60, 40 e 80, a execução do algoritmo e a evolução das variáveis aconteceria de acordo com a Tabela 2 abaixo. Dessa vez, o teste realizado na linha 6 retorna verdadeiro, fazendo com que as linhas 7 e 8 sejam executadas e com que as linhas 9, 10 e 11 sejam ignoradas.

Simulando a execução do algoritmo para cálculo da idade em dias de um usuário
Linha n1 n2 n3 media media>=60? Tela
1 Início do algoritmo
2
3 Informe suas notas:
4 60 40 80 Informe a sua idade em anos: 60<ENTER>
40<ENTER>
80<ENTER>
5 60 40 80 60 Informe a sua idade em anos: 60
40
80
6 60 40 80 60 Verdadeiro Informe a sua idade em anos: 60
40
80
7 60 40 80 60 Verdadeiro Informe a sua idade em anos: 60
40
80
Você foi aprovado!
8 60 40 80 60 Verdadeiro Informe a sua idade em anos: 60
40
80
Você foi aprovado!
Parabéns!
13 Fim do algoritmo

Combinando estruturas de decisão simples e compostas

As estruturas de decisão simples e compostas podem ainda ser combinadas e utilizadas uma dentro da outra para que nossos algoritmos possam selecionar suas ações com base em quantas condições forem necessárias.

De forma a entendermos como isso é possível, vejamos o exemplo de um algoritmo criado para ler três números e verificar se eles podem ou não ser o comprimento dos lados de um triângulo. Para isso, cada lado precisa ser menor que a soma dos comprimentos dos outros dois lados. Em caso dessa condição ser atendida, o algoritmo verifica ainda se as dimensões fornecidas pelo usuário compõem um triângulo equilátero (três lados iguais), isósceles (dois lados iguais) ou escaleno (três lados diferentes).

Programa para ler três números e informar se eles corresondem a um triângulo equilátero, isósceles, escaleno ou se não formam um triângulo
1
inicio;
//Início do algoritmo
2
    real: a, b, c;
//Declaração das variáveis
3
    escreva (“Informe os três números: “);
//Mensagem para o usuário
4
    leia (a, b, c);
//Leitura das dimensões
5
    se ((a<b+c) e (b<a+c) e(c<a+b)) entao
//Testa se é um triângulo
6
        se ((a=b) e (a=c)) entao
//Testa se é equilátero
7
            escreva (“Triângulo equilátero”);
8
        senao
//Não atende à linha 6
9
            se ((a=b) ou (a=c) ou (c=b)) entao
//Testa se é isósceles
10
                escreva (“Triângulo isósceles”);
11
            senao
//Não atende à linha 9
12
                escreva (“Triângulo escaleno”);
13
            fimse;
//Fim do “se” da linha 9
14
        fimse;
//Fim do “se” da linha 6
15
    senao
//Não atende à linha 5
16
        escreva (“Valores não formam triângulo”);
//Não atende à linha 9
17
    fimse;
//Fim do “se” da linha 5
18
fim.
//Fim do algoritmo

Nesse exemplo, podemos observar que três estruturas de decisão composta são utilizadas, a primeira delas iniciada na linha 5 e finalizada na linha 17, a segunda começando na linha 6 e terminando na linha 14 e, a mais interna delas, entre as linhas 9 e 13.

Vale notarmos também como a indentação do conteúdo facilita a localização dos limites de cada uma dessas estruturas de seleção, melhorando a compreensão do algoritmo. Os comandos “se”, “senao” e “fimse” sempre ficam alinhados verticalmente para uma mesma estrutura de decisão. Tudo o que estiver mais à direita pertencerá ao bloco de comandos que será executado dependendo se o teste lógico for verdadeiro ou falso.

Fica como desafio para você leitor simular esse algoritmo. Teste diferentes valores para as variáveis a, b e c e veja como o pseudocódigo acima se comporta para cada uma delas.

Estruturas de múltipla escolha: escolha-caso

Quando uma determinada variável puder assumir inúmeros valores e precisarmos implementar blocos de comandos específicos para cada um deles, a estrutura de seleção composta começa a se tornar inviável. Nesse caso, podemos utilizar a estrutura de decisão “escolha-caso”, cuja sintaxe é mostrada a seguir.

escolha (variável)
   caso v1:
      bloco de comandos 1;
   caso v2:
      bloco de comandos 2;
   …
   caso vn:
      bloco de comandos n;
   caso contrário:
      bloco de comandos padrão;
fimescolha;

A estrutura de decisão de múltipla escolha é iniciada pela linha “escolha (variável)” e finalizada na linha “fimescolha;”. Para cada valor a ser testado, utiliza-se o comando “caso valor:”, seguido pelas ações desejadas caso o teste seja verdadeiro. Uma condição opcional (“caso contrário”) pode ser ou não adicionada ao final dessa estrutura, sendo que o bloco de comandos correspondente à essa opção será executado somente quando o valor da variável não atender à nenhuma das condições anteriores.

Nessa estrutura de decisão, o conteúdo da variável é comparado à um valor v1 qualquer e, se forem iguais, o bloco de ações 1 é executado. No caso de serem diferentes, as outras condições serão testadas, até que seja encontrada uma igualdade ou que terminem todos os casos possíveis.

O exemplo abaixo nos ajuda a entender a estrutura de seleção composta, apresentando um algoritmo para ler o sabor de pizza que o cliente deseja e imprimir uma mensagem informando que ela está sendo preparada.

Problema para ler o sabor da pizza e informar ao cliente que ela está sendo preparada
1
inicio;
//Início do algoritmo
2
    caracter: tipo;
//Declara variáveis
3
    escreva (“Selecione muzzarela (M), quatro queijos (Q) ou presunto (P): “);
//Mensagem p/ o usuário
4
    leia (tipo);
//Leitura do sabor
5
    escolha (tipo)
//Inicia estrutura
6
    caso “M”:
//Caso tipo = “M”
7
        escreva (“Pizza de muzzarela em preparo!”);
8
        escreva (“Aguarde…”);
9
    caso “Q”:
//Caso tipo = “Q”
10
        escreva (“Pizza de 4 queijos em preparo!”);:
11
        escreva (“Aguarde…”);
12
    caso “P”:
//Caso tipo = “P”
13
        escreva (“Pizza de presunto em preparo!”);
14
        escreva (“Aguarde…”);
15
    caso contrario:
//Caso contrário
16
        escreva (“Opção não disponível!”);
17
    fim escolha;
//Fim da estrutura
18
fim.
//Fim do algoritmo

Caso tenha ficado alguma dúvida, deixe o seu comentário abaixo para que possamos lhe ajudar. Na próxima aula, realizaremos exercícios para praticarmos essas estruturas de seleção e dominarmos o assunto. Caso você queira aprender muito mais sobre programação e outros assuntos ligados à engenharia, conhecer outras pessoas que também se interessam pela área e trocar experiências com elas, acesse agora esse link e faça parte da nossa comunidade. Estamos empolgados para ter você com a gente!

Referências bibliográficas

A. A. T. Maia, “Fundamentos da Computação – Algoritmos – Programação em Linguagem C”. Universidade Federal de Minas Gerais, 2013.

Deixe um comentário

%d blogueiros gostam disto: