03 - Estruturas de Seleção

Prévia do material em texto

Estruturas de Seleção 
 
3.1 Comando Se 
 
Freqüentemente na construção de algoritmos vamos nos defrontar com problemas, onde é necessário 
selecionar uma, entre duas ou mais situações possíveis. Suponha, por exemplo, um algoritmo em que se 
necessite mostrar o conteúdo de uma variável do tipo Inteiro, somente se seu conteúdo for maior que 
10. Considerando uma variável de nome Nota, poderíamos escrever: 
 
Se Nota > 10 Então 
Escreva Nota 
Fim Se 
 
Consideramos que, quando for executado o comando Se, caso o conteúdo da variável Nota seja maior 
que dez, então será executado o comando Escreva Nota. Caso o conteúdo de Nota não seja maior 
que dez, então não será executado o comando Escreva Nota. 
 
Suponha outro algoritmo que mostre, para dois valores inteiros, qual o maior deles (algoritmo 
Maximo_1). 
 
Algoritmo Maximo_1 
 
Variáveis 
 
Valor_a, Valor_b : Inteiro 
 
Inicio 
Leia Valor_a, Valor_b 
Se Valor_a > Valor_b Então 
Escreva `Maior Valor: ', Valor_a (1) 
Senão 
Escreva `Maior Valor: ', Valor_b (2) 
Fim Se 
Fim 
 
O algoritmo Maximo_1 solicita inicialmente a entrada de dois valores, os quais são armazenados nas 
variáveis Valor_a e Valor_b. Ao ser executado o comando Se, é calculado o valor da expressão lógica 
Valor a > Valor b. Se o conteúdo da variável Valor_a for maior que o conteúdo da variável Valor 
b, ou seja, se a expressão Valor_a > Valor_b tiver o valor verdadeiro, então será executado o 
comando (1) e, após, o fluxo de execução do algoritmo passará para o primeiro comando após o Fim 
Se. Caso o conteúdo de Valor a não seja maior que Valor_b, isto é, caso o valor da expressão lógica 
Valor_a > Valor_b seja falso, então será executado o comando (2) e após, o fluxo de execução 
passará para o primeiro comando após o Fim Se. Veja que, caso os dois valores sejam iguais, então a 
expressão lógica tem o valor falso e será executado o comando (2), o qual informará o maior valor como 
sendo o conteúdo de Valor_b. Isto não corresponde a realidade. Assim, esse algoritmo só funciona se 
os dois valores forem diferentes. Discutiremos esse problema novamente mais adiante. 
 
Pelos exemplos apresentados, concluímos que o comando Se tem por função fazer com que seja 
selecionada uma, entre duas situações possíveis, e pode ser apresentado sob as seguintes formas: 
 
a) Comando Se sem a cláusula Senão 
 
Se expressão lógica Então 
Comando 1 
Comando 2 
... 
Comando N 
Fim Se 
 
Nessa forma de comando Se, os comandos Comando 1, Comando 2, ... , Comando N serão 
executados somente se a expressão lógica tiver o valor verdadeiro. Assim, quando o fluxo de execução 
chegar no comando Se, será calculado o valor de expressão lógica e caso seja verdadeiro serão 
executados os comandos Comando 1, Comando 2, ..., Comando N. Após a execução desses 
comandos, o fluxo segue para a execução do primeiro comando após o Fim Se. Se a expressão lógica 
tiver o valor falso, então o fluxo segue diretamente para o primeiro comando após o Fim Se sem 
executar nenhum dos comandos colocados internamente ao Se. Veja que dentro de um comando Se 
podemos colocar qualquer comando, inclusive outro comando Se. 
 
b) Comando Se com a cláusula Senão 
 
Se expressão lógica Então 
Comando 1 
Comando 2 
Senão 
Comando a 
Comando b 
 Fim Se 
 
Em um comando Se com a cláusula Senão, quando o fluxo de execução chegar no Se, será avaliada a 
expressão lógica. Caso a expressão lógica tenha o valor verdadeiro, então serão executados os 
comandos colocados entre o Se e a cláusula Senão (Comando 1, Comando 2, ...) e após o fluxo de 
execução segue para o primeiro comando após o Fim Se. Se, ao avaliar a expressão lógica, esta tiver o 
valor falso, então serão executados os comandos colocados entre a cláusula Senão e o Fim Se 
(Comando a, Comando b,...) e após o fluxo de execução segue para o primeiro comando após o 
Fim Se. 
 
3.2 Ninhos de Comandos Se 
 
Dentro de um comando de seleção (comando Se), podemos colocar qualquer tipo de comando. Assim, 
dentro de um Se, pode-se ter outros comandos de seleção. No algoritmo Maximo_1, que determina o 
maior entre dois valores, vimos que, se os dois números são iguais, o algoritmo informará como 
resposta que Valor _b é o maior valor, o que obviamente não é verdade. Assim, esse algoritmo não 
está correto. 
 
Note que, na determinação do maior valor entre dois valores, temos três situações possíveis: Valor_a 
maior que Valor_b, Valor_a menor que Valor_b e os dois valores iguais. Com um único Se conse-
guimos avaliar apenas duas situações. Para levar em conta as três situações, outro comando de seleção 
faz-se necessário. A solução para esse problema é apresentada pelo algoritmo Maximo_2. 
 
Algoritmo Maximo_2 
 
Variáveis 
Valor_a, Valor_b : Inteiro 
 
Inicio 
Leia Valor a, Valor_b 
 
Se Valor_a > Valor_b Então 
Escreva `Maior Valor: ', Valor_a 
Senão 
uSe Valor_a < Valor_b Então 
 Escreva `Maior Valor: ', Valor_b 
 Senão 
Escreva 'Os dois são iguais. ' 
 Fim Se 
Fim Se 
Fim 
 
Note que, nessa nova versão, caso o valor da expressão Valor_a > Valor_b seja falso, o fluxo de 
execução irá executar o que estiver dentro do Senão do primeiro Se. Dentro do Senão do primeiro Se, 
outro Se é executado, sendo então verificado se o conteúdo de Valor_a é menor que o conteúdo de 
Valor_b. Caso Valor_a seja menor que Valor _b, o algoritmo identificará Valor_b como sendo o 
maior valor. Veja que, o comando de seleção que está colocado dentro do Senão do primeiro Se, só 
será executado se, ao executar o primeiro Se, a expressão Valor_a > Valor_b for falsa. Se Valor_a 
> Valor _b tiver o valor falso, então conclui-se que Valor_a não é o maior valor. Logo, se a 
expressão Valor_a < Valor_b também for falsa, então também Valor_b não poderá ser o maior 
valor, o que permite concluir que os dois valores são iguais. 
 
Observe que os comandos colocados entre o Se e a cláusula Senão foram deslocados em relação à 
coluna (linha vertical) relativa ao Se. Também os comandos colocados entre a cláusula Senão e o Fim 
Se foram deslocados em relação ao Senão e Fim Se. Esse processo denomina-se identação e tem por 
objetivo facilitar a visualização de que conjunto de comandos será executado quando o comando Se for 
executado. 
 
Considere agora a construção de um algoritmo que, dada a idade de uma pessoa, informe se esta é 
criança, adolescente ou adulto. Considerar as faixas etárias conforme a seguir. 
 
Idade até 12 anos : Criança 
Idade maior que 12 e menor que 18 anos : Adolescente 
Idade maior ou igual a 18 anos : Adulta 
 
Fazendo uma análise desse problema, podemos concluir que, para a sua resolução, deve-se conhecer a 
idade da pessoa, a qual constitui-se em uma entrada do problema. A solução do problema consiste em 
mostrar-se uma mensagem dizendo se a pessoa é criança, adolescente ou adulta. Essa mensagem 
constitui-se na saída do problema. O algoritmo deve então solicitar do usuário o valor da idade da 
pessoa e executar os testes necessários para identificar se é criança, adolescente ou adulta. A solução é 
apresentada pelo algoritmo Faixa Etaria. 
 
Algoritmo Faixa_Etaria 
 
Variáveis 
Idade : Inteiro 
 
Inicio 
Escreva `Entre com valor da idade :' 
 Leia Idade 
 
 Se Idade <= 12 Então 
 Escreva `Criança' 
Senão 
 Se Idade < 18 Então 
Escreva `Adolescente' 
Senão 
Escreva `Adulto' 
Fim Se 
Fim Se 
Fim 
 
3.3 Comando Escolha 
 
Suponha que o conceito de um aluno seja determinado em função de sua nota. Suponha também que 
essa nota seja um valor inteiro na faixa de 0 a 100. O comando Se permite a escolha de uma alternativa 
entre duas possíveis, o comando Escolha possibilita a escolha de uma alternativa entre as várias 
possíveis. 
 Nota Conceito0 a 49 Insuficiente 
 50 a 64 Regular 
 65 a 84 Bom 
 85 a 100 Ótimo 
 
O algoritmo Conceito_1, através da utilização de comando Se aninhados, apresenta a solução do 
problema. 
 
Algoritmo Conceito_1 
 
Variáveis 
 Nota : Inteiro 
 Conceito : Literal 
 
Início 
 Leia Nota 
 Se Nota <= 49 
 Conceito  Insuficiente 
 Senão 
 Se Nota <= 64 Então 
 Conceito  Regular 
 Senão 
 Se Nota <= 84 
 Conceito  Bom 
 Senão 
 Conceito  Ótimo 
 Fim Se 
 Fim Se 
 Fim Se 
 
 Escreva ‘Conceito do aluno: ‘, Conceito 
Fim 
 
No algoritmo Conceito_1, vários testes são feitos sobre o conteúdo da variável Nota. Em vez de 
escrevemos os vários testes utilizando vários comando Se aninhados, e considerando que todos os 
testes são realizados sobre a mesma expressão, podemos utilizar um comando alternativo que tem essa 
função. O comando Escolha pode ser usado sempre que for necessária a realização de várias seleções 
tendo-se por base a mesma expressão. Usando o comando Escolha, o problema da determinação do 
conceito de um aluno pode ser resolvido conforme apresentado no algoritmo Conceito_2. Observe 
que, enquanto o comando Se permite a escolha de uma alternativa entre duas possíveis, o comando 
Escolha possibilita a escolha de uma alternativa entre as várias possíveis. 
 
Algoritmo Conceito_2 
 
Variáveis 
 Nota : Inteiro 
Conceito : Literal 
 
Inicio 
Leia Nota 
 
Escolha Nota 
0..49 : Conceito  `Insuficiente' 
50..64 : Conceito  `Regular' 
65..84 : Conceito  'Bom' 
Senão 
Conceito  'Otimo' 
Fim Escolha 
Fim 
 
Estamos assumindo que, ao executar o comando Escolha no algoritmo Conceito_2, será avaliada 
cada uma das opções de valores para Nota. Veja que a opção 65..84, por exemplo, significa valores 
que vão desde 65 até 84. Assim, se o valor de Nota estiver nessa faixa, essa opção será satisfeita. As 
opções serão sempre avaliadas na ordem em que aparecem, e será executada a instrução relativa à 
primeira opção que satisfazer o valor de Nota. Caso nenhuma das opções satisfaça o valor da 
expressão do Escolha, então serão executadas as instruções colocadas no Senão. 
 
A forma geral do Escolha pode ser colocada como: 
 
Escolha Expressão 
Opl : Instruções relativas a Opl 
Op2 : Instruções relativas a Op2 
 ... 
 Opn : Instruções relativas a Opn 
Senão 
Instruções 
Fim Escolha 
 
onde Expressão consiste em uma expressão cujo valor será usado para definir quais instruções serão 
executadas. Veja que as opções de valores (Op1 a Opn ) serão avaliadas na ordem em que aparecem, 
e que, caso nenhuma das opções satisfaça o valor de Expressão, então serão executadas as instruções 
colocadas no Senão. Vamos assumir também que as opções apresentadas no comando Escolha 
devem ser valores do mesmo tipo de Expressão. Cada opção pode ser expressa na forma de faixa, 
conforme aparece no algoritmo Conceito_2, ou na forma de uma lista de um ou mais valores 
separados por vírgula, ou ainda, uma combinação de ambas as formas. 
 
Outro exemplo de uso do comando Escolha aparece no algoritmo Operacoes, que toma como 
entrada qual a operação a ser feita, bem como os dois operandos, e efetua a operação solicitada. 
 
Algoritmo Operacoes 
 
Variáveis 
Opl, Op2, Resultado : Real 
Operacao : Caractere 
Op_valida : Lógico 
 
Inicio 
Escreva 'Entre com o primeiro operando: ' 
Leia Op_1 
Escreva 'Entre com o segundo operando: ' Leia_Op2 
Op_valida  verdadeiro 
Escreva `Escolha uma das seguintes opções: ' 
Escreva '+ ( para somar os dois operandos)' 
Escreva '- ( para subtrair o segundo operando do primeiro)' 
Escreva '* ( para multiplicar os dois operandos)' 
Escreva para dividir o primeiro operando pelo segundo)' 
Leia Operacao 
 
Escolha Operacao 
'+': Resultado  Op_1 + Op_2 
'-': Resultado  Op_l – Op_2 
'*': Resultado  Opl * Op2 
'/': Resultado  Opl / 0p2 
Senão 
Escreva 'Operação inválida...' 
Op_Valida  falso 
Fim Escolha 
 
Se Op_valida Então 
Escreva `O resultado da operação solicitada foi: `, Resultado 
Fim Se 
Fim 
 
A seguir é apresentado mais um exemplo de algoritmo onde aparece um comando Escolha. O 
algoritmo Analisa_Caractere analisa o caractere fornecido pelo usuário e informa qual o tipo 
desse caractere. 
 
Algoritmo Analisa_Caractere 
 
Variáveis 
Car : Caractere 
 
Inicio 
Escreva 'Digite um caractere qualquer' 
Leia Car 
 
Escolha Car 
'A'..'Z' : Escreva 'Você digitou uma letra maiúscula' 
'a'..'z' : Escreva 'Você digitou uma letra minúscula' 
'0'..'9' : Escreva 'Você digitou um dígito' 
'.','-',':',',' Escreva 'Você digitou sinal de pontuação' 
Senão 
Escreva 'Caractere não classificado...' Fim Escolha 
Fim 
 
3.4 Exercícios Resolvidos 
 
Exercício 1 
 
Considere que se queira escrever um algoritmo que, para um número inteiro positivo N, determine se 
esse número é par ou não. Um número inteiro positivo é par se o mesmo for divisível exatamente por 2. 
Assim, o problema pode ser resolvido tomando-se o resto da divisão inteira do número N por 2 e 
verificando-se se esse resto é zero ou não. 
 
Algoritmo Par 
 
Variáveis 
N : Inteiro 
 
Inicio 
Leia N 
Se N Resto 2 = 0 Então 
Escreva N, ' é um número par' 
Senão 
Escreva N, ' não é um número par' 
Fim Se 
Fim 
 
Exercício 2 
 
Considere agora que se queira escrever um algoritmo que calcule o valor do imposto de renda de um 
contribuinte. Considere que o valor do imposto é calculado de acordo com a tabela a seguir. 
 
Renda Anual Alíquota Dedução 
 
Até R$ 10000,00 0% - 
> R$10000 e <= R$ 25000 10% 1000 
Acima de R$25000 25% 4750 
 
De acordo com o problema, para que seja possível a sua resolução, é necessário ter-se como entrada o 
valor da renda anual do contribuinte. Sobre o valor da renda anual, deve -se aplicar um processo de 
seleção de forma a determinar que alíquota deve ser aplicada. Com a determinação da alíquota 
(percentual), o valor do imposto deve ser calculado aplicando-se a alíquota à renda anual e subtraíndo-
se o valor da dedução. 
 
Algoritmo ImpostoRenda 
 
Variáveis 
RendaAnual, Imposto : Real 
 
Inicio 
Leia RendaAnual 
Se RendaAnual <= 10000.0 
Então Imposto  0.0 
Senão 
Se RendaAnual <= 25000.0 Então 
Imposto  RendaAnual * 0.1 - 1000.0 
Senão 
Imposto  RendaAnual * 0.25 - 4750.0 
Fim Se 
Fim Se 
Fim 
 
Exercício 3 
 
Sejam A, B e C números inteiros, todos diferentes. Entre esses números se deseja determinar qual o 
maior valor. A resolução desse problema pode ser obtida aplicando-se o seguinte algoritmo: Se A for 
maior que B e também for maior que C, então A é o maior valor. Caso A não seja o maior valor, então o 
maior valor está entre B e C. 
 
Algoritmo Maximo 
 
Variáveis 
A, B, C : Inteiro 
 
Inicio 
Leia A, B, C 
Se (A > B) E (A > C) Então 
Escreva 'Maior valor: ', A 
Senão 
Se B > C Então 
Escreva 'Maior valor: ' , B 
Senão 
Escreva 'Maior valor: ', C 
Fim Se 
Fim Se 
Fim 
 
Esse problema também pode ser resolvido usando-se uma variável para armazenar o maior valor 
(variável Max, por exemplo). Pode-se assumir inicialmente que A é o maior valor, ou seja, faz-se Max 
receber o valor de A. Após, compara-se Max com B. Caso B seja maior que Max, então Max deve receber 
o valor de B. O mesmo processo deve ser feito com C. 
 
Algoritmo Maximo2 
 
Variáveis 
A, B, C, Max : Inteiro 
Inicio 
Leia A, B, C 
Max  A 
Se B > Max Então 
Max  B 
Fim Se 
Se C > Max Então 
Max  C 
 Fim Se 
Escreva 'Maior valor : ', Max 
Fim