Algoritmos I - Parte 2

Prévia do material em texto

UNIVERSIDADE COMUNITÁRIA DA REGIÃO DE CHAPECÓ 
ACEA 
CURSO DE CIÊNCIA DA COMPUTAÇÃO 
 
 
 
 
 
 
 
Algoritmos e Estrutura de Dados I 
 
 
 
Apostila da Disciplina – Parte 2 
Estruturas de Decisão 
 
 
 
 
 
 
 
Prof. José Carlos Toniazzo 
 
 
 
 
 
 
 
 
 
 
Chapecó, 2011 
1 - Estruturas de Decisão 
 
Em programação, existem muitas situações em que não queremos necessariamente 
que a máquina execute todos os comandos incluídos em um algoritmo. Nestes casos, 
usamos comandos que ensinam o computador a tomar uma decisão, optando por executar ou 
não um ou mais comandos. 
O computador não toma decisões sozinho. Por meio de comandos de decisão, 
podemos instruí-lo a seguir um determinado caminho no algoritmo, tomando por base o teste 
do resultado de uma expressão lógica (que sempre tem como resposta Verdadeiro ou Falso). 
Assim a máquina saberá qual (ou quais) comandos irá executar, a partir do resultado 
da expressão. 
Sendo assim, é fundamental aprendermos uma forma de comando que permita ao 
algoritmo executar alguma(s) instrução(ões) ou outra(s). Para isso temos duas estruturas de 
decisão fundamentais: o comando se e o comando escolha. 
 
1.1 Comando SE 
 
O comando se é uma estrutura de decisão básica em algoritmos. Sua sintaxe (no nosso 
portugol) é: 
 
 
se <expressão_lógica> então <comando_Verdadeiro>; 
ou 
se <expressão_lógica> então <comando_Verdadeiro> senão <comando_Falso>; 
 
O comando se é mais longo do que os outros que vimos até o momento. Na primeira 
forma de sintaxe, podemos indicar ao computador a execução de um comando se o resultado 
da expressão lógica for verdadeiro; havendo resultado falso, a máquina simplesmente ignora a 
execução do comando. 
 
Na segunda forma de sintaxe, o computador também executará um comando se o 
resultado da expressão lógica for verdadeiro, mas o complemento senão indica que queremos 
que a máquina execute outro comando se o resultado for falso. Na execução do algoritmo, a 
máquina sempre verá o resultado da expressão e fará apenas um dos dois comandos (nunca 
os dois ao mesmo tempo). 
 
Para facilitar o entendimento, é mais comum escrever o comando se desta forma: 
 
se <expressão_lógica> então 
 <comando_verdadeiro>; 
 
OU: 
 
 
se <expressão_lógica> então 
 <comando_Verdadeiro> 
 senão 
 <comando_Falso>; 
 
O ponto e vírgula só deve ser colocado no final do comando. 
 
 
Exemplo 1: Ler a idade de uma pessoa e imprimir a mensagem ‘Você é maior de idade’ se 
ela tiver mais de 18 anos de idade. 
 
Algoritmo Maior_de_Idade 
Variáveis 
IDADE: inteiro; 
Início 
escrever ‘Forneça a idade: ‘; 
ler IDADE; 
se IDADE >= 18 então 
escrever ‘Você é maior de idade’; 
Fim 
 
 
Exemplo 2: Ler a idade de uma pessoa e imprimir a mensagem ‘Você é maior de idade’ se 
ela tiver 18 anos ou mais, ou ‘Você é menor de idade’ caso ela tenha menos de 18 anos. 
 
Variáveis 
IDADE: inteiro; 
Início 
escrever ‘Forneça a idade: ‘; 
ler IDADE; 
se IDADE >= 18 então 
escrever ‘Você é maior de idade’ 
 senão 
escrever ‘Você é menor de idade’; 
Fim 
 
O complemento senão indica que a máquina deve exibir outra mensagem se o 
resultado da expressão lógica for falso (uma pessoa é menor quando sua idade NÃO É igual 
ou superior a 18). 
 
ATENÇÃO: Cuidado para não escreve um algoritmo redundante: 
 
// Versão correta, mas redundante do algoritmo 
 
Variáveis 
IDADE: inteiro; 
Início 
escrever ‘Forneça a idade: ‘; 
ler IDADE; 
se IDADE >= 18 então 
escrever ‘Você é maior de idade’; 
se IDADE < 18 então 
escrever ‘Você é menor de idade’; 
Fim 
 
Este algoritmo apresenta dois testes, um para cada mensagem a ser exibida. Foi 
resolvido o problema da versão anterior, mas devíamos explorar a facilidade do comando de 
teste. A segunda expressão lógica é a própria negação da primeira, daí podermos usar o 
senão diretamente, já que ele vai justamente executar um comando para a negação de uma 
expressão lógica. Assim, evitamos o segundo comando de decisão. 
 
Exemplo 3: Ler um número inteiro e dizer se ele é par ou ímpar. 
 
Solução: 
A partir do número de entrada, temos que decidir entre duas mensagens o que deve 
ser impresso. Com o saber se o número é par ou ímpar? A maneira mais simples é lembrar-se 
de que todo número par é divisível por 2. Veja: 
 
6 é par, pois é divisível pro 2 (não há resto) 
10 é par, pois é divisível por 2 (não há resto) 
7 é ímpar, pois não é divisível por 2 (há resto) 
11 é impar, pois não é divisível por 2 (há resto) 
 
Podemos então calcular o resto, usando o operador % da divisão do número por 2, e a partir 
dele decidir qual mensagem será impressa: 
 
// Algoritmo para escrever se um número é par ou ímpar 
Variáveis 
NUM: inteiro; 
Início 
escrever ‘Forneça o número: ‘; 
ler NUM; 
se (NUM % 2) = 0 então 
escrever ‘O número é par’ 
 senão 
escrever ‘O número é impar’; 
Fim 
 
 
 
Testes Encadeados – Um comando SE dentro do outro 
 
Um encadeamento (ou aninhamento) de testes ocorre quando há necessidade de se fazer 
um teste interno a outro, geralmente a partir de uma combinação de decisões. Tal situação pode 
aparecer em função do leque de possibilidades apresentadas em um problema. 
Quando há um encadeamento de testes, o algoritmo possui um comando de decisão dentro 
de outro,que pode estar localizado internamente ao Então ou ao Senão. Veja as construções a seguir: 
 
se A > B então 
se K > M então 
C = K; 
senão 
 C = M; 
... 
 
se X < Y então 
S = X + Y; 
 senão 
se X < (A + B) 
 então 
 A = C 
senão 
B = C; 
 
( Abrindo um parênteses: ) 
 
Conceito de Módulos 
 
Muitas vezes na construção de um algoritmo algumas partes são repetitivas, como por 
exemplo a leitura de uma informação ou mostrar uma mensagem na tela. Dessa forma, para que não 
seja repetido várias vezes a mesma coisa, criamos um módulo do algoritmo em separado. Esse módulo 
fará algum processamento e pode ser chamado várias vezes dentro do algoritmo. 
Cada vez que ele é chamado as instruções contidas no módulo são chamadas novamente. 
Sendo assim, se um mesmo módulo vai ser chamado mais de uma vez, a vantagem é que o programa 
ficará mais conciso (menos linhas) bem como mais organizado. Ao longo dos próximos exemplos este 
conceito será visto na prática. 
 
OBS: Módulos na programação são definidos como procedimentos ou funções. É um conceito 
relativamente complexo, sendo que o aluno deve ter bastante atenção para fixar o aprendizado. 
 
 
 
 
Como o senão é uma parte opcional do comando se, há situações em que testes 
encadeados podem ou não incluir a parte senão de cada decisão. Vamos estabelecer aqui a seguinte 
regra: todo complemento senão é referente ao comando se mais interno imediatamente anterior a ele. 
 
Exemplo: Um quisque de sorvetes vende casquinhas somente nos sabores Chocolate (letra 
‘C’) e Morango (letra ‘M’). Faça um algoritmo para imprimir uma mensagem nas seguintes situações: 
 
• Sorvete de Chocolate com mais de três bolas: ‘desconto de 10%’. 
• Sorvete de Chocolate com qualquer quantidade de bolas: ‘desconto de 5%’. 
 
Considere que os dados de entrada são sempre válidos. 
 
Solução: 
 
Para imprimir uma das mensagens propostas, o algoritmo precisa de dois dados de entrada: 
o sabor do sorvete e a quantidade de bolas. Vamos montar esta leitura com um módulo: 
 
Módulo LER_DADOS_SORVETE; 
{ 
escrever (‘Entre com o sabor (C ou M): ‘); 
ler SABOR; 
escrever (‘Entre com a quantidade de bolas: ‘); 
ler BOLAS; 
}; 
 
Para descobrir a mensagem de impressão, precisamos testar as variáveis de entrada: 
 
Módulo IMPRIMIR_DESCONTO; 
{ 
se SABOR = ‘C’ então 
se BOLAS > 3 então 
escrever ‘Desconto de 10%’senão 
escrever ‘Desconto de 5%’; 
}; 
 
O conteúdo de variável SABOR é testado para saber se o sorvete é de chocolate; em caso 
positivo, um novo teste é feito para decidir qual mensagem será exibida, de acordo com a quantidade de 
bolas. 
 
Algoritmo Completo: 
 
// Algoritmo para impressão de desconto de sorvetes 
Variáveis 
SABOR: caractere; 
BOLAS: inteiro; 
 
Início 
LER_DADOS_SORVETE; 
IMPRIMIR_DESCONTO; 
Fim. 
 
 
Módulo LER_DADOS_SORVETE; 
{ 
escrever ‘Entre com o sabor (C ou M): ‘; 
ler SABOR; 
escrever ‘Entre com a quantidade de bolas: ‘; 
ler BOLAS; 
}; 
 
Módulo IMPRIMIR_DESCONTO; 
{ 
se SABOR = ‘C’ então 
se BOLAS > 3 então 
escrever ‘Desconto de 10%’ 
 senão 
escrever ‘Desconto de 5%’; 
}; 
 
 
 
Repare que a variável SABOR é do tipo caractere. Quando fazemos a comparação com a 
letra C, usamos as aspas para que o computador saiba que C é uma letra. 
 
Outro Exemplo: 
 
Fazer um algoritmo para ler as três notas de um aluno em uma disciplina, e depois imprimir a 
média aritmética das notas e a situação do aluno, a partir da seguinte tabela: 
 
• MEDIA >= 7.0 : Aprovado 
• 4 <= MEDIA < 7 : Prova Final 
• MEDIA < 4 : Reprovado 
 
 
 
 
Solução: 
 
Entradas do algoritmo: as três notas do aluno. 
Saídas do algoritmo: a média dos alunos e a sua situação (que depende do valor da meda). 
Parte do algoritmo (a leitura) apresenta uma estrutura seqüencial simples. Vamos então definir um 
módulo para a entrada de dados: 
 
Módulo LER_NOTAS; 
{ 
escrever ‘Entre com a primeira nota: ‘; 
ler NOTA1; 
escrever ‘Entre com a segunda nota: ‘; 
ler NOTA2; 
escrever ‘Entre com a terceira nota: ‘; 
ler NOTA3; 
 
MEDIA = (NOTA1 + NOTA2 + NOTA 3) / 3; 
 
}; 
 
Na saída de dados, precisamos testar o valor da média para saber qual mensagem será impressa. 
Pela tabela, o aluno é aprovado quando tem média igual ou superior a sete, então podemos incluir o 
seguinte teste: 
 
 
// Impressão (incompleta) da situação do aluno 
Módulo IMPRIMIR_SITUAÇÃO; 
{ 
se MEDIA >= 7 então 
escrever ‘Aprovado’; 
. 
. 
. 
}; 
 
Se o teste da média for falso, ainda há duas possibilidades (aluno fazer prova final ou estar 
reprovado). Neste caso, podemos criar um senão para o primeiro teste, e dentro incluir outro comando 
de decisão. Numa primeira tentativa podemos ter algo assim: 
 
 
// Impressão (incompleta) da situação do aluno 
 
Módulo IMPRIMIR_SITUAÇÃO; 
{ 
se MEDIA >= 7 então 
escrever ‘Aprovado’ 
 senão 
se (MEDIA >= 4) e (MEDIA < 7) então 
escrever ‘Prova Final’; 
 
. 
. 
}; 
 
A expressão lógica colocada no segundo teste reproduz, na notação algorítmica, o que está 
apresentado na tabela: um aluno em prova final é aquele que possui média entre 4 (inclusive) e 7 
(exclusive). 
Mas pense bem: pelo algoritmo, a máquina só executa o segundo teste quando o primeiro é 
falso, isto é, quando a média é menor do que 7. Assim, podemos simplificar o segundo teste por já 
saber que a média está abaixo de 7: 
 
 
// Impressão (incompleta) da situação do aluno 
Módulo IMPRIMIR_SITUAÇÃO; 
{ 
se MEDIA >= 7 então 
escrever ‘Aprovado’ 
 senão 
se MEDIA >= 4 então 
escrever ‘Prova Final’; 
. 
. 
. 
}; 
 
 
Ainda há uma última possibilidade, a reprovação por média abaixo de 4. Esta situação é 
exatamente a negação do segundo teste, de modo que não há necessidade de se fazer mais um 
comando de decisão, e sim incluir outro senão. 
 
 
// Impressão (incompleta) da situação do aluno 
Módulo IMPRIMIR_SITUAÇÃO; 
{ 
se MEDIA >= 7 então 
escrever ‘Aprovado’ 
 senão 
se MEDIA >= 4 então 
escrever ‘Prova Final’ 
 senão 
escrever ‘Reprovado’; 
}; 
 
 
 
OBS: Estes tipos de testes lógicos irão aparecer sucessivas vezes ao longo dos problemas 
computacionais os quais o aluno irá resolver. Dessa forma é de extrema importância que seja 
desenvolvido o raciocínio lógico para a correta elaboração dos testes condicionais. 
 
 
 
 
 
 
 
 
 
 
Algoritmo Completo: 
 
// Algoritmo para cálculo de média e situação de aluno 
Variáveis 
NOTA1, NOTA2, NOTA3, MEDIA: real; 
 
Início 
LER_NOTAS; 
IMPRIMIR_SITUAÇÃO; 
Fim. 
 
Módulo LER_NOTAS; 
{ 
escrever ‘Entre com a primeira nota: ‘; 
ler NOTA1; 
escrever ‘Entre com a segunda nota: ‘; 
ler NOTA2; 
escrever ‘Entre com a terceira nota: ‘; 
ler NOTA3; 
 
MEDIA = (NOTA1 + NOTA2 + NOTA 3) / 3; 
}; 
// Impressão (incompleta) da situação do aluno 
 
Módulo IMPRIMIR_SITUAÇÃO; 
{ 
se MEDIA >= 7 então 
escrever ‘Aprovado’ 
 senão 
se MEDIA >= 4 então 
escrever ‘Prova Final’ 
 senão 
escrever ‘Reprovado’; 
}; 
 
 
Neste tipo de algoritmo, a indentação correta torna-se ainda mais importante, já que ela 
contribui para que se entenda exatamente a lógica que foi programada. 
 
 
Exercícios: 
 
1. Um casal possui três filhos: Marquinhos, Zezinho e Luluzinha. Faça um algoritmo para ler as 
idades dos filhos e exibir quem é o caçula da família; suponha que não haja empates. 
 
 
2. Entrar com um valor e dizer a qual mês do ano o mesmo corresponde. Se o valor for maior 
que doze ou menor que um, diga que o valor não corresponde a nenhum mês. Ex: 3 = mês 
de março. 
 
 
3. A partir de dois números fornecidos pelo usuário, escrever uma das seguintes mensagens: 
 
a. Os dois são pares 
b. Os dois são ímpares 
c. O primeiro é par e o segundo é impar 
d. O primeiro é ímpar e o segundo é par 
 
4. O que será impresso pelo algoritmo a seguir? 
 
// Algoritmo para fixação de testes encadeados 
Variáveis 
X, Y: inteiro; 
Início 
X = 10; 
Y = 1; 
X = X - 1; 
Y = Y + 2; 
X = X – 1; 
Y = Y + 2; 
X = X – 1; 
Y = Y + 2; 
se X > Y então 
escrever ‘X ficou maior do que Y’ 
senão 
se X < Y então 
escrever ‘X ficou menor do que Y’ 
senão 
escrever ‘X e Y ficaram iguais’; 
Fim. 
 
 
1.2 Comando ESCOLHA 
 
No comando se, a partir de cada um dos testes é possível ir ou para um bloco de 
código ou para outro. Todavia existem situações em que a partir de um teste ou valor de uma 
variável podemos assumir uma ou algumas entre várias situações. Nesse caso existe o 
comando escolha, que permite a partir de um valor assumir determinada(s) situações. 
O comando escolha será estudado mais a diante. 
 
 
2 -Teste de Mesa 
 
O objetivo do teste de mesa é fazer uma verificação manual do algoritmo. 
 
Após a construção de um algoritmo, existe uma forma “braçal” de verificar se ele 
está realmente apresentando uma solução correta para o problema. Esta forma, chamada de 
“método chinês” ou ainda “teste de mesa”, consiste em simular manualmente a execução do 
algoritmo, comando após comando, atentando para as entradas e saídas de dados, e 
principalmente acompanhando o comportamento das variáveis que foram utilizadas. 
 
 
Fazer o teste de mesa equivale a colocar-se no papel de computador, anotando o que 
a máquina faria ao encontrar cada comando. 
 
Exemplo 1: Calcular a média de dois números reais fornecidos pelo usuário: 
 
Solução: 
Entradas: dois números reais 
Saída: a média dos números; 
Cálculo necessário: somar os números e dividir o resultado por 2. 
 
// Algoritmo para calcular a média de 2 números 
Variáveis 
NUM1, NUM2, SOMA, MEDIA: real; 
Início 
ler NUM1; // linha 1 
ler NUM2; // linha 2 
SOMA = NUM1 + NUM2; // linha 3 
MEDIA = SOMA / 2; // linha 4 
escrever MEDIA; // linha 5 
Fim 
Primeiro passo: 
NUM 1 = ? 
NUM 2 = ? 
SOMA = ? 
MEDIA = ? 
 
Executada a linha 1 
NUM 1 = 8 
NUM 2 = ? 
SOMA = ? 
MEDIA = ? 
 
Executando a linha 2 
NUM 1 = 8 
NUM 2 = 7 
SOMA = ? 
MEDIA = ? 
 
Executando a linha 3 
NUM 1 = 8 
NUM 2 = 7 
SOMA = 15 
MEDIA = ? 
 
Executando a linha 4 
NUM 1 = 8 
NUM 2 = 7SOMA = 15 
MEDIA = 7.5 
 
Executando a linha 5 
7.5 
 
Este é o valor que será impresso. De fato a média entre os valores 8 e 7 é 7.5. O 
algoritmo está calculando a média corretamente. 
 
Exemplo 2: 
Este algoritmo só serve para praticar o teste de mesa. 
 
// Algoritmo para praticar teste de mesa 
Variáveis 
A,B,C,D: inteiro; 
Início 
A = 10; // linha 1 
B = 20; // linha 2 
D = A + A; // linha 3 
C = A + B; // linha 4 
A = B + C; // linha 5 
D = D + 1; // linha 6 
escrever A; 
escrever B; 
escrever C; 
escrever D; 
Fim 
 
Podemos usar este formato para escrever o teste de mesa. 
 
 
 
 
 
Dica: A partir de agora, todos os algoritmos que você construir devem ser testados 
para saber se a solução que foi dada está correta ou não.