Apostila Algoritmos parte 4

Prévia do material em texto

Autor: Ernani Cláudio Borges. 1 
 
 
Instituto Federal do Triângulo Mineiro Cursos da Área de Computação 
Disciplina de Algoritmos Prof. Ernani Cláudio Borges 
Estudos para as atividades - PARTE 4 
 
Observações importantes: 
a) Esta atividade irá fazer a introdução aos conceitos: 
• Estrutura REPETIÇÃO. 
 
 
 
Tranquilidade, firmeza, objetividade e BONS ESTUDOS! 
 
 
Nome do aluno(a): __________________________________________________________ Data: ____/_____/_____ 
Matrícula (RA): __________________________ ____________________________________ 
 
 
 
 
 
1 ESTRUTURA DE REPETIÇÃO 
 
Antes de começarmos, vamos refletir sobre a palavra “enquanto”!! 
O que ela representa para Você? 
Se você pesquisar em um dicionário poderá encontrar definições como o tipo: 
“No tempo em que”, “ao passo que” dentre outras. 
Destra forma, voltando para nossa área de programação, acredito que 
podemos definir assim: “enquanto for inválido ... digite outra informação” ... 
“enquanto a condição for verdadeira faça as instruções..” 
Foi isso que Você imaginou? 
Se foi, Você está no caminho certo ... pois, é esta a diferencia entre a 
estrutura condicional e a estrutura de repetição, pois, a repetição nos permite criar 
um “laço” e ficar repetindo a informação até que ela atenda a sua condição de 
parada ... e aí sim, podemos continuar a executar as outras instruções. 
Se você pesquisar em livros de algoritmos e programação irá ver que existem 
três tipos de estrutura de repetição: ENQUANTO, REPITA e PARA. Cada uma delas 
tem sua característica as quais serão apresentadas, iniciando neste módulo pela 
estrutura de repetição ENQUANTO e no módulos seguintes as demais. 
Vamos lá! 
 
 
 
Autor: Ernani Cláudio Borges. 2 
 
1.1 A Estrutura ENQUANTO 
 
Para ASCÊNCIO (2007), a estrutura de repetição é utilizada quando um 
trecho do algoritmo ou até mesmo o algoritmo inteiro precisa ser repetido. Essa 
repetição deverá ter uma condição de parada, podendo ser um valor fixo ou uma 
pergunta ao usuário se ele deseja executar novamente. Por exemplo: vamos 
imagina que você queira mostrar no vídeo (na tela do computador) todos os número 
inteiros existente no intervalo de 1 e 100, inclusive eles. Nesse problema você já 
percebe que a condição de parada é o número 100, ok? 
No caso da estrutura de repetição ENQUANTO a pergunta de 
parada/continuar fica no início do bloco. 
Veja a sintaxe da estrutura de repetição ENQUANTO 
 
 
 
enquanto <condição> faça 
 ação 1 
 ação 2 
fimenquanto 
 
 
Observe que enquanto a condição for verdadeira, será executado os 
comandos/ações que estão dentro do bloco de repetição, que no exemplo acima são 
as ações 1 e 2. Quando a condição não for mais satisfatória, ou seja, for falsa, a 
sequencia lógica do algoritmo irá para primeira linha abaixo do fimenquanto. 
 
 
Fique de olho! 
Importante você perceber o que o bloco da estrutura de repetição irá executar 
os comandos que estão dentro dele enquanto a condição for verdadeira. 
Percebe-se também que a lógica de programação só permitira a entrada no 
bloco se a condição for verdadeira. 
 
Autor: Ernani Cláudio Borges. 3 
 
 
 
1.2 Em foco: Vamos analisar a estrutura enquanto? 
 
Analisando mais de perto a estrutura de repetição ENQUANTO, podemos 
perceber que as ações que estão dentro do bloco só irão ser executadas se a 
resposta à CONDIÇÃO for verdadeira ... pode acontecer casos de não se executar 
nenhuma vez isso porque a estrutura de repetição ENQUANTO, pergunta primeiro 
para depois entrar no bloco e após ter entrado, executa as ações e volta, pergunta 
se pode executar novamente. 
Bom, para você compreender a importância da estrutura de repetição 
ENQUANTO, imagine que você quer mostrar no vídeo os valores do resultado da 
tabuada de multiplicação do número 5, mostrando conforme exemplo a seguir: 
 
cálculo resposta 
5 * 1 = 5 
5 * 2 = 10 
5 * 3 = 15 
5 * 4 = 20 
5 * 5 = 25 
5 * 6 = 30 
5 * 7 = 35 
5 * 8 = 40 
5 * 9 = 45 
5 * 10 = 50 
 
O Algoritmo para este exemplo é: 
 
/* 
 Cabeçalho: cálculo tabuada de multiplicação do número 5 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 08/04/2013 
 */ 
/* nome do algoritmo */ 
algoritmo tabuada_multiplicacao 
/* bloco para criar e determinar os tipos de variáveis */ 
Autor: Ernani Cláudio Borges. 4 
 
var 
 n, res : inteiro 
/* bloco do código principal */ 
inicio 
 // inicializar variáveis para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 n � 0 
 res � 0 
 /* 
 corpo do algoritmo 
 entrada dos dados via teclado pelo usuário 
 */ 
 mostre ("digite o valor do número: ") 
 leia (n) // imagine que o usuário irá digitar o número 5 
 // saída – mostrar resultado no vídeo 
 res � n * 1 // ou seja ....: res irá receber o resultado de 5 * 1 
 mostre (res) // irá mostrar o conteúdo de res ... que nesse exemplo será 5 
 res � n * 2 // ou seja ....: res irá receber o resultado de 5 * 2 
 mostre (res) // irá mostrar o conteúdo de res ... que nesse exemplo será 10 
 res � n * 3 // e assim por diante. 
 mostre (res) 
 res � n * 4 
 mostre (res) 
 res � n * 5 
 mostre (res) 
 res � n * 6 
 mostre (res) 
 res � n * 7 
 mostre (res) 
 res � n * 8 
 mostre (res) 
 res � n * 9 
 mostre (res) 
 res � n * 10 
 mostre (res) 
 mostre (“acabou”) 
 pausa 
fim. 
 
 
Observe que para mostrar os resultados da tabuada usamos, com os cálculos 
e mostre´s, ao todo 20 linhas de programação ... conseguiu verificar isso? Ou seja, 
de 1 a 10 sendo um cálculo e um mostre para cada. 
Agora, vamos começar a pensar como podemos fazer para solucionar esse 
mesmo problema utilizando a estrutura de repetição ENQUANTO. 
 
 
Autor: Ernani Cláudio Borges. 5 
 
1.3 Exemplo 1 – cálculo da tabuada de multiplicação com estrutura de 
repetição ENQUANTO 
 
Após demonstração do cálculo da tabuada passo-a-passo (na “mão”), vamos 
criar o mesmo problema, porém, com estrutura de repetição ENQUANTO. 
Para isso vamos refletir/analisar o que está acontecendo com os processos 
dos cálculos ... veja bem ... nos cálculos: 
 
5 * 1 5 * 2 5 * 3 ... 5 * 10 
Analise o que está acontecendo nos cálculos, como por exemplo: “O que é 
fixo?” ... “o que está variando?” 
Observe que: 
5 * é constante 
1, 2, 3, ... 10 Está variando de 1 em 1 até chegar em 10 
 
Após esta análise, podemos determinar que a variação de 1 em 1 até 10, é 
nada mais nada menos que um contador, variando de 1 em 1 ... concorda? 
Podemos fazer o seguinte: criar uma variável com o nome de “cont”, inicializar 
com o valor 1, e proceder com as ações de variação de 1 em 1, veja: 
 
 
Fique de olho! 
Vamos criar uma variável com o nome de “cont”. Ela será um CONTADOR, 
ou seja, ela irá contar de 1 até 10, quando seu conteúdo for maior que 10 a 
seqüência lógica irá finalizar o ENQUANTO e ir para a primeira linha abaixo do 
fimenquanto, ok? 
 
 
Analise a seqüência a seguir: 
 
res � 0 inicializamos a variável res com 0 
cont � 1 inicializamos o contador com o valor 1 
res � 5 * cont ou seja, o valor de cont = 1, desta forma a variável 
Autor: Ernani Cláudio Borges. 6 
 
res irá receber o valor 5. 
mostre (res) o comando mostre irá mostrar no vídeo o valor de 
res que é igual a 5 
? agora vem o detalhe importante ... 
já sabe qual é? 
temos que variar o valor da variável “cont” para 2 ... 
como podemos fazer isso??? 
veja abaixo 
cont � cont + 1 veja que fizemos com que a variável cont recebesse 
o valor que ela tem + 1, ou seja, o valor de cont era 
1 + 1 ... cont irá receber o valor 2 o qual irá 
sobrescrever o valor anterior que era 1. 
agora podemos continuar ... veja os próximos 
comandos. 
res � 5 * cont neste comando o valor de cont = 2 ... 
conseqüentemente a variável res irá receber 10. 
mostre (res) mostramos no vídeo 
cont � cont + 1 nesta ação vamos passar o cont para 3, ou seja, o 
cont era 2 + 1 ... recebeu3. 
res � 5 * cont a variável res irá receber 15 
mostre (res) mostramos 15 no vídeo 
cont � cont + 1 cont irá se tornar 4 
res � 5 * cont res receberá o valor 20 
mostre (res0 mostramos o valor 20 no vídeo 
cont � cont + 1 cont virou 5 
... ... e assim continua ... 
 
E assim por diante ... porém ... não vamos fazer manual desta forma ... vamos 
utilizar o laço de repetição ... esse processo é muito legal ... acompanhe! 
 
 
 . 
 . 
 . 
Autor: Ernani Cláudio Borges. 7 
 
 res � 0 
 cont � 1 
 enquanto cont <= 10 faca 
 res � 5 * cont 
 mostre (res) 
 cont � cont + 1 
 fimenquanto 
 . 
 . 
 . 
 
 
Na seqüência, temos res recebendo 0, cont recebendo 1, e aí fazemos a 
pergunta: “enquanto cont <= 10 faca”, nesse momento, a variável cont possui o 
valor 1, e em resposta a pergunta do enquanto, o conteúdo da variável “cont” é é 
menor que 10, sendo assim, verdadeira ... concorda? E sendo verdadeira, a 
seqüência lógica irá entrar no bloco (laço) e irá executar a primeira linha de 
comando. 
 
Analise agora o algoritmo completo! 
 
1.3.1 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: cálculo tabuada de multiplicação do número 5 com repetição 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 08/04/2013 
 
 nome do algoritmo */ 
algoritmo tabuada_multiplicacao 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 n, res, cont : inteiro 
/* bloco do código principal */ 
inicio 
 // inicializar variáveis para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 n � 0 
 res � 0 
 cont � 1 
 /* 
 corpo do algoritmo 
 entrada dos dados via teclado pelo usuário 
 */ 
 mostre ("digite o valor do número: ") 
 leia (n) // imagine que o usuário irá digitar o número 5 
Autor: Ernani Cláudio Borges. 8 
 
 
 // laço de repetição que irá fazer e mostrar todos os cálculos 
 enquanto cont <= 10 faca 
 res � n * cont 
 // a execução da linha acima, res irá receber o resultado de n * cont 
 mostre (res) // irá mostrar o conteúdo de res 
 cont � cont + 1 // soma mais 1 ao número anterior 
 fimenquanto // volta ao topo e pergunta se cont ainda é verdadeiro 
 mostre (“acabou”) // primeira linha após a finalização do laço de repetição. 
 pausa 
fim. 
 
 
 
1.4 Exemplo 3 – seqüência de números de 1 até 100. 
 
Vamos pensar juntos como podemos fazer para mostrar no vídeo os números 
de 1 a 100, variando de 1 em 1, ou seja, será mostrado no vídeo os números: 1, 2, 
3, 4, 5, 6, 7, 8, 9, ... 100. 
 
1.4.1 Visão central do problema 
 
 
Analisando, junto com Você, o problema de mostrar os números de 
1 a 100 variando de 1 em 1, vamos precisar de quantas variáveis? 
Veja só ... já sabemos qual é o inicio e final da amostragem ... em 
outras palavras vamos iniciar em 1 e finalizar em 100 ... correto? 
Pela lógica vamos precisar de uma variável para contar de 1 até 
100, variando de 1 em 1. Desta forma podemos criar uma variável com o 
nome de cont ... o que acha? 
 
Assim, vamos executar os seguintes passos: 
1) criar a variável cont do tipo inteiro; 
2) inicializar a variável cont com 1; 
3) criar a estrutura de repetição e mostrar o valor de cont a cada 
execução e variando o conteúdo de cont com mais 1. 
4) finalizar o algoritmo 
Autor: Ernani Cláudio Borges. 9 
 
 
 
 
1.4.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar a seqüência de 1 a 100 virando de 1 em 1. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 24/04/2013 
 */ 
 
/* nome do algoritmo */ 
algoritmo sequencia1a100 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 cont � 1 
 /* 
 corpo do algoritmo 
 */ 
 
 enquanto cont <= 100 faca 
 mostre (cont) 
 cont� cont + 1 
 fimenquanto 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
 
1.5 Exemplo 4 – seqüência de números de 1 até n. 
Exemplo: 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , ... , n 
 
Qual a diferença entre esta seqüência e a seqüência do Exemplo 3? 
 
� Podemos verificar que a seqüência do exemplo 3 temo o valor inicial igual 
a 1 e com final igual 100. 
Autor: Ernani Cláudio Borges. 10 
 
� Já esta seqüência, temos o valor inicial igual a 1 porém não sabemos qual 
o valor final, podendo ser qualquer número maior que 1 ... concorda? 
 
1.5.1 Visão central do problema 
 
 
Para resolver o problema de mostrar todos os números inteiro de 1 
até “n” vamos precisar um uma variável para contar de 1 até n variando 
de 1 em 1, e uma outra variável que irá representar o valor final da 
seqüência, a qual será fornecida pelo usuário. 
 
Deste modo, executaremos os seguintes passos: 
1) criar as variáveis cont e n do tipo inteiro; 
2) inicializar a variável cont com 1 e n com 0; 
3) receber o valor de n via teclado; 
4) criar a estrutura de repetição e mostrar o valor de cont e a cada 
execução e variar o conteúdo de cont com mais 1 até que o 
cont seja maior que n. 
5) finalizar o algoritmo 
 
 
 
1.5.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar a seqüência de 1 a n. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 24/04/2013 
 */ 
/* nome do algoritmo */ 
algoritmo sequencia_de_1_a_n 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, n : inteiro 
 
/* bloco do código principal */ 
inicio 
 
Autor: Ernani Cláudio Borges. 11 
 
 // inicializar variáveis para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 cont � 1 
 n � 0 
 /* corpo do algoritmo */ 
 mostre (“digite o valor limite para n: ”) 
 leia (n) 
 enquanto cont <= n faca 
 mostre (cont) 
 cont� cont + 1 
 fimenquanto 
 mostre (“acabou !”) 
 pausa 
fim. 
 
Fique de olho! 
Você conseguiu visualizar que a ESTRUTURA DE REPETIÇÃO no Exemplo 
4 na visão panorâmica 1.5.2, irá processar (executar) os comandos “mostre” e a 
atribuição de “cont ���� cont + 1” enquanto a condição for verdadeira, ou seja, se o 
número limite informado para a variável “n” for igual a 10, a estrutura de repetição irá 
processa os comandos dentro do bloco de repetição até que a a variável “cont” 
tenha um conteúdo maior que 10, fazendo desta forma que a pergunta “enquanto 
cont <= n faça” passe a ser “falsa” finalizando a execução e passando para a 
primeira instrução abaixo do “fimenquanto”. 
 
 
1.6 Exemplo 5 – seqüência de números de 5 até n. 
Exemplo: 5 , 10 , 15 , 20 , 25 , 30 , 35 , 40 , 45 , 50 , 55 , ... , n 
 
Esta seqüência Você já entendeu? 
Fácil né! 
Acompanhe a visão central logo a seguir. 
 
1.6.1 Visão central do problema 
 
 
Ela começa em 5, tem variação de 5 em 5 até que contador seja 
Autor: Ernani Cláudio Borges. 12 
 
maior que o número informado pelo usuário (o qual será representado 
pela variável n. 
 
Deste modo, executaremos os seguintes passos: 
1) criar as variáveis cont e n do tipo inteiro; 
2) inicializar a variável cont com 5 e n com 0; 
3) receber o valor limite via teclado e guardá-lo em n; 
4) criar a estrutura de repetição e mostrar o valor de cont e a cada 
execução e variar o conteúdo de cont com mais 5 até que o 
cont seja maior que n. 
5) finalizar o algoritmo 
 
 
 
1.6.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar a seqüência de 5 a n, variando de 5 em 5. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 24/04/2013 
 */ 
/* nome do algoritmo */ 
algoritmo sequencia_de_5_a_n 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, n : inteiro 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 cont � 5 
 n � 0 
 /* Corpo do algoritmo*/ 
 mostre (“digite o valor limite para n: ”) 
 leia (n) 
 enquanto cont <= n faca 
 mostre (cont) 
 cont� cont + 5 
 fimenquanto 
 mostre (“acabou !”) 
 pausa 
fim. 
Autor: Ernani Cláudio Borges. 13 
 
 
 
 
1.7 Exemplo 6 – seqüência de números de 2, -2 até n. 
Exemplo: 2 , -2 , 4 , -4 , 6 , -6 , 8 , -8 , 10 , -10 , ... , n , -n 
 
Para esta seqüência temos algumas opções de solução. Uma mais longa, 
com mais variáveis e outra com menos variáveis. 
 
Acompanhe a visão central logo a seguir. 
 
1.7.1 Visão central do problema 
 
 
Podemos criar uma variável cont a qual irá começar com 2 e uma 
variável cont1 começando com -2. Outra para receber o valor de n 
(positivo) via teclado, e esse mesmo valor colocar noutra variável, a qual 
irá representar o n negativo ... e lógico, multiplicando o valor de n por 
menos um (-1). Veja: 
cont � 2 
cont1 � -2 
leia (n) 
n1 � n * -1 
desta forma o usuário poderá digitar o limite que quiser e teremos 
armazenado na variável n1 o valor de n negativo. 
 
Ou outra forma é termos UMA variável cont começando com 2, 
mostramos seu conteúdo, logo a seguir multiplicamos por -1, ou seja, 
cont � cont * -1, aí mostramos esse conteúdo. Logo a seguir para fazer 
o cont virar 4 (positivo), basta cont receber o valor que ele tem 
multiplicado por menos um e mais 2, ou seja: cont � (cont * -1) + 2. Já o 
valor n fazer quase a mesma coisa. 
 
Autor: Ernani Cláudio Borges. 14 
 
Vamos escolher a segunda opção, assim, executaremos os 
seguintes passos: 
1) criar as variáveis cont e n do tipo inteiro; 
2) inicializar a variável cont com 2 e n com 0; 
3) receber o valor limite via teclado e guardá-lo em n; 
4) criar a estrutura de repetição e mostrar o valor de cont positivo e 
depois mostrar o valor de cont negativo, e a cada execução e 
variar o conteúdo de cont com mais 2 até que o cont seja maior 
que n. 
5) finalizar o algoritmo 
 
 
 
1.7.2 Visão panorâmica da resolução do problema 
 
/* Cabeçalho: Algoritmo para mostrar a seqüência de 2 – 2 4 -4 6 -6 ... n. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 24/04/2013 
 nome do algoritmo */ 
algoritmo sequencia_de_2_-2 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, n : inteiro 
/* bloco do código principal */ 
inicio 
 // inicializar variáveis para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 cont � 2 
 n � 0 
 /* 
 corpo do algoritmo 
 */ 
 mostre (“digite o valor limite para n: ”) 
 leia (n) 
 enquanto cont <= n faca 
 mostre (cont) 
 cont � cont * -1 
 mostre (cont) 
 cont� (cont * -1) + 2 
 fimenquanto 
 mostre (“acabou !”) 
 pausa 
fim. 
 
Autor: Ernani Cláudio Borges. 15 
 
1.8 Exemplo 7 – quantidade de pares entre 15 números. 
Exemplo: Receber 15 números e mostrar a quantidade de pares 
 
A partir de agora vamos começar a aumentar a quantidade de informação a 
ser processada. 
Com isso, é importante sua concentração e compreensão para criar as 
variáveis e montar a estrutura de repetição. 
 
Acompanhe a visão central logo a seguir. 
 
Fique de olho! 
Você sabe como descobrir, matematicamente, se um número é par ou não? 
Bom isso é fácil ... lembra da função RESTO (x) ... esta função retorna o resto 
da divisão entre dois número inteiros ... RECORDOU a função? 
Desta forma, a regra matemática para saber se um número é par, basta 
verificar se o resto da divisão desse número por 2 é igual a zero, se for, o número é 
par, senão ele é ímpar. 
 
Veja: 
 
res � n resto (2) 
se (rest = 0) então 
 mostre (“esse número é PAR”) 
senão 
 mostre (“esse número é IMPAR”) 
fimse 
 
 
 
 
 
 
Autor: Ernani Cláudio Borges. 16 
 
1.8.1 Visão central do problema 
 
 
Bom, vamos interpretar o problema: 
 
Receber 15 números via teclado, processar e mostrar quantos 
desses números são pares. 
 
1º) para receber 15 número vamos precisar de um laço de 
repetição, ou seja, um contador começando em 1, variando de 1 em 1 
até quinze e dentro desse bloco de repetição o processo de 
VERIFICAÇÃO se o número é par, caso seja, precisamos de uma 
variável para ir guardando o TOTAL de pares. Não podemos esquecer 
de receber o número via teclado, e para isso, temos que ter uma variável 
para receber esse número. Ok? 
 
Analise os passos do algoritmo: 
1) criar as variáveis cont, n, tot_par, res do tipo inteiro; 
2) inicializar a variável cont com 1 e n, res e tot_par com 0; 
3) abrir o laço de repetição (enquanto cont <= 15 faca); 
 3.1) receber o número (leia (n)); 
 3.2) verificar se o resto de n por 2 é igual a zero, caso verdadeiro 
tot_par � tot_par + 1 
 3.3) somar mais 1 ao cont e voltar ao início do enquanto. 
4) mostrar o conteúdo de tot_par; 
5) finalizar o algoritmo 
 
 
 
1.8.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar o total de número pares 
 Nome do Programador: Ernani Cláudio Borges 
Autor: Ernani Cláudio Borges. 17 
 
 Data: 24/04/2013 
 */ 
/* nome do algoritmo */ 
algoritmo pares 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, n, res, tot_par : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis para tirar lixo de memória e 
 cont � 1 
 n � 0 
 res � 0 
 tot_par � 0 
 /* 
 corpo do algoritmo 
 */ 
 enquanto cont <= n faca 
 mostre (“digite o valor limite para n: ”) 
 leia (n) 
 // cálculo do RESTO da divisão 
 res � n resto 2 
 // verificar se o RESTO é igual a zero 
 se (res = 0) entao 
 tot_par � tot_par + 1 
 fimse 
 cont� cont + 1 
 fimenquanto 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
 
 
Fique de olho! 
Você deve estar percebendo que a quantidade de informação que 
escrevemos para resolver cada problema está aumentando. Isso porque cada 
problema tem sua especificidade. 
Aconselho que leia o CAPÍTULO 5 (página 93) do livro “FUNDAMENTOS DA 
PROGRAMAÇÃO DE COMPUTADORES : Algoritmos, Pascal, C/C++ e Java” da 
Autora: ANA FERNANDA GOMES ASDENCIO, 2ª edição, editora Pearson Prentice 
Hall, 2007. 
Autor: Ernani Cláudio Borges. 18 
 
Este material é um breve despertar da lógica com a tentativa de tentar clarear 
alguns passos e seqüências lógicas. 
A busca por uma leitura complementar é fundamental, pois, nos livros você irá 
encontrar mais exemplos e exercícios propostos, enriquecendo ainda mais este 
material. 
 
 
 
 
1.9 Exemplo 8 – Sexo e altura de n pessoas. 
Exemplo: Receber sexo e altura de várias pessoas. Parar quando sexo for igual a 
"*" (asterisco). Mostrar a media de altura das mulheres e dos homens. 
 
Vamos nesse momento trabalhar com outras tipos de dados. Este exemplo irá 
contemplar os tipos: inteiro, real e caracter (literal). 
Onde vamos receber o tipo de sexo de uma pessoa (masculino ou feminino) o 
qual vamos declarar do tipo “caracter”. Vamos receber a altura, a qual pode conter 
casas decimais, por exemplo: 1,80m (um metro e oitenta centímetros). Calcular a 
média aritmética da altura, cuja fórmula é a soma das alturas divididas pela 
quantidade de altura. 
 
Vamos a visão central! 
 
 
1.9.1 Visão central do problema 
 
 
Analisar os nomes e tipos de variáveis primeiro: 
 
1º) vamos determinar que o sexo do indivíduo seja representado 
por “m” (masculino) e “f” (feminino) e caso o usuário digite o símbolo “*” 
(asterisco) iremos interromper a entrada do laço, ou seja: enquanto o 
Autor: Ernani Cláudio Borges. 19 
 
sexo <> “*” faca. 
2º) para calcular a média aritmética dos homens precisamos ter 
uma variável que guarde a soma das alturas e a total de homens. E 
Faremos o mesmo para as mulheres. Vale recordar que para separar o 
homem da mulher, teremos que utilizar a estrutura condicional “se”. 
3º) quando o sexo for igual a “*” (asterisco), saímos do laço e 
calculamos a média e mostramos no vídeo. 
 
 
Analise os passos do algoritmo:1) criar as variáveis sexo do tipo caracter; 
2) criar as variáveis tot_masc, tot_fem do tipo inteiro; 
3) criar as variáveis alt, soma_alt_masc, soma_alt_fem, 
media_m, media_f do tipo real; 
4) inicializar a variável sexo com “ “ (aspas com espaço em 
branco), e as demais com zero; 
5) receber o primeiro sexo (m, f ou *) 
4) abrir o laço de repetição (enquanto sexo <> “*” faca); 
 3.1) receber a altura da pessoa (leia (alt)); 
 3.2) verificar se o sexo = m, calcular somar a altura e tot_masc 
recebe mais um, 
 senão fazer o mesmo para feminino. 
 3.3) receber o próximo sexo, e voltar ao início do laço “enquanto” 
e verificar se é diferente de *. 
5) verificar se tot_masc e tot_fem são diferentes de zero e calcular 
a média e mostrar no vídeo. Senão dar uma mensagem: 
 5.1) não houve sexo masculino, caso tot_masc igual a zero; 
 5.2) não houve sexo feminino, caso tot_fem igual a zero; 
 5.3) não houve nenhuma entrada de dados. 
7) finalizar o algoritmo 
 
 
 
Autor: Ernani Cláudio Borges. 20 
 
1.9.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar media altura masculina e feminina. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 24/04/2013 
 */ 
/* nome do algoritmo */ 
algoritmo altura 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 sexo : caracter 
 tot_masc, tot_fem : inteiro 
 alt, soma_masc, soma_fem, media_m, media_f : real 
/* bloco do código principal */ 
inicio 
 // inicializar variáveis para tirar lixo de memória e 
 sexo � “ “ 
 tot_masc � 0 
 tot_fem � 0 
 alt � 0 
 soma_masc � 0 
 soma_fem � 0 
 media_m � 0 
 media_f � 0 
 /* 
 corpo do algoritmo 
 */ 
 mostre (“digite o primeiro sexo: f, m ou símbolo * para finalizar : ”) 
 leia (sexo) 
 enquanto sexo <> “*” faca 
 mostre (“digite a altura: ”) 
 leia (alt) 
 // verificar o sexo para calculo da quantidade e soma das alturas 
 se (sexo = “f”) entao 
 tot_masc � tot_masc + 1 
 soma_alt_masc � soma_alt_masc + alt 
 senão 
 se (sexo = “m”) entao 
 tot_fem � tot_fem + 1 
 soma_alt_fem � soma_alt_fem + alt 
 fimse 
 fimse 
 mostre (“digite o próximo sexo: m, f ou símbolo * para finalizar : ”) 
 leia (sexo) 
 fimenquanto 
 
 se (tot_masc = 0) entao 
 mostre (“Não houve entrada de pessoas com sexo masculino”) 
 senão 
 media_m � soma_alt_masc / tot_masc 
Autor: Ernani Cláudio Borges. 21 
 
 mostre (“media das alturas masculinas = “, media_m) 
 fimse 
 
 se (tot_fem = 0) então 
 media_f � soma_alt_fem / tot_fem 
 mostre (“media das alturas femininas = “, media_f) 
 fimse 
 
 se (tot_masc = 0) e (tot_fem = 0) então 
 mostre (“não houve nenhuma entrada de dados”) 
 fimse 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
 
2 VALIDAÇÃO CORRETIVA 
 
Uma das grandes utilidades da estrutura de repetição é proporcionar que seja 
feita uma “validação” durante a entrada dos dados. Para compreender de forma 
prática o significado “validação corretiva”, vou citar, a princípio, um exemplo 
ilustrativo, vejamos: 
Imagine que você abriu uma conta corrente no banco de sua escolha e 
durante o procedimento de abertura lhe foi solicitado cópia de seus documentos e ao 
final, o atendente pediu que Você cadastrasse uma senha de no 6 (seis) dígitos 
(números) e em uma semana Você recebeu em sua casa o cartão magnético. Até 
aqui Você acompanhou o raciocínio, ok? 
Bom, desta forma, o atendente pediu que Você que, após chegar o cartão 
magnético, fosse ao caixa eletrônico para fazer um teste. Após chegar na agência, 
você inseriu o cartão no caixa eletrônico, o qual fez uma leitura dos dados que estão 
no cartão, ou seja, uma variável recebeu o número do banco, o número da agência, 
e o número de sua conta, logo a seguir apareceu na tela uma mensagem pedindo 
que você digite sua senha. 
Nesse momento você digitou a senha, a qual foi armazenada em uma variável 
e sem Você perceber o sistema bancário foi verificar se a senha que Você digitou 
agora é igual à senha que Você cadastrou no dia da abertura da conta. 
Autor: Ernani Cláudio Borges. 22 
 
Em palavras algorítmicas, o que está acontecendo nesse momento é que o 
algoritmo do sistema bancário está em uma “estrutura de repetição “enquanto”, e 
que enquanto a senha digitada no teclado do caixa eletrônico for diferente da senha 
cadastrada na abertura da conta, o algoritmo irá lhe dar uma mensagem de erro. 
Contudo o sistema bancário é mais completo e seguro, permitindo que você 
erra a senha no máximo 3 (três) vezes. Essa quantidade de erros pode variar de 
banco para banco. 
Concluindo, a “Validação Corretiva”, visa corrigir, durante a entrada de 
dados um valor, com a intenção de que o algoritmo só funcione com valor correto. 
Ok? 
Vamos aos exemplos. 
 
2.1 Exemplo 9 – raiz quadrada de um número inteiro 
A teoria matemática diz que a raiz quadrada de um número negativo nos 
remete a teoria dos números complexos e a criação de número imaginário. 
Desta forma, para efeito de nossos trabalhos e exercícios, vamos considerar 
que para fazer cálculo de raiz quadrada, o número deve ser maior que zero. 
 
Vamos a visão central! 
 
 
2.1.1 Visão central do problema 
 
Criar as variáveis 
Receber o valor do número via teclado 
Validar corretivamente a entrada para que seja maior que zero 
Calcular a raiz quadrada 
Mostrar o resultado no vídeo. 
Finalizar o algoritmo 
 
 
 
 
Autor: Ernani Cláudio Borges. 23 
 
 
 
 
2.1.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para cálculo da raiz quadrada de um número inteiro 
 Nome do Programador: Ernani Cláudio Borges 
 Data:24/04/2013 
 */ 
 
/* nome do algoritmo */ 
algoritmo raiz 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 nr : inteiro 
 res : real 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis é bom para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 nr � 0 
 res � 0 
 
 /* 
 corpo do algoritmo 
 entrada dos dados via teclado pelo usuário 
 */ 
 mostre ("Digite o valor do número: ") 
 leia (nr) 
 
 // VALIDAÇÃO CORRETIVA 
 enquanto nr <= 0 faca 
 mostre (“Número inválido ... digite outro numero maior que zero:” ) 
 leia (nr) 
 fimenquanto 
 
 // cálculo da conversão 
 res � raiz (nr) 
 
 // saída – mostrar resultado no vídeo 
 mostre ("Resultado da raiz quadrada = ",res) 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
Autor: Ernani Cláudio Borges. 24 
 
 
2.2 Exemplo 10 – mostrar a seqüência enquanto for menor ou igual a N 
Elaborar um algoritmo que processe e mostre o a seqüência: 2 , 3 , 5 , 9 , 17, 
..., N. Validar corretivamente a entrada do valor de N para seja maior ou igual a 2. 
 
Vamos a visão central! 
 
 
2.2.1 Visão central do problema 
 
Criar as variáveis 
Receber o valor do N via teclado 
Validar corretivamente a entrada para que seja maior ou igual a 2 
Processar a variação e mostrar 
Finalizar o algoritmo 
 
2.2.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para cálculo da raiz quadrada de um número inteiro 
 Nome do Programador: Ernani Cláudio Borges 
 Data:24/04/2013 
 */ 
 
/* nome do algoritmo */ 
algoritmo sequencia 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, aux, n : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis é bom para tirar lixo de memória e 
 // sabermos qual o conteúdo inicial da variável 
 n � 0 
 cont � 2 
 aux � 1 
 
 /* 
Autor: Ernani Cláudio Borges. 25 
 
 corpo do algoritmo 
 entrada dos dados via teclado pelo usuário 
 */ 
 mostre ("Digite o valor do número “N” maior ou igual a 2: ") 
 leia (n) 
 
 // VALIDAÇÃO CORRETIVA 
 enquanto n < 2 faca 
 mostre (“Número inválido ... digite outro numero maior ou igual a 2:” ) 
 leia (n) 
 fimenquanto 
 
 // cálculo da sequenciaenquanto cont <= n faca 
 // irá mostrar o conteúdo de da variável cont que na primeira execução 
 // é igual a 2, seguido de um espaço em branco para 
 // separar do próximo número 
 mostre (cont, “ ”) 
 cont � cont + aux 
 aux � aux * 2 
 fimquanto 
 mostre (“acabou ....”) 
 pausa 
fim. 
 
 
 
 
 
 
 
 
Autor: Ernani Cláudio Borges. 26 
 
REFERÊNCIAS 
 
ASCENCIO, Ana Fernanda Gomes. Fundamentos da programação de 
computadores. Prentice Hall. São Paulo, 1999. 
 
ASCENCIO, Ana Fernanda Gomes. Fundamentos da programação de 
computadores. Prentice Hall. São Paulo, 2002. 
 
ASCENCIO, Ana Fernanda Gomes. Fundamentos da programação de 
Computadores: Algoritmos, Pascal, C/C++ e Java. 2ed. São Paulo: Pearson 
Prentice Hall, 2007. 
 
GUIMARÃES, Ângelo de Moura; LAGES, Newton Alberto de Castilho. Algoritmos e 
Estruturas de Dados. 23ed. Rio de Janeiro: LTC – Livros Técnicos e Científicos 
Editora S.A., 1994. 
 
FARRER, Harry, Algoritmos Estruturados. LTC. Rio de Janeiro, 1999 
 
FORBELLONE, André Luiz Villar. A lógica de Programação: A construção de 
Algoritmos e Estruturas de Dados. São Paulo: Makron Books, 1993. 
 
MANZANO, José Augusto. Algoritmos: Lógica para Desenvolvimento de 
programação. Érica. São Paulo, 1996.