Construção de Algoritimos

Prévia do material em texto

Capítulo I Lógica Binária 
Neste capítulo são abordados os conceitos básicos de lógica 
binária, a definição de proposição lógica, operadores e 
conectivos lógicos básicos usados em programação, tabelas 
verdade e avaliação de expressões lógicas. 
I. 1 Expressões Lógicas 
Chama-se expressão lógica toda sentença que pode ser 
avaliada, computada ou “resolvida”, e que tenha como 
resultado um valor lógico. Avaliar uma expressão lógica é 
uma função básica porém não menos importante. É nessa 
capacidade básica que todo aparato computacional está 
baseado. As expressões lógicas são utilizadas para fornecer à 
máquina as diretrizes sobre quais instruções “comandos” 
devem ser executadas em um dado momento. Sem a 
capacidade de avaliação de expressões lógicas, os programas 
estariam restritos a uma seqüência linear de operações. Não 
seria, portanto possível implementar algoritmos com diretrizes 
de desvio/seleção, tampouco seria possível construir estruturas 
de repetição. 
 2 
I. 1.1 Valores Lógicos 
Em se tratando de lógica binária tem-se sempre apenas dois 
valores possíveis VERDADEIRO ou FALSO. Nenhum outro 
valor pode ser considerado, não existe talvez, a dúvida e a 
incerteza não podem ser considerados como valores válidos. 
I. 1.2 Relações 
Uma relação é expressa pôr um operador relacional, e 
representa uma comparação entre dois valores de mesmo tipo. 
Os operadores relacionais estão presentes na matemática e são 
velhos conhecidos. 
• = igual a 
• ≠ diferente de 
• > maior que 
• < menor que 
• ≤ menor ou igual a 
• ≥ maior ou igual a 
O resultado de uma relação será sempre um valor lógico 
verdadeiro ou falso 
Exemplo 1 
a) 5 = 5 → Verdadeiro 
b) 6 > 5 → Verdadeiro 
c) X < 7 → ? 
(quanto vale X?) 
d) 6 ≤ 5 → Falso 
e) 4 ≠ 3 → Verdadeiro 
 3
Exemplo 2 
Para X = 5, Y = 6 e Z = 4 podemos afirmar que: 
a) X ≤ Y é o mesmo que 5 ≤ 6 → Verdadeiro 
b) X + Z ≠ Y é o mesmo que 
 5 + 4 ≠ 6 → 9 ≠ 6 → Verdadeiro 
c) Z ≥ X é o mesmo que 4 ≥ 5 → Falso 
I. 1.3 Proposição Lógica Simples 
Uma proposição lógica simples é toda sentença simples que 
pode ser avaliada resultando em um valor lógico válido 
(Verdadeiro ou Falso). Em programação, uma proposição 
lógica simples é geralmente expressa pôr uma relação, 
podendo também ser expressa pelo próprio valor lógico ou por 
uma variável que armazena um valor lógico. Os exemplos de 
relações expressos acima são também exemplos de 
proposições lógicas simples. 
Exemplo 1 
Sejam X = 2, Y = 5, Z = -4, Flag = Falso e Pronto = 
Verdadeiro, as expressões abaixo são proposições lógicas 
simples: 
a) X < 3 → Valor lógico Verdadeiro; 
b) X – Z > Y → Valor lógico Verdadeiro; 
c) Flag ≠ Verdadeiro → Valor lógico Verdadeiro; 
d) Flag = Falso → Valor lógico Falso; 
e) Flag → Valor lógico Falso; 
 4 
f) Pronto = Flag → Valor lógico Falso; 
g) Pronto = Verdadeiro → Valor lógico Verdadeiro; 
h) não Pronto → Valor lógico Falso; 
I. 1.4 Proposição Lógica Composta 
Uma proposição lógica composta é uma sentença ou 
expressão composta por duas ou mais proposições lógicas 
simples, unidas por operadores lógicos. 
Para avaliar o valor de uma proposição lógica composta, é 
necessário primeiro avaliar o valor lógico de cada proposição 
simples, depois então efetuar as operações definidas pelos 
operadores lógicos. 
Ao avaliar uma expressão lógica composta, faz-se 
necessário observar a ordem de precedência dos operadores, 
exatamente como ocorre com expressões matemáticas que 
envolvem operações de adição, subtração, multiplicação, 
divisão, potências. 
Entretanto, assim como nas expressões matemáticas, é 
possível lançar mão de parênteses para indicar a necessidade 
de efetuar uma operação de menor precedência antes de outra 
de maior precedência. 
I. 1.5 Operadores Lógicos 
Nem sempre é possível expressar uma determinada 
situação através de uma proposição lógica simples apenas, 
nesses casos é preciso uma expressão lógica composta de duas 
ou mais proposições simples. A álgebra da lógica binária 
define operadores para a junção de proposições simples em 
 5
expressões de modo a formar proposições lógicas compostas. 
Para os propósitos desse livro, os três operadores abaixo são 
suficientes. 
• e − conjunção 
• ou − disjunção 
• não − negação 
I. 1.5.1 Conjunção – e – ∧ 
A conjunção de duas proposições lógicas simples resulta 
numa proposição lógica composta cujo valor lógico só será 
verdadeiro quando ambas as proposições simples possuírem 
valor lógico verdadeiro. 
Dadas duas proposições lógicas p e q, a conjunção pode ser 
expressa pôr: p e q ou pôr: p ∧ q 
I. 1.5.1.1 Tabela Verdade 
A tabela verdade de um operador, expressa todas os 
resultados possíveis da expressão, tomando pôr base todas as 
combinações dos valores individuais de cada proposição que 
compõe a expressão. 
p q p ∧ q 
V V V 
F V F 
V F F 
F F F 
Tabela 1 - Tabela verdade operador lógico "e" 
 6 
I. 1.5.2 Disjunção – ou – ∨ 
A Disjunção de duas proposições lógicas simples resulta 
numa proposição lógica composta cujo valor lógico será 
verdadeiro sempre que pelo menos uma das proposições 
simples possuírem valor lógico verdadeiro. 
Dadas duas proposições lógicas p e q, a disjunção é 
expressa pôr: p ou q ou pôr: p ∨ q 
I. 1.5.2.1 Tabela Verdade 
p q p ∨ q
V V V
F V V
V F V
F F F
Tabela 2 - Tabela verdade operador lógico "ou" 
 
I. 1.5.3 Negação – não – ~ 
A negação de uma proposição lógica resulta na inversão do 
seu valor lógico, ou seja, a negação do valor lógico 
verdadeiro resulta em falso e vice versa. 
I. 1.5.3.1 Tabela Verdade 
p ~p q ~q
V F V F
F V F V
Tabela 3 - Tabela verdade operador lógico "não" 
 7
I. 1.5.4 Ordem de Prioridade 
Os operadores lógicos podem ser associados de modo a 
formar expressões que representam proposições lógicas 
complexas. 
Da mesma forma que os operadores matemáticos de adição, 
subtração, multiplicação, divisão e potenciação, os operadores 
lógicos também possuem uma ordem de precedência definida. 
Tal como na matemática, para alterar a ordem de avaliação do 
resultado, é necessário fazer uso de parênteses. 
 
Operadores em ordem de precedência
1o negação – não – ∼ 
2o conjunção – e – ∧ 
3o disjunção – ou - ∨ 
Tabela 4 - Ordem de precedência dos operadores lógicos 
Exemplo 1 
Sendo p e q proposições lógicas simples, montar a 
tabela verdade para as expressões: 
a) não p e q; 
p q ~p ~p ∧ q
V V F F 
F V V V 
V F F F 
F F V F 
 8 
b) não (p e q) 
p q (p ∧ q) ~( p ∧ q)
V V V F 
F V F V 
V F F V 
F F F V 
Tabela 5 - Tabela verdade das expressões lógicas a)- não p e q b)- não ( 
p e q ) 
Exemplo 2 
Dados X, Y, Z, Nome, Logic cujos valores são 
respectivamente 3, 6, 2, Maria e Verdadeiro, Observe a 
forma de avaliação e o resultado de cada uma das expressões 
abaixo: 
a) Y-X > Z 
(substituir as letras pelos seus respectivos valores) 
6 - 3 > 2 
(efetuar as operações matemáticas) 
3 > 2 → 
(Verificar o valor lógico) 
Verdadeiro 
b) Logic 
(fazer a substituição e verificar o valor lógico ) 
 Verdadeiro 
 
 9
c) Nome = Maria e Logic ≠ Verdadeiro 
(fazer as substituições) 
Maria = Maria e Verdadeiro ≠ Verdadeiro 
(Verificar o valor lógico) 
 Verdadeiro e Falso → Falso 
 
d) X ≤ Y e não logic 
(fazer as substituições) 
3 ≤ 6 e não Verdadeiro 
(Verificar o valor lógico) 
Verdadeiro e Falso → Falso 
 
e) não ( Z ≥ 2 e Nome = João) 
(fazer as substituições) 
não ( 2 ≥ 2 e Maria = João) 
(Verificar o valor lógico, operador lógico e ) 
não ( Verdadeiro e Falso) 
(Verificar o valor lógico, operador lógico não) 
não Falso → Verdadeiro 
 
f) Z – Y + X≤ 0 ou Z * Y ≥ X * 10 
(fazer as substituições) 
2 – 6 + 3 ≤ 0 ou 2 * 6 ≥ 3 * 10 
 10
(efetuar as operações matemáticas) 
 -1 ≤ 0 ou 12 ≥ 30 
(Verificar o valor lógico, operador lógico ou ) 
 Verdadeiro ou Falso → Verdadeiro 
 
g) ~Logic 
(fazer a substituição do identificador pelo seu valor) 
 ~ Verdadeiro 
(verificar o valor lógico, operador lógico não ) 
 não Verdadeiro → Falso 
 
h) Logic ≠ Verdadeiro 
(Fazer a substituição) 
Verdadeiro ≠ Verdadeiro 
(verificar o valor lógico) 
 Falso 
 
i) X ≥ 3 
(substituir o valor de x) 
3 ≥ 3 
(verificar o valor lógico) 
Verdadeiro 
 
 11
j) X * Z – Y > 0 e não ( Logic ou (Y + 2 ) ÷ 4 = X ) 
(Fazer a substituição) 
3 * 2 – 6 > 0 e não ( Verdadeiro ou ( 6 + 2 ) ÷ 4 = 3 ) 
(efetuar as operações matemáticas segundo a ordem de precedência) 
6 – 6 > 0 e não ( Verdadeiro ou 8 ÷ 4 = 3 ) 
0 > 0 e não ( Verdadeiro ou 2 = 3 ) 
(efetuar as operações lógicas segundo a ordem de precedência) 
0 > 0 e não ( Verdadeiro ou Falso ) 
Falso e não Verdadeiro 
(Verificar o valor lógico da proposição) 
Falso e Falso → Falso 
 
k) Nome = Pedro ou Nome = Maria 
(substituir) 
Maria = Pedro ou Maria = Maria 
(verificar os valores lógicos das proposições simples envolvidas) 
 Falso ou Verdadeiro 
(efetuar a operação lógica e obter o valor da expressão) 
 Verdadeiro 
Exemplo 3 
Dadas as expressões abaixo, montar a respectiva tabela 
verdade. 
 12
a) p e (q ou r) 
p q r (q ou r) p e (q ou r)
V V V V V 
F V V V F 
V F V V V 
F F V V F 
V V F V V 
F V F V F 
V F F F F 
F F F F F 
Tabela 6 - Tabela verdade da expressão lógica - p e (q ou r) 
b) ~r ∨ ~( ~p ∧ s) 
r p s ~r ~p (~p ∧ s) ~(~p ∧ s) ~r ∨ ~(~p ∧ s) 
V V V F F F V V 
F V V V F F V V 
V F V F V V F F 
F F V V V V F V 
V V F F F F V V 
F V F V F F V V 
V F F F V F V V 
F F F V V F V V 
Tabela 7 - Tabela verdade da expressão lógica - ~ r ∨ ~ (~p ∧ s) 
 13
I. Exercícios 
1) Dados X = 2, A = 4, B = 7, C = 2 , D = 9 e Log = Falso. 
Determine os valores lógicos das expressões abaixo; V = 
Verdadeiro, F = Falso. 
a) ~X ≤ 2 ( ) 
b) ( X < C ) ∧ ~ Log ( ) 
c) ( A mod 2 = C ) ( ) 
d) ( D mod 2 ≠ B mod 2) ( ) 
e) ( B + C ≥ D ) ∨ ( A – X > 2) ( ) 
f) A>B ∨ ~( C > B ) ( ) 
g) ~( D >5 ) ∨ ( C ≤ D-B) ( ) 
h) ( B div 2 ≠ D div 2 ) ( ) 
i) (A div 2 = C) ( ) 
j) (D mod A) é par ( ) 
Obs: A operação mod tem como resultado o resto da divisão 
entre dois números inteiros, por exemplo, 5 ÷ 2 é igual a 2 e 
sobra resto 1, portanto 5 mod 2 = 1. 
Obs: A operação div tem como resultado o quociente da 
divisão entre dois números inteiros, por exemplo 11 ÷ 3 é 
igual a 3 e sobra 2, portanto 11 div 3 = 3 e 11 mod 3 = 2. 
 14
2) Dadas as proposições lógicas p, q, r, s, montar a tabela 
verdade para cada uma das expressões abaixo. 
a) p ∨ q ∧ s 
b) p ∨ ~(r ∨ q) 
c) ~p ∧ ~( r ∨ ~s) 
d) ( r ∧ q ) ∨ ~p 
3) Considere as seguintes informações João é pai de Maria, 
Maria é casada com Pedro que é pai de Joaquim, Luiz é 
primo de Joaquim e irmão de Chiquinha que é neta de 
Josefa mulher de João. Discuta as seguintes afirmações. 
a) Chiquinha é sobrinha de Pedro 
b) João é parente de Pedro. 
4) Se for segunda-feira, não for feriado e as condições 
climáticas forem favoráveis então vou trabalhar, senão 
ficarei em casa e dormirei até mais tarde. E aí ? vou ou não 
trabalhar amanhã ? 
5) Um distinto ermitão possui dois animais de estimação, 
uma onça e uma cabra. De certa vez estava ele a beira do 
rio com seus dois animais de estimação e mais um saco de 
milho. Ele necessita atravessar o rio, entretanto o bote é 
muito pequeno para levar tudo de uma vez. Ajude o amigo 
ermitão nessa tão árdua tarefa. Observe que se a cabra 
ficar sozinha junto do milho, ela o comerá. Da mesma 
 15
forma, se a onça ficar sozinha com a cabra, a segunda será 
a refeição da primeira. 
6) Num reino distante, no tempo e no espaço, existia um 
sábio. O rei sentindo-se ameaçado pela sabedoria do 
homem resolveu provar que o mesmo não passava de um 
charlatão e impôs o seguinte teste. O sábio foi colocado 
numa sala com duas portas apenas, uma delas era a saída 
para a liberdade enquanto que a outra era a porta de 
entrada para o recinto dos leões, que por ordem do rei não 
eram alimentados a vários dias. Em cada porta o rei 
colocou um guarda, ordenando a um deles para apenas 
dizer a mais pura verdade e ao outro para mentir e mentir. 
Ao sábio foi dada a oportunidade de efetuar uma única 
pergunta a um dos dois guardas. O sábio sobreviveu ao 
teste e recebeu seu prêmio tornando-se rei. Como ele 
conseguiu tal proeza ? 
 16
Capítulo II Definições 
Neste capítulo são apresentadas algumas definições e a 
simbologia básica necessária para o desenvolvimento dos 
próximos capítulos. Leia cada definição com muita atenção. 
Antes de passar aos próximos capítulos, será interessante 
também que você providencie uma régua/gabarito para a 
construção de fluxogramas. 
II. 1 Problema 
No transcorrer deste livro, um problema é considerado 
como sendo uma situação em que se tem um ponto de partida 
que pode ou não possuir valores iniciais preestabelecidos, e 
um ponto considerado como fim “solução”, o qual pode 
apresentar um, vários ou nenhum resultado específico 
II. 2 Classe de Problemas 
Uma classe de problemas pode ser entendida como as 
várias situações que se resumem num mesmo problema, por 
exemplo, encontrar a solução das seguintes equações: 
a) 3x2 – 4x + 2 = 0 b) x2 –3 = 0 
 17
c) – 2x2 + 3x = 0 d) 4x2 + x –1 = 0 
Estas são na verdade versões diferentes do mesmo 
problema “encontrar as raízes de uma equação do 2o grau”. 
Assim um problema pode ser visto como uma situação 
exemplo de uma classe de problemas. Encontrar a solução de 
um problema em específico pode ser útil, mas muito mais útil 
é encontrar um mecanismo de resolução que nos permita 
solucionar vários ou até mesmo todos os problemas 
pertencentes a uma mesma classe. Um exemplo relacionado às 
equações do 2o é a famosa fórmula de Baskaha1 
 
 
II. 3 Conceito de Valor Literal 
Um literal é um valor posto conhecido e imutável, expresso 
junto ao algoritmo. Pôr exemplo, ao expressarmos B = 
3,1415 x R2, tem-se que B e R são variáveis, enquanto que 
3,1415 e 2 são valores literais. 
Os valores literais são previamente conhecidos e não 
mudam com o desenvolver da solução do problema. 
II. 4 Conceito de Variável 
Na matemática, muitas vezes usa-se letras para representar 
valores, sejam eles conhecidos ou não. Pôr exemplo na 
expressão 2X + 4 = 5, a letra X representa o valor 0,5 que é a 
solução da expressão. 
 
1 Em homenagem a .........matemático que descobriu a fórmula. 
a
cabbx
.2
..42 −±−=
 18
Em termos de programação, variáveis tem o mesmo 
propósito matemático de representar um valor. Este poderá ser 
um dado numérico, um valor lógico (verdadeiro/falso) uma 
letra ou mesmo um texto. 
Para que se possa armazenar uma informação na memória 
da máquina, é necessário que se tenha reservado um espaço 
para tal. Essa reserva de espaço é feita através da declaração 
de variáveis. A declaração de uma variável se dá pela 
definição de um nome e um tipo associado. O espaço 
efetivamente reservado irá variar de acordo com o tipo da 
informação que será representada pela variável. Esse assunto 
será abordado em mais detalhes nos próximos capítulos. 
II. 5 Algoritmo 
Um algoritmo é um método ( uma seqüência de operações ) 
para a resolução de um determinado problema, seja elematemático ou não. O algoritmo representa o modo como se 
processa a solução do problema. Para ser útil o algoritmo deve 
ser passível de ser aplicado todas as vezes que surgir um 
problema semelhante, mesmo que esse problema não envolva 
os mesmos valores do problema anterior, ou seja, um 
algoritmo expressa as operações e a seqüência de execução 
das mesmas, ele trata de uma classe de problemas semelhantes 
e não de um caso em particular. 
Existem várias formas de expressar um algoritmo, com este 
livro você será levado a trabalhar com a linguagem natural, os 
FLUXOGRAMAS e uma pseudo-linguagem de programação 
conhecida como PORTGUÊS ESTRUTURADO. 
 19
II. 6 Programa 
Muitos problemas, dada a sua complexidade, não são 
passíveis de serem solucionados a partir de um único 
algoritmo. Nesses casos, fazemos uso de um programa. 
Chama-se programa, um conjunto de um ou mais 
algoritmos, articulados de forma a proverem solução para uma 
ou mais classes de problemas semelhantes. 
II. 7 Linguagem Natural 
É a linguagem que costumamos usar em nosso dia a dia, os 
algoritmos escritos dessa forma parecem-se com o modo de 
fazer de uma receita de bolo, ou seja, é uma descrição 
seqüencial, passo a passo, do que deve ser feito para resolver o 
problema. 
Seja por exemplo, o ato de trocar uma lâmpada do tipo 
incandescente supostamente queimada. 
1. Acionar o interruptor, se a luz acender não precisa 
trocar senão vai para o passo dois. 
2. Retirar a lâmpada do soquete e verificar as 
condições da mesma, se concluir que o filamento 
está rompido então substitui-la por uma nova senão 
vai para o passo 5 
3. Acionar novamente o interruptor. Se a lâmpada 
acender, informar ao requisitante que o problema foi 
solucionado, senão executar o passo 4 
4. Verificar a existência de energia elétrica na rede. Se 
positivo, informar o requisitante que deve haver 
algum outro problema, senão informar que o serviço 
 20
foi realizado mas que não foi possível testar dada a 
falta de energia. 
5. Informar ao requisitante que o problema é outro pois 
a lâmpada não está queimada. 
II. 8 Fluxograma 
Um fluxograma é a representação gráfica de um algoritmo, 
através de simbologia própria. É uma das ferramentas 
utilizadas para representar uma construção algorítmica que 
expressa a resolução de um problema ou classe de problemas. 
Atualmente muitos autores afirmam que o fluxograma é uma 
ferramenta ultrapassada, mas pessoalmente ainda não conheço 
ferramenta mais indicada para iniciantes em programação 
estruturada. 
II. 8.1 Simbologia para Fluxogramas 
A tabela abaixo apresenta os símbolos adotados neste livro 
para a representação de algoritmos através de fluxogramas. 
Saber identificar o significado de cada símbolo é o primeiro 
passo para tirar proveito dessa ferramenta. 
 _ O símbolo de terminação marca o 
início e o fim de um algoritmo. É 
importante frisar que deve existir apenas 
um início e um fim em cada algoritmo. 
Terminador 
 21
 _ Este símbolo é utilizado para indicar a 
necessidade de entrada de dados pelo 
teclado, o computador deve esperar que o 
usuário digite a informação necessária e 
depois pressione a tecla de entrada. 
 _ O símbolo de fita magnética é utilizado 
para indicar o ato de ler ou gravar uma 
informação em um dispositivo de fita 
magnética. 
Fluxo de dados _ Uma seta indica o sentido do fluxo de 
dados e a seqüência de execução das 
operações que formam o algoritmo. 
 _ Usa-se este símbolo para indicar a 
leitura/gravação de informações em um 
disco rígido. 
 _ Este símbolo representa o monitor de 
vídeo e é usado para indicar a 
apresentação de uma 
mensagem/informação ao usuário. 
Fim de Estrutura _ O conector é utilizado para marcar o 
fim de um estrutura de seleção e/ou 
controle de repetição. 
 _ O símbolo de processo é utilizado para 
indicar a execução de uma ou mais 
operações (processamento de dados) que 
não envolvem entrada e saída de dados. 
Entrada via 
Teclado 
Fita 
Magnética 
 HD 
Saída no 
Video 
 
Processo 
 22
 _ Este símbolo indica a impressão de um 
relatório e/ou conjunto de mensagens e 
informações. 
 _ O símbolo de decisão marca um ponto 
onde é necessário avaliar uma 
determinada condição para então decidir 
pôr um entre dois caminhos a seguir na 
execução do algoritmo. Este símbolo é 
essencial para a construção de estruturas 
de seleção e controle de repetição. 
Tabela 8 - Tabela de símbolos básicos para o desenvolvimento de 
fluxogramas 
II. 9 Português Estruturado 
O PORTUGUÊS ESTRUTURADO é uma pseudo 
linguagem de programação estruturada, seu está diretamente 
ligado ao fato de por não ser uma linguagem de programação 
verdadeira, sua sintaxe pode ser menos rígida e mais 
adaptável. Um algoritmo expresso em português estruturado 
pode facilmente ser implementado em qualquer linguagem de 
programação. 
Como toda linguagem de programação, o Português 
Estruturado consiste de um conjunto de palavras e de um 
conjunto de regras que nos permitem expressar construções 
algorítmicas de modo não ambíguo. Para cada construção 
expressa num fluxograma, existe uma representação expressa 
em Português Estruturado, essas construções serão abordadas 
nos próximos capítulos. 
Saída 
Impressa
Decisã
 23
II. Exercícios 
1) Descreva detalhadamente, passo a passo, como você faz 
para escovar os seus dentes. 
2) Descreva o ato de apontar um lápis. 
3) Descreva como proceder para encontrar as raízes de uma 
equação do segundo grau, utilizando a fórmula 
 
4) Descreva como proceder para calcular a média final de um 
aluno do seu curso. 
5) Descreva como proceder para saber se um determinado 
número é ou não primo. 
6) Descreva como proceder para efetuar uma pesquisa por 
determinado assunto em um site de busca da internet. 
7) Descreva como você faz para escrever os números pares 
menores que 50. 
8) Descreva uma tática para vencer no conhecido jogo da 
velha. 
a
cabbx ⋅
⋅⋅−±−=
2
42
 24
Capítulo III Construindo 
Algoritmos 
Neste capítulo são discutidos os pontos mais críticos na arte 
da construção de algoritmos. É imprescindível que você não 
passe para o próximo capítulo sem antes ter certeza de que 
compreendeu e assimilou os tópicos abordados a seguir. 
III. 1 Passos essenciais 
Para que ser capaz de escrever um algoritmo para uma 
determinada classe de problemas é necessário que primeiro 
saber resolver problemas pertencentes a tal classe. Não é 
possível escrever um algoritmo que represente a seqüência de 
passos necessários à solução de um ou mais problemas 
semelhantes, sem antes ter o domínio da solução. Os passos 
abaixo são essenciais para a resolução de um problema. 
9 Ler e entender o enunciado: Antes de partir para a 
resolução, deve-se ter certeza absoluta de que o problema 
foi compreendido, você sabe exatamente qual é o ponto de 
partida e qual deve ser o ponto de chegada “a solução 
esperada”. Esse é o passo mais importante, portanto não se 
 25
apresse e detenha-se um pouco mais na leitura e 
compreensão do enunciado. 
 
9 Especificação das Entradas, e Saídas: A solução de um 
problema/classe de problemas, passa necessariamente, 
primeiro pela especificação das entradas, essas podem 
apresentar-se na forma de valores conhecidos ou não. Se 
todos valores de entrada são conhecidos, então temos um 
“problema”. por outro lado, se alguns valores iniciais não 
são conhecidos a priori “serão fornecidos posteriormente 
pelo usuário”, então temos uma classe de problema. A 
especificação dos valores iniciais “entradas” é uma questão 
de leitura, interpretação e compreensão do enunciado e do 
problema em si. 
Após a especificação das entradas, é necessário especificar 
os resultados esperados. O que se espera comoresultado 
após a resolução do problema. 
Uma forma simples de encontrar as entradas/saídas é 
responder as perguntas: O que eu tenho? (entradas e valores 
imutáveis); O que eu quero? (resultados esperados/saídas); 
 
9 O Processamento: Antes da construção do algoritmo sob a 
forma de fluxograma, é necessário raciocinar sobre o 
problema e a melhor forma de resolução do mesmo. Você 
só poderá partir para a diagramação do algoritmo após ter 
claro em sua mente, qual é o método de resolução a ser 
empregado e qual a seqüência de operações envolvidas. Na 
maioria das vezes é indicado descrever a seqüência de 
ações antes de partir para a diagramação. 
 26
Aqui a questão é responder a seguinte pergunta: Como 
fazer para transformar o que tenho no que quero? 
 
9 A Construção do Algoritmo: Nesse ponto você já deve 
saber exatamente o que deve ser feito para que o problema 
seja solucionado, caso contrário deverá retornar aos passos 
anteriores. Não siga em frente se não tiver absoluta certeza 
de que sabe o que está fazendo. 
Construir um algoritmo significa expressar de forma clara e 
seqüencial as operações envolvidas na resolução do 
problema/classe de problemas. A resolução do problema é 
subdividida em uma seqüência ordenada de operações 
simples, que ao ser executada na ordem estabelecida, 
produz a solução do mesmo. É mais ou menos como 
escrever o modo de fazer de uma receita de bolo, porém um 
pouco mais detalhadamente. 
 
9 O teste de mesa: O teste de mesa consiste em efetuar 
mentalmente, a execução das operações expressas no 
algoritmo para verificar se elas realmente resultam na 
solução do problema, como era esperado. Geralmente usa-
se uma tabela em que cada coluna representa uma das 
variáveis do algoritmo, é necessário também uma coluna 
para a indicação dos resultados. O algoritmo é seguido 
conforme o descrito, atualizando a tabela a cada operação 
realizada. Ao mesmo tempo em que executa o algoritmo 
passo a passo, você deve analisar os resultados produzidos 
verificando se há ou não progresso em direção ao resultado 
esperado. 
 27
 
A correta execução dos passos acima configura um 
algoritmo para a construção de algoritmos. Vejamos alguns 
exemplos. 
Exemplo 1 
Calcular a área de uma pequena peça retangular de 
madeira, em cm2. 
Entrada: 
1 Peça de madeira retangular; 
Saída: 
1 Área da peça em centímetros quadrados; 
Algorítmo: 
Linguagem Natural 
1 Pegar uma régua, graduada em centímetros; 
2 Pegar um papel para rascunho; 
3 Usando a régua, medir o comprimento do lado 
maior e anotar no rascunho; 
4 Ainda usando a régua, medir o comprimento do 
lado menor e anotar no rascunho; 
5 Calcular a equação Area = LM x Lm, onde Area 
é a área da peça em cm2 e LM e Lm são 
respectivamente Lado Maior e Lado Menor em 
cm. 
6 Informar o resultado 
 28
Exemplo 2 
Dados os valores de referentes as medidas da base (B = 4 
cm) e da altura (H = 3,2 cm) de um triângulo, calcular a sua 
respectiva área em cm2. 
Entrada: 
1 Valor da base (B = 4cm) e da altura (H = 3,2 cm); 
Saída: 
1 Área (A) do triângulo em cm2; 
Algorítmo: 
Linguagem Natural 
1 Início; 
2 Obter os valores da medida da base ( B ) e da 
altura ( H ) 
3 Calcular A = ( B x H ) / 2; 
4 Informar o resultado ( A ) como sendo a área do 
triângulo; 
5 Fim; 
Exemplo 3 
Construir um algoritmo para calcular o volume de um cone, 
cujos valores de raio da base (R) e Altura (H) só serão 
informados pôr ocasião da execução do algoritmo, no entanto 
sabe-se que π = 3,14159 e que o volume de um cone é dado 
pela fórmula V=1/3.B.H, sendo V= Volume, B = Área da 
Base ( B = πR2) e H = Altura. 
 
 29
Entrada: 
1 Raio da base do cone, R – a ser informada; 
2 Altura do cone, H – a ser informada; 
Saída: 
1 Volume do cone, calculado pela fórmula V = 
1/3.B.H; 
Algorítmo: 
Linguagem Natural 
1 Inicio; 
2 Solicitar o valor do raio da base, R; 
3 Solicitar o valor da altura do cone, H; 
4 Calcular a área da base B, usando a fórmula B = 
πR2; 
5 Calcular o volume do cone, fazendo V = 1/3.B.H; 
6 Informar o volume do cone ( V ) em cm3; 
7 Fim; 
III. Exercícios 
1) Suponha que você tem em suas mãos uma lata de leite em 
pó. Com base nos exemplos acima, escreva um algoritmo 
para calcular a quantidade aproximada de chapa em cm2 
necessária para a confecção da respectiva lata. Observe 
que embora as latas de leite em pó, encontradas a venda no 
supermercado, sejam redondas, a chapa será sempre 
retangular e haverão sobras de recorte na confecção do 
 30
fundo e da tampa, essas sobras em geral são descartadas 
como sucata. 
2) Agora desenvolva um algoritmo para calcular o volume da 
lata de leite em pó. 
3) Dado que uma esfera possui raio R=3,4 m, qual será o seu 
volume, sabe-se que Vesfera = 4/3πR3, e que π = 3,14159. 
4) Converter uma temperatura T dada em graus Celsius, para 
Fahrenheit e para Kelvin. Fórmula C/5 = (F-32)/9 = (K-
273)/5. 
5) Um dado automóvel percorre em média 11,5 Km com um 
litro de combustível. Seu dono pretende fazer uma viagem 
de 1240Km, calcule o valor em reais a ser gasto com 
combustível, cada litro custa R$:1,75. É importante 
observar que estes valores podem variar de um dia para 
outro. 
6) Desenvolva um algoritmo para a conversão de valores em 
Reais para Dólares. A cotação do dólar varia todos os dias, 
desse modo não é possível pré-fixar um valor. 
7) Desenvolva um algoritmo para calcular a média final antes 
do exame, para um acadêmico na disciplina de Lógica de 
Programação, sabendo que o curso é semestral com duas 
notas parciais. 
8) Desenvolva um algoritmo para trocar o valor de duas 
variáveis. O algoritmo deve aceitar os dois valores como 
entradas, armazenar cada um deles em uma variável e 
 31
depois permutar esses valores entre si e apresentar o 
resultado. 
9) Desenvolva um algoritmo que aceite como entradas – O 
custo de um produto em R$ e a margem de lucro esperada 
em percentual – calcule e apresente o respectivo valor de 
revenda do produto. 
10) Desenvolva um algoritmo que, uma vez informadas as 
coordenadas de dois pontos (x, y) do plano cartesiano, 
calcule e informe a distância entre eles. 
11) O motorista de um automóvel ao passar pela marca Km 
326 de uma rodovia, verifica que o velocimetro marca 
50Km/h. A partir desse momento o motorista passa a 
acelerar e ao passar pela marca Km 328 está a uma 
velocidade de 120Km/h. Escreva um algoritmo que apartir 
desses dados, calcule e apresente a aceleração média do 
veículo no percurso. 
12) A altura máxima atingida por um objeto lançado 
verticalmente para cima pode ser calculada pelas equações 
da cinemática escalar, considerando que ao atingir o ápice, 
a velocidade do objeto é nula. Escreva o respectivo 
algoritmo de calculo. 
 32
Capítulo IV Algoritmos 
Expressos em Fluxogramas e 
Português Estruturado 
Este capítulo é uma introdução à representação de 
algoritmos através dos FLUXOGRAMAS e/ou do 
PORTGUÊS ESTRUTURADO. São apresentados os 
conceitos básicos de diagramação, um pequeno conjunto de 
palavras reservadas e as regras que constituem o Português 
Estruturado. Também são apresentados alguns conceitos e 
técnicas básicas muito importantes em programação 
estruturada. O estudante não é aconselhado a prosseguir sem 
antes compreender o conteúdo deste capítulo. 
IV. 1 Fluxogramas 
No capitulo III, foi mostrado como expressar um algoritmo 
na forma de passos/operações seqüenciais, neste capítulo o 
objetivo é representar esses passos na forma de um 
fluxograma. No exemplo 2 do capitulo III, foi dado o seguinte 
algoritmo. 
 
 
 33
Inicio
A = ( B x H ) / 2
"Area do triângulo:", A
Fim
B, H
Linguagem Natural 
1 Início;2 Calcular A = ( B x H ) / 2; 
3 Informar o resultado ( A ) como sendo a área do 
triângulo; 
4 Fim; 
Primeiramente observe que os valores da base B e da altura 
H são conhecidos e valem respectivamente 4 cm e 3,2 cm. 
Relembrando a simbologia apresentada no capítulo II monta-
se o respectivo fluxograma. 
 
 
 
 
 
 
 
 
 
 
Fluxograma 1 - Cálculo da área de triângulos 
 
Em primeiro lugar, observe que mesmo sendo conhecido o 
valor da base B e da altura H, esses encontram-se 
representados como entradas via teclado. Isso ocorre porque 
 34
queremos um algoritmo genérico, capaz de calcular a área de 
qualquer triângulo e não de apenas um em específico. Tenha 
sempre em mente que um algoritmo deve essencialmente ser 
genérico, ou seja solucionar toda uma classe de problemas. 
Em segundo, temos um retângulo representando o 
processamento, no caso, a fórmula matemática para o calculo 
da área de um triângulo. 
Em terceiro, vem o símbolo do que representa o monitor de 
vídeo, neste foi colocado um texto entre aspas (“Área do 
triângulo”), seguido de uma virgula e da letra A, o que isso 
significa ? 
Bem a resposta é simples, observe que o que está entre 
aspas é um texto, uma frase explicativa, já a letra A que não 
está entre aspas representa um valor, o valor calculado no 
passo anterior como sendo a área do triângulo. Essa é uma 
regra a ser seguida, toda vez que indicar a apresentação de um 
texto no monitor de vídeo, o texto deve ser delimitado pôr 
aspas, já quando indicar a apresentação de um valor 
representado pôr uma letra ou palavra, não tem aspas. A 
virgula aparece como separador. O separador é necessário 
quando se faz uso de um mesmo símbolo para indicar a 
apresentação de dois ou mais valores. 
Veja agora como fica o exemplo 3 do capitulo anterior, 
para o qual foi apresentado o seguinte algoritmo: 
 
Linguagem Natural 
1 Inicio; 
2 Solicitar o valor do raio da base, R; 
 35
3 Solicitar o valor da altura do cone, H; 
4 Calcular a área da base B, usando a fórmula B = 
πR2; 
5 Calcular o volume do cone, fazendo V = 1/3.B.H; 
6 Informar o volume do cone em cm3; 
7 Fim; 
 
Fluxograma: 
 
 
 
 
 
 
 
 
 
Fluxograma 2 - Cálculo do volume de cones 
IV. Exercícios 
Antes de continuar você precisa exercitar, então pegue a 
sua régua de desenho, lápis, borracha e papel e monte os 
fluxogramas referentes aos algoritmos desenvolvidos para os 
exercícios propostos no capítulo III 
R, H
B = 3,14159 x R 2
V = ( B x H ) / 3
"Volume do cone:", V
Fim
Início
 36
IV. 2 Português Estruturado 
O Português Estruturado é uma linguagem para 
especificação de algoritmos em forma estruturada. Essa 
pseudo linguagem de programação consiste de um conjunto de 
símbolos e palavras reservadas, que são usadas para 
representar os comandos, as operações e as diversas estruturas 
encontradas nas linguagens de programação. Também faz 
parte do Português Estruturado, um conjunto de regras a 
serem observadas. 
IV. 2.1 Tipos Básicos 
Toda linguagem de programação possui um conjunto de 
tipos básicos, esse conjunto define os tipos primitivos aos 
quais cada variável pode ser associada. O tipo de uma variável 
define o tamanho do espaço de memória associado ao seu 
nome, bem como quais são as operações possíveis, logo ficam 
implicitamente definidas quais informações podem ser 
armazenadas numa variável e quais não podem. Pôr exemplo, 
se você definiu uma variável associada ao tipo inteiro, não 
armazenar nela um valor real pois os números reais possuem 
características que os números inteiros não suportam, a virgula 
é um exemplo disso. Além disso o espaço de memória 
necessário para armazenar um número real é maior que o 
espaço reservado para um inteiro. 
 
Os tipos de dados definidos para nossa pseudo linguagem 
serão: 
 37
9 inteiro – variáveis associadas a esse tipo dados, 
armazenam apenas números inteiros e podem ser objeto das 
seguintes operações: 
 
 – inversão de sinal ( menos unário ) 
Mod Resto da divisão ( ex: 5 mod 2 = 1 ) 
Div Quociente da divisão (ex: 5 div 2 = 2 ) 
^ Potência inteira 
√ Radiciação inteira 
÷ Divisão 
* Multiplicação 
+ Adição 
− Subtração 
 
9 Real – uma variável associada ao tipo real permite 
armazenar qualquer valor numérico, porem não pode ser 
usada com as operações mod e div pois essas operações só 
se aplicam a números inteiros. 
 
9 Lógico - O tipo lógico define um tipo de dado que só 
admite dois valores verdadeiro e falso. Sobre um dado do 
tipo lógico podem ser aplicados os operadores vistos no 
capitulo I ( e, ou, não ) e alguns outros que não serão 
abordados neste trabalho. 
 
P
R
I 
O
R
I 
D
A
D
E
 38
9 Caracter – Variáveis associadas a esse tipo definem 
espaços de memória que podem ser usados para armazenar 
caracteres individuais, ou seja letras, dígitos, símbolos. O 
conjunto de caracteres mais usual é conhecido como tabela 
ASCII, veja no final do livro. 
 
9 Frase – O tipo frase define um espaço de memória capaz 
de armazenar uma seqüência de caracteres de modo a 
formar uma frase. Na linguagem PASCAL, o 
correspondente é o tipo string o qual permite um tamanho 
máximo de 255 caracteres, mas pôr enquanto não 
precisamos nos preocupar com o tamanho máximo. 
IV. 2.2 Operadores Matemáticos 
 
 – inversão de sinal ( menos unário ) 
^ Potenciação e 
√ Radiciação 
* Multiplicação e 
/ Divisão 
+ Adição e 
– Subtração 
 
P
R
I 
O
R
I 
D
A
D
E
 39
IV. 2.3 Operadores Relacionais 
 
> Maior que 
< Menor que 
≥ Maior ou igual a 
≤ Menor ou igual a 
≠ Diferente de 
IV. 2.4 Instruções Básicas 
As instruções representam os passos de um algoritmo, e são 
expressas fazendo-se uso do conjunto de palavras reservadas 
da linguagem. 
9 leia ( ) – Representa uma entrada de dados via teclado, 
equivalente ao símbolo: 
 
 
9 escreva ( ) – Representa uma saída de dados/informações 
no monitor de vídeo, é equivalente ao símbolo: 
 
 
9 imprima ( ) – Representa uma saída de dados/informações 
através do dispositivo de impressão, equivalente ao 
símbolo; 
 
 
 40
 
 
9 Principal ( ) – Marca o início do programa 
 
9 ← – A seta representa a atribuição de um valor para uma 
variável 
 
9 { – Abre Chaves, marca o início de um bloco de instruções, 
é necessário sempre que houver mais de uma instrução. 
 
9 } – Fecha Chaves, marca o fim de um bloco de instruções. 
 
9 ; – Separador de instruções; 
IV. 3 Técnicas Estruturadas Básicas 
Antes de começar as escrever algoritmos empregando o 
Português Estruturado, é necessário tomar conhecimento de 
algumas técnicas que foram desenvolvidas para tornar os 
algoritmos legíveis e apresentáveis. Vale a pena frisar que não 
se trata de frescura, é um dos pontos mais críticos. A diferença 
entre um algoritmo comum e um algoritmo ótimo, não reside 
apenas na lógica aplica, mas também na forma estética e 
especialmente na legibilidade do mesmo. 
Quando construir um algoritmo, tenha em mente que não o 
está construindo para você, mas sim para outros. Um bom 
 41
algoritmo é aquele que reúne simplicidade, funcionalidade, 
eficiência e legibilidade. 
 
9 Palavras reservadas - As palavras reservadas, aquelas que 
fazem parte da linguagem, devem ser expressas com letras 
minúsculas em negrito quando impressas pôr computador e 
sublinhadas quando escritas a mão. Palavras reservadas são 
aquelas que fazem parte do Português Estruturado e não 
podem ser usadas como nomes de variáveis. ( leia, 
imprima, escreva, se, então, senão, fim-se, enquanto, 
para, do ...) 
 
9 Variáveis – Toda variável deve necessariamenteser 
primeiro declarada para depois poder ser utilizada. Essa é 
uma restrição imposta pôr muitas linguagens de 
programação e será adotada nesse livro. Imagine como 
seria possível armazenar um valor na memória, sem antes 
ter requisitado o espaço necessário? Como seria possível se 
referir a um determinado espaço de memória sem lhe ter 
atribuído um nome? Como a máquina poderia identificar as 
operações que podem ser efetuadas sobre o valor 
armazenado num determinado espaço de memória, sem que 
o mesmo tivesse sido associado a um tipo de dado? 
 
9 Nomenclatura de variáveis – O nome de uma variável 
deve começar sempre pôr uma letra maiúscula, sendo as 
demais minúsculas. Quando o nome for composto de duas 
ou mais palavras, a primeira letra de cada palavra deverá 
 42
estar em maiúsculo. Exemplos: Raio, Base, Altura, 
LadoMaior. 
Ao dar nome a uma variável, certifique-se de que o nome 
dado reflete a essência da informação a ser armazenada. 
Nomes tipo X1, X2, X3, A, B, C, ... são essencialmente 
confusos pois não refletem as informações que as variáveis 
armazenam. Um bom nome de variável, é aquele capaz de 
nos fazer compreender imediatamente, sem ser necessário 
analisar o algoritmo, qual é a informação armazenada na 
variável. São bons exemplos: AlturaTriângulo, RaioBase, 
CotaçãoDolar. 
 
9 Sintaxe – A sintaxe diz respeito à forma, o modo correto 
de expressar uma determina ordem/comando ou estrutura. 
Cada comando possui uma maneira correta de escrever a 
qual deve ser respeitada. Algoritmos que não obedecem as 
regras de sintaxe, geralmente apresentam inconsistências 
(erros). 
 
9 Semântica – A semântica diz respeito ao significado, o 
entendimento que se obtêm daquilo que está 
expresso/escrito. Na vida real, nem sempre o que 
escrevemos significa aquilo que queríamos escrever. 
Muitas vezes somos ambíguos, as vezes dizemos “não” 
significando “sim”, outras vezes usamos gírias ou costumes 
que podem nos ser familiares, mas que são completamente 
confusas para outras pessoas. Em termos de programação, 
não pode haver ambigüidades pois a máquina não é capaz 
de raciocinar e interpretar comandos dúbios. Desse modo 
 43
faz-se necessário escrever de forma explicita todas as 
operações a serem efetuadas. 
9 Edentação – É uma técnica que torna clara a hierarquia das 
estruturas/instruções que compõem o algoritmo tornando-o 
de fácil leitura. Em geral a edentação consiste de um 
deslocamento de 3 caracteres para a direita, sempre que se 
inicia um novo bloco de instruções. As instruções 
subordinadas a uma estrutura ou bloco devem ficar três 
casas para a direita, indicando a sua subordinação. Veja os 
exemplos abaixo. 
 
Errado 
 
principal ( ) 
{ 
real Raio, Altura, Base, Volume; 
escreva (“Raio da base : ”); 
leia ( Raio ); 
escreva (“Altura : ”); 
leia ( Altura ); 
Base ← 3,14159 * Raio ^ 2; 
Volume ← ( Base * Altura ) / 2; 
escreva (“Volume : ”, Volume); 
}; 
 
Correto 
 
principal ( ) 
{ 
 real Raio, Altura, Base, Volume;
 
 escreva (“Raio da base : ”); 
 leia ( Raio ); 
 escreva (“Altura : ”); 
 leia ( Altura ); 
 Base ← 3,14159 * Raio ^ 2; 
 Volume ← ( Base * Altura ) / 2; 
 escreva (“Volume : ”, Volume); 
}; 
 
9 Construção do Algoritmo – Observe os algoritmos 
apresentados nesse exemplo. Pôr enquanto, todo e qualquer 
algoritmo que você escrever em Português Estruturado 
deverá iniciar pela palavra chave “principal” seguida de 
parênteses, logo em seguida na próxima linha vem um 
indicador de início de bloco “{”. Nesse ponto devem ser 
 44
efetuadas as declarações de variáveis, observar a edentação. 
Após a declaração das variáveis deixe uma ou mais linhas 
em branco e inicie a escrita do pseudo código que irá 
constituir o algoritmo. 
Observe ainda que as instruções terminam com um ponto e 
virgula, esse é o separador padrão para a maioria das 
linguagens de programação e será adotado em nossa 
pseudo linguagem também. 
 
É hora de aplicar a teoria na prática. Inicie analisando os 
exemplos que seguem. 
Exemplo 1 
Suponha que você tem em suas mãos uma lata de leite em 
pó. Com base nos exemplos acima, escreva um algoritmo para 
calcular a quantidade aproximada de chapa em cm2 necessária 
para a confecção da respectiva lata. 
Entrada: 
1 Medidas do Raio da Base e da Altura da Lata, 
verificadas com uma régua 
Saída: 
1 Quantidade de chapa necessária à confecção da 
lata, essa quantidade é aproximadamente a mesma 
medida da área externa da lata: área lateral + 
fundo + tampa, considerando a lata de leite como 
tendo forma cilíndrica. 
 
 45
Algorítmo: 
Linguagem Natural 
1 Inicio 
2 Medir a altura da lata; 
3 Medir o raio da base ( fundo); 
4 Calcular a área da base ( AreaBase = π.Raio2 ); 
5 Calcular a área lateral ( AreaLateral = 
Altura.2.π.Raio ); 
6 Calcular a área externa 
( AreaExterna = AreaLateral + 2.AreaBase); 
7 Informar o valor de AreaExterna, como sendo a 
quantidade, aproximada, de chapa necessária à 
confecção da lata; 
8 Fim; 
 
Português Estruturado: 
 
 
 
 
 
 
 
 
principal ( ) 
{ 
 real Raio, Altura, AreaLateral, AreaBase, AreaExterna; 
 
 escreva (“Medida da altura da Lata : ”); 
 leia ( Altura ); 
 escreva (“Medida do Raio da Base : ”); 
 leia ( Raio ); 
 AreaBase ← 3,14 * Raio ^ 2; 
 AreaLateral ← Altura * 2 * 3,14 * Raio; 
 AreaExterna ← AreaLateral + 2 * AreaBase; 
 escreva (“Serão necessários ”, AreaExterna, “ cm2 chapa”); 
}; 
 46
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 3 - Quantidade de chapa para montar uma lata de leite em pó 
 
Neste algoritmo foi considerada a área externa da lata, 
como sendo a quantidade aproximada de chapa, necessária 
para a construção da lata. Não foram consideradas as perdas 
relativas ao recorte da tampa e do fundo. Se forem 
considerados os recortes, então a tampa e o fundo passam a ser 
quadrados de lado igual ao diâmetro da base da lata, assim 
AreaBase = (2R)2; 
Inicio
"Altura da Lata : "
H
"Raio da Base : "
R
AB = 3,14 * R ^ 2
AL = H * 2 * 3,14 * R
AExt = AL + 2*AB
"Serão Necessários",
AExt,"cm2 de chapa,
aproximadamente"
Fim
Passo 1 
Passo 2 
Passos 3, 4, 5 
Passo 6 
 47
Exemplo 2 
Agora escreva um algoritmo para calcular a capacidade da 
lata de leite em pó em cm3. 
Entrada: 
1 Medidas do raio e da altura da lata em cm; 
Saída: 
1 Volume da lata em cm3, V = Altura * AreaBase; 
 
Algorítmo: 
Linguagem Natural 
1 Início 
2 Medir a altura da lata; 
3 Medir o raio da base ( fundo); 
4 Calcular a área da base ( AreaBase = π.Raio2 ); 
5 Calcular o volume da lata ( Volume = Altura * 
AreaBase); 
6 Informar o volume calculado, como sendo o 
volume da lata; 
7 Fim; 
 48
Fluxograma: 
 
 
 
 
 
 
 
 
Fluxograma 4 Volume de uma lata de leite em pó 
 
Português Estruturado: 
principal ( ) 
{ 
 real Raio, Altura, AreaLateral, AreaBase, AreaExterna; 
 
 escreva (“Medida da altura da Lata : ”); 
 leia ( Altura ); 
 escreva (“Medida do Raio da Base : ”); 
 leia ( Raio ); 
 AreaBase ← 3,14 * Raio ^ 2; 
 Volume ← Altura * AreaBase; 
 escreva (“O volume é ”, volume, “ cm3 ”); 
}; 
 
Inicio
Altura, Raio
Base = 3,14 * R ^ 2
Volume = Altura * Base
"O volume é :",
Volume,"cm3 "
Fim
Passos 1, 2 
Passos 3, 4 
Passo 5 
 49
IV. Exercícios 
1) Os dois exemplos anteriores são a resolução dos dois 
primeiros exercícios do capítulo anterior. Agora, como 
você já fez os algoritmos para os demais exercícios, será 
fácil transcreve-los para o português estruturado, faça isso 
antes de prosseguir. 
2) Desenvolva um algoritmo para calcular a velocidade finalde um automóvel em MRUV (Movimento Retilíneo 
Uniformemente Variado). Os valores da aceleração, 
velocidade inicial e tempo só serão conhecidos no 
momento do teste. Em um MRUV a velocidade é dada pôr 
Vf = Vi + a.t 
3) Desenvolva um algoritmo para calcular o valor do salário 
líquido de um trabalhador horista. Sabe-se que o número 
de horas trabalhadas e o valor de cada hora variam de mês 
para mês. Sobre o salário bruto é feito um desconto de 
10% referente a contribuição para o INSS. 
4) Desenvolva um algoritmo para decompor um número em 
centenas, dezenas e unidades. Exemplo 2345 = 23 
centenas 4 dezenas e 5 unidades. Dica: use os operadores 
mod e div; 
 
 50
Capítulo V Estruturas de 
Seleção 
Os capítulos anteriores apresentaram como construir 
algoritmos simples e triviais, através deles você iniciou na arte 
da programação estruturada. A partir desse capítulo serão 
apresentadas novas técnicas e recursos para a especificação de 
algoritmos estruturados, com elas você poderá escrever 
algoritmos muito mais poderosos. 
O presente capítulo trata da tomada de decisões, como 
especificar a opção pôr uma entre duas possibilidades. São 
apresentadas as estruturas de seleção simples e compostas. 
Esteja certo de ter dominado os capítulos anteriores antes de 
prosseguir. 
V. 1 Estrutura de Seleção Simples 
Para melhor entender vamos pensar num caso simples: 
após calculada a média final de um acadêmico da disciplina de 
Lógica de Programação, deseja-se saber se ele está aprovado. 
Sabe-se que o mesmo estará aprovado se sua média for maior 
ou igual a 7,0 pontos. Note que será necessário tomar uma 
decisão baseada no fato da média final ser ou não superior a 7. 
 51
Nas linguagens de programação estruturada, existe uma 
estrutura de seleção para especificar que uma determinada 
instrução só será executada se a avaliação de uma certa 
condição lógica ( proposição lógica simples ou composta ) 
resultar em verdadeiro. Essa estrutura é conhecida como 
se...então....fim_se, é uma estrutura simples mas poderosa. 
V. 1.1 Fluxograma 
Em fluxogramas, a estrutura de seleção simples deverá 
sempre ser desenhada conforme mostrado abaixo. As 
instruções a serem executadas estão sempre subordinadas ao 
resultado “VERDADEIRO” da condição lógica testada. O 
resultado “FALSO” não possui instruções subordinadas. 
 
 
 
 
 
 
 
 
 
Fluxograma 5- A estrutura de seleção se...então...fim_se 
 
<condição>
<Instruções a serem executadas
se a condição possuir valor
lógico verdadeiro>
V
F
se 
fim_se 
então 
 52
V. 1.2 Português Estruturado 
A sintaxe básica para a estrutura de seleção simples em 
Português Estruturado pode ter duas variantes, tudo vai 
depender do número de instruções a serem executadas quando 
a avaliação da condição resultar no valor lógico verdadeiro: 
 
Com uma instrução apenas 
 
 
se < condição > então 
 
 < instrução > 
 
fim_se; 
 
Com mais de uma instrução 
 
se < condição > então 
{ 
 < instrução 1 > 
 < instrução 2 > 
 : 
 < instrução n > 
} 
fim_se; 
 
Observe que sempre que houver mais de uma instrução 
subordinada, será necessário inseri-las em um bloco iniciado 
com abre chaves “{” e finalizado com fecha chaves “}”. No 
caso de uma única instrução, o uso de chaves é opcional. 
Exemplo 1 
Retornando ao texto inicial: Sabe-se que o aluno estará 
aprovado se sua média for maior ou igual a 7,0 pontos. Note 
que o caso em questão é especificar uma situação que depende 
de uma sentença com valor lógico VERDADEIRO ou 
FALSO. 
 53
Entrada: 
1 Supondo um curso semestral com duas notas 
parciais, as entradas serão a primeira e a segunda 
nota parcial. 
Saída: 
1 A saída é a informação a respeito da aprovação. 
 
Algorítmo: 
Linguagem Natural 
1 Início 
2 Solicitar as duas notas parciais; 
3 Calcular a soma; 
4 Calcular a média ( MF = Soma / 2 ); 
5 Verificar a situação do acadêmico, e se aprovado 
apresentar uma mensagem indicando tal situação.; 
6 Fim; 
 
Fluxograma: 
 
 
 54
 
 
 
 
 
 
 
 
 
 
Fluxograma 6 - Verificando a aprovação do aluno 
Português Estruturado: 
 
Você deve estar se perguntando e se ele não obteve 
aprovação? Para poder expressar essa situação, é necessário 
ampliar a estrutura de seleção, de modo a incluir uma 
principal ( ) 
{ 
 real Nota1, Nota2, Soma, Media; 
 
 escreva (“1a Parcial : ”); 
 leia ( Nota1 ); 
 escreva(“2a Parcial; : ”); 
 leia ( Nota2 ); 
 Soma ← Nota1 + Nota2; 
 Media ← Soma / 2; 
 se ( Media ≥ 7,0 ) então 
 escreva(“Aprovado”) 
 fim_se; 
}; 
 
Media >= 7
Inicio
"1a e 2a Parcial : "
N1 , N2
Soma = N1 + N2
Media = Soma / 2
"Aprovado"
Fim
V
F
 55
instrução que será executada quando a avaliação da condição 
lógica resultar FALSO. 
V. 2 Estrutura de Seleção Composta 
A estrutura de seleção composta permite especificar a 
necessidade de optar-se pôr uma entre duas situações distintas. 
No exemplo inicial, o algoritmo informa a mensagem 
“Aprovado” quando a média obtida é maior ou igual a 7 
pontos. No entanto queremos agora incluir a mensagem 
“Reprovado” que deverá ser apresentada quando a média 
obtida for menor que 7 pontos. Uma solução possível, seria a 
inclusão de mais uma estrutura de seleção simples, veja 
abaixo. 
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 7 - Verificando se o aluno está “Aprovado” ou “Reprovado”. 
Início
"1a e 2a Parcial"
N1, N2
Soma = N1+N2
Media = Soma / 2
Media >= 7
"Aprovado"
V
F
Media < 7
"Reprovado"
V
F
Fim
 56
Português Estruturado: 
 
 
Embora essa seja uma solução eficaz, não é a mais 
recomendada, num caso como esse podemos lançar mão de 
uma estrutura de seleção composta, a qual além de ser tornar o 
algoritmo menor, aumenta também a sua legibilidade do 
mesmo. 
Uma estrutura de seleção composta difere da estrutura de 
seleção simples, apenas no fato de que ela possui instruções 
subordinadas ao resultado FALSO quando do teste da 
condição lógica. 
V. 2.1 Fluxograma 
A estrutura de seleção composta especifica uma decisão 
tomada segundo o valor de uma proposição lógica 
principal ( ) 
{ 
 real Nota1, Nota2, Soma, Media; 
 
 escreva (“1a Parcial : ”); 
 leia ( Nota1 ); 
 escreva(“2a Parcial; : ”); 
 leia ( Nota2 ); 
 Soma ← Nota1 + Nota2; 
 Media ← Soma / 2; 
 se ( Media ≥ 7,0 ) então 
 escreva (“Aprovado”); 
 fim_se; 
 se ( Media < 7,0 ) então 
 escreva (“Reprovado”); 
 fim_se; 
}; 
 
 57
“<condição>”. Se a avaliação dessa proposição resultar 
verdadeiro, então as instruções a serem executadas são aquelas 
descritas no ramo identificado com a letra V – 
VERDADEIRO, caso contrário “senão” devem ser executadas 
as instruções descritas no ramo identificado com a letra F – 
FALSO. 
 
 
 
 
 
 
 
 
 
 
Fluxograma 8 - Estrutura de seleção composta se...então....senão...fim_se 
Pode-se dizer que a estrutura de seleção simples é um caso 
especial da estrutura composta, onde não foram descritas 
instruções a serem executadas quando a avaliação da condição 
resultar FALSO. 
V. 2.2 Português Estruturado 
A transformação de uma estrutura de seleção simples em 
uma composta, dá-se pura e simplesmente pela adição da 
clausula “senão”, como ilustrado a seguir. 
<condição> V
F
<Instruções a serem
executadas se a condição
possuir valor lógico
verdadeiro>
<Instruções a serem
executadas se a condição
possuir valor lógico
falso>
F
então
se
fim se
senão 
 58
Com uma instrução 
 
se < condição > então 
 < instrução >; 
senão 
 < instrução >; 
fim_se; 
Com mais de uma instruçãose < condição > então 
{ 
 < instruções >; 
} 
senão 
{ 
 < instruções >; 
} 
fim_se;
 
O exemplo 1 pode agora ser modificado, de modo que com 
apenas uma estrutura de seleção, será possível especificar as 
duas situações. Veja a seguir. 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 9 - Verificando a aprovação ou não do aluno 
Media >= 7
Inicio
"1a e 2a Parcial : "
N1, N2
Soma = N1 + N2
Media = Soma / 2
"Aprovado"
Fim
"Reprovado"
VF
principal ( ) 
{ 
 real Nota1, Nota2; 
 real Soma, Media; 
 
 escreva (“1a Parcial : ”); 
 leia ( Nota1 ); 
 escreva(“2a Parcial; : ”); 
 leia ( Nota2 ); 
 Soma ← Nota1 + Nota2; 
 Media ← Soma / 2; 
 se ( Media ≥ 7,0 ) então 
 escreva (“Aprovado”) 
 senão 
 escreva (“Reprovado”); 
 fim_se; 
 59
Apenas recapitulando, observe que quando se tem mais de 
uma instrução em cada clausula, é necessária a inclusão destas 
em um bloco delimitado por “{” e “}”. 
Para ampliar o exemplo, pensemos agora que a atual 
legislação, especifica que todo aluno com índice de freqüência 
inferior a 75% estará automaticamente reprovado. Vamos 
incluir essa condição em nosso algoritmo, fazendo uso de um 
operador lógico “e”. Analise o Fluxograma 10 e depois 
transcreva-o para o Português Estruturado. 
Observe que mesmo que o aluno tenha média maior ou 
igual a 7, estará reprovado se não atingir o percentual de 75 % 
de freqüência. Note também que o operador “e”, resolve sem a 
necessidade de acrescentar mais uma estrutura de seleção. 
 
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
Fluxograma 10 - Verificando a aprovação do aluno ( média e freqüência) 
Media >= 7
e
 Freq >= 75%
Inicio
N1, N2, Freq
Soma = N1 + N2
Media = Soma / 2
"Aprovado"
Fim
"Reprovado"
VF
 60
V. 3 Estruturas de Seleção Aninhadas 
Dizemos que uma estrutura está aninhada, quando a mesma 
é interna a outra, ou seja, a estrutura aparece como uma 
instrução pertencente a um dos ramos de outra estrutura. 
Para melhor entender, considere novamente o exemplo da 
verificação da aprovação do aluno. Vamos incluir duas novas 
proposições: 1- Se o aluno com freqüência igual ou superior a 
75%, não obtiver média suficiente para a aprovação, ele 
poderá pleitear um exame. 2- Só poderão pleitear exame, os 
alunos com freqüência igual ou superior a 75% e média não 
inferior a 4 pontos. Agora nosso problema requer três 
mensagens, a saber: “Aprovado”, “Exame” e “Reprovado”. 
 
Linguagem Natural 
1 Início 
2 Solicitar as duas notas parciais e o percentual de 
freqüência; 
3 Calcular a soma; 
4 Calcular a média ( MF = Soma / 2 ); 
5 Verificar a situação do acadêmico, 
a. se aprovado (Média >=7 e Freqüência >= 75%) 
apresentar a mensagem “Aprovado”; 
b. senão está aprovado, verificar se está reprovado 
(Média <4 ou freqüência < 75%); 
i. se reprovado apresentar a mensagem 
“reprovado”; 
 61
ii. caso contrário, apresentar a mensagem 
“exame”; 
6 fim; 
 
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 11 Verificação da situação de um aluno (aprovado, 
reprovado, exame) 
Obs: Cada estrutura de seleção deve ter seus ramos 
conectados após as instruções, marcando assim o final da 
instrução. Esse conector, em Português Estruturado, é 
representado pela palavra chave fim_se. 
Media >= 7
e
 Freq >= 75%
Inicio
N1, N2, Freq
Soma = N1 + N2
Media = Soma / 2
"Aprovado"
Fim
"Reprovado"
Media < 4
ou
Freq < 75%
"Exame"
VF
VF
Estrutura 
A i h d
Estrutura mãe 
fim_se 
fim_se
 62
A transcrição do fluxograma para o Português Estruturado 
é simples e fácil. Analise o pseudo código a seguir, 
comparando-o com o fluxograma. Para verificar a consistência 
do algoritmo. 1- Considere o conjunto de possibilidades 
(Notas e Freq); 2- execute mentalmente as operações descritas 
verificando se o resultado obtido é correto. 
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Exemplo 1 
Considere três valores A,B,C como sendo o comprimento 
dos lados de um triângulo. Verificar se é realmente possível a 
Principal ( ) 
{ 
 real N1, N2, Soma, Media, Freq; 
 
 escreva (“1a Parcial: ); 
 leia ( N1); 
 escreva (“2a Parcial: ); 
 leia ( N2); 
 escreva (“% Freqüência :”); 
 leia ( Freq ); 
 Soma ← N1 + N2; 
 Media ← Soma / 2; 
 se ( Media ≥ 7 e Freq ≥ 75) então 
 escreva(“Aprovado”); 
 senão 
 se ( Media < 4 ou Freq < 75 ) então 
 escreva (“Reprovado”); 
 senão 
 escreva (“Exame”); 
 fim_se; 
 fim_se; 
}; 
 63
construção de um triângulo com esses valores. Se a construção 
do triângulo for possível, verificar o tipo do mesmo: 
Eqüilátero, Escaleno ou Isósceles 
Entrada: 
1 Os comprimentos dos lados de um triângulo 
A,B,C. 
Saída: 
1 Confirmação ou não da possibilidade de ser um 
triângulo possível. Em caso afirmativo, a 
classificação do mesmo. 
Algorítmo: 
Linguagem Natural 
1 Ler os três valores (As medidas de cada um dos 
lados); 
2 Verificar a possibilidade de construção de um 
triângulo com tais valores, para tal sabe-se que um 
triângulo só é possível quando a soma de 
quaisquer dois de seus lados é sempre maior que o 
terceiro; 
3 Se a construção do triângulo for possível, então 
verificar o tipo do mesmo (Equilátero –Três lados 
iguais, Isósceles – Dois lados iguais, escaleno – 
Os três lados diferentes ); 
 
 64
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 12 Verificando a possibilidade de construção de um triângulo 
e sua respectiva classificação. 
 
 
Inicio
A, B, C
(A+B) > C
e (A+C) > B e
(B+C) > A
A = B e B = C
A = B
ou B = C ou
 A = C
"Impossível"
"Equilátero"
"Isóceles""Escaleno"
Fim
v
F
v
v
F
F
fim_se 
 65
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Exemplo 2 
Em um determinado país, é utilizada a tabela abaixo para 
fins de cálculo do imposto de renda a pagar. 
Ganhos Alíquota 
Até 1.200,00 1% 
De 1.200,01 até 2.000,00 10% 
De 2.000,01 até 3.000,00 15% 
De 3.000,01 acima 20% 
principal ( ) 
{ 
 real A, B, C; 
 
 escreva ( “Lado A: ” ); 
 leia ( A ); 
 escreva ( “Lado B: ” ); 
 leia ( B ); 
 escreva ( “Lado C: ” ); 
 leia ( C ); 
 se ( (A + B > C) e (A + C > B) e (B + C > A) ) então 
 se ( ( A = B )e( B = C ) ) então 
 escreva (“Equilátero”); 
 senão 
 se ( ( A=B ) ou ( A=C ) ou ( B=C ) ) então 
 escreva (“Isósceles”); 
 senão 
 escreva (“Qualquer”); 
 fim_se; 
 fim_se; 
 senão 
 escreva (“Não é triângulo”); 
 fim_se; 
}; 
 66
Montar um fluxograma para resolver o problema de calculo 
do valor do imposto a ser recolhido pôr um cidadão desse 
país, depois escrever o respectivo algoritmo em Português 
Estruturado. 
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 13 - Cálculo da alíquota do Imposto de Renda 
 
Inicio
Ganhos
Ganhos > 1.200,00
Ganhos > 2.000,00
Ganhos > 3.000,00
IR = Ganhos * 1%
IR = Ganhos * 10%
IR = Ganhos * 15% IR = Ganhos * 20%
F V
F V
F V
Fim
"IR a pagar : ",IR
 67
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
principal ( ) 
{ 
 real Ganhos, IR; 
 
 escreva (“Ganhos: ”); 
 leia ( Ganhos ); 
 se ( Ganhos ≤ 1.200,00 ) então 
 IR ← Ganhos /100; 
 senão 
 se (Ganhos ≤ 2.000,00 ) então 
 IR ← (Ganhos * 10)/100; 
 senão 
 se ( Ganhos ≤ 3.000,00 ) então 
 IR ← (Ganhos * 15)/100; 
 senão 
 IR ← (Ganhos * 20)/100; 
 fim_se; 
 fim_se; 
 fim_se; 
 escreva(“IR a pagar: ”, IR); 
}; 
 68
Nos exercícios abaixo, você deve primeiro ler atentamente 
o enunciado e indicar as entradas e as saídas para então 
escrever o algoritmo na forma de passos, usando a linguagem 
natural. Depois monte o fluxograma e pôr ultimo o português 
estruturado. 
1) Desenvolva um algoritmo que solicite três valores 
numéricos, calcule e apresente qual é o menor; 
2) Desenvolva um algoritmo, que dado um número inteiro 
positivo qualquer, apresente como resposta uma das 
seguintes mensagens: 
a) “CASAL” → em se tratando de número par; 
b) “VELA” → em se tratando de número impar; 
c) “INVÁLIDO” → para números menores ou iguais a 
zero; 
Obs: Para saber se o número é par ou impar, use o 
operador mod; 
3) Desenvolva um algoritmo que solicite ao usuário o nome e 
o sexo de uma pessoa e a partir dessas informações, 
apresente a mensagem “Ilmo Senhor” ou “Ilma Senhora” 
conforme o caso, e em seguida do nome da pessoa. O sexo 
deverá constar de “M” ou “m” para masculino e “F” ou “f” 
para feminino, quaisquer outras letras deverão causar a 
apresentação da mensagem “Erro”. 
 69
4) Desenvolver um algoritmo para a ordenação crescente de 
três valores inteiros quaisquer. O algoritmo deve solicitar 
os valores, ordenar e apresentá-los na forma ordenada. 
5) Desenvolva um algoritmo que, a partir do sexo e da altura 
de uma pessoa, calcule e apresente o seu peso ideal. Use as 
formulas: 
a) Para homens ( 72.7 * h ) – 59; 
b) Para mulheres ( 62.1 * h ) – 45; 
6) Desenvolva um algoritmo para calculo das raízes de uma 
equação do 2oGrau, na forma Ax2 + Bx + C = 0. Observar 
que nem sempre uma equação dessa natureza possui raízes 
reais. 
7) Desenvolva um algoritmo que a partir da idade de um 
jogador de futebol faça e apresente a classificação de sua 
categoria. 
Idade em anos Classe
5 a 8 Infantil 
9 a 12 Infanto – Juvenil 
13 a 18 Juvenil 
19 a 35 Amador 
acima de 35 Amador Sênior 
8) Uma empresa produz vários produtos. Cada produto tem 
uma tarifação de ICMS diferente. Desenvolva um 
algoritmo que a partir do valor de uma venda e do código 
do respectivo de tarifação do produto, calcule e apresente 
o valor do ICMS a recolher. 
 70
Código Tarifação
1 17 % 
3, 5 e 7 12 % 
4 e 8 9 % 
10 25 % 
Outro “Código Invalido” 
9) Desenvolva um algoritmo que tenha como entradas: dois 
valores numéricos reais e um símbolo representando a 
operação desejada. O algoritmo deverá efetuar a operação 
solicitada e apresentar o respectivo resultado. 
Símbolo Operação
+ Adição 
- Subtração 
* Multiplicação 
/ Divisão 
10) Para se determinar o número de luminárias necessárias 
para a iluminação de cada cômodo de uma casa, é utilizada 
uma tabela que fornece a potência mínima em Watts pôr 
metro quadrado. Desenvolva um algoritmo que a partir da 
potência das luminárias a serem utilizadas, das medidas do 
cômodo e da sua classificação, calcule e apresente: 
a) A área do cômodo; 
b) A potência total necessária; 
c) O número mínimo de luminárias; 
Cômodo Classe Potência (w/m2) 
Quarto 1 14 
Sala de TV 2 10 
 71
Sala 3 20 
Cozinha 4 22 
Escritório 5 25 
Banheiro 6 18 
Áreas de Lazer 10 15 
 
 72
Estrutura de Seleção Múltipla 
Quando um problema se apresenta de tal forma que se faz 
necessário efetuar uma escolha entre várias possibilidades, 
aninhar estruturas tipo se...então...senão.... pode vir a ser 
extremamente trabalhos. Considere pôr exemplo, um 
algoritmo que a partir de um número entre 1 e 7, apresente 
qual é o nome do respectivo dia da semana. Sua construção 
com estruturas aninhadas requer 6 níveis. Veja abaixo. 
 
Entrada: 
1 Um número de 1 a 7 representando o dia da 
semana 
Saída: 
1 O nome do dia da semana ( 1 = Segunda-feira, 2 = 
Terça-feira, 3 = Quarta-feira, 4 = Quinta-feira, 5 = 
Sexta-feira, 6 = Sábado, 7 = Domingo) 
Algorítmo: 
Linguagem Natural 
1 Solicitar o número que representa o dia; 
2 Verificar se é um dia válido de 1 até 7, se não for 
apresentar mensagem de erro e terminar; 
3 Caso seja um dia válido, verificar e apresentar o 
seu respectivo nome conforme descrito acima; 
4 Fim; 
5 
 73
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 14 - Verificando o nome do dia da semana 
 
Dia ≥ 1 e Dia ≤ 7
"Dia Inválido"
Dia=1
"Seg-Feira" Dia=2
Dia=3
Dia=4
Dia=5
Dia=6
V
"Terc-Feira"
"Qua-Feira"
"Qui-Feira"
"Sex-Feira"
"Sábado" "Domingo"
V
V
V
V
V F
F
F
F
F
V
Fim
Dia
"Dia (1 a 7):"
Início
F
F
 74
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Agora imagine uma situação em que ocorram muito mais 
opções. O aninhamento sucessivo de estruturas se...então... 
principal ( ) 
{ 
 inteiro NumDia; 
 
 escreva (“Dia (1 a 7 ): ”); 
 leia ( NumDia ); 
 se ( NumDia ≥ 1 e NumDia ≤ 7 ) então 
 se ( NumDia = 1 ) então 
 escreva (“Segunda - Feira”); 
 senão 
 se ( NumDia = 2 ) então 
 escreva (“Terça - Feira”); 
 senão 
 se ( NumDia = 3 ) então 
 escreva (“Quarta - Feira”); 
 senão 
 se ( NumDia = 4 ) então 
 escreva (“Quinta - Feira”); 
 senão 
 se ( NumDia = 5 ) então 
 escreva (“Sexta - Feira”); 
 senão 
 se ( NumDia = 6 ) então 
 escreva (“Sábado”); 
 senão 
 escreva (“Domingo”); 
 fim_se; 
 fim_se; 
 fim_se; 
 fim_se; 
 fim_se; 
 fim_se; 
 senão 
 escreva (“Dia inválido”); 
 fim_se; 
}; 
 75
torna-se impraticável. Felizmente pode-se lançar mão de uma 
estrutura especialmente desenvolvida para esses casos, a 
estrutura de seleção múltipla caso...seja. 
A estrutura caso...seja, estabelece a comparação de um 
valor dado (inteiro ou caracter) com cada uma das opções 
expressas, ao encontrar uma que seja igual, serão executadas 
as instruções especificadas em seu respectivo bloco. 
Não há limite para o número de opções, e cada opção pode 
conter de mais de um valor, sendo estes expressos 
seqüencialmente e separados pôr vírgula. Também é permitido 
especificar intervalos. Um intervalo é expresso indicando-se o 
início e o fim do mesmo, separados pôr dois pontos lineares. 
Caso não haja nenhuma opção que case com o valor dado, 
serão executadas as instruções especificadas no bloco de 
instruções padrão. 
Importante observar que essa estrutura trabalha apenas com 
igualdade, não sendo possível expressar casos tais como X ≥ 
6. Outra restrição importante esta no fato de que a variável a 
ser comparada deve ser do tipo inteiro ou do tipo caracter. 
 
 76
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 15 - Estrutura de seleção múltipla - caso .. seja 
Valor a ser 
Comparado
Valor das 
Opções 
Instruções para 
o caso de não 
ter a opção 
<?>
Instruções
Instruções
Intruções
:
:
Instruções
Op 1
Op 2
Op N
 77
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
O objeto de comparação é o valor da variável expressa no 
início da estrutura. Essa variável deve obrigatoriamente ser de 
um tipo enumerado (inteiro ou caracter). Seu valor deverá ser 
comparado seqüencialmente, de cima para baixo, com todos 
os valores ou intervalos de cada opção, havendo uma 
igualdade, devem ser executadas as instruções especificadas 
na opção. 
O comando pare marca o fim de uma opção e determina 
que a próxima instrução a ser executada é a primeira após o 
fim da estrutura, não havendo o comando pare a execução 
prossegue linearmente. 
A clausula não_seja indica quais instruções devem ser 
executadas, caso o valor da variável nãoseja igual a nenhum 
dos valores especificados nas opções. 
caso (< Variável >) seja 
{ 
 < valor(es) ou intervalo(s) > : 
 < instruções > 
 pare; 
 < valor(es) ou intervalo(s) > : 
 < instruções > 
 pare; 
 : 
 : 
 < valor(es) ou intervalo(s) > : 
 < instruções > 
 pare; 
 
 não_seja 
 < instruções > 
};
 78
Exemplo 1 
A partir de um número fornecido pelo usuário, informar 
qual é o dia da semana. Se o respectivo número for menor que 
1-Segunda-feira ou for maior que 7-Domingo, deverá ser 
mostrada uma mensagem de erro. 
Entrada: 
1 Um número de um a sete; 
Saída: 
1 O dia da semana, ou uma mensagem de erro; 
 
Algorítmo: 
Linguagem Natural 
1 Início 
2 Ler o número para o dia da semana; 
3 Determinar se é: 
a. 1 - Segunda-feira; 
b. 2 - Terça-feira; 
c. 3 - Quarta-feira; 
d. 4 - Quinta-feira; 
e. 5 - Sexta-feira; 
f. 6 - Sábado; 
g. 7 - Domingo; 
h. outro valor – “Erro” – Dia inválido; 
4 Fim; 
 79
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 16 - Determinando o nome do dia da semana com a estrutura 
caso..seja 
Dia
1
2
Dia
Início
3
4
5
6
7
Fim
"Segunda - Feira"
"Terça - Feira"
"Quarta - Feira"
"Quinta - Feira"
"Sexta - Feira"
 "Sábado"
"Domingo"
"Dia Inválido"
 80
 
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Exemplo 2 
Dado um número maior ou igual a zero, dizer se é: unidade, 
dezena, centena ou milhar. Números negativos e números 
maiores que 10.000, devem gerar uma mensagem de erro. 
 
principal ( ) 
{ 
 inteiro Dia; 
 
 escreva (“ Dia: ”); 
 leia ( Dia ); 
 caso ( Dia ) seja 
 { 
 1: escreva ( “Segunda-feira” ); 
 pare; 
 2: escreva ( “Terça-feira” ); 
 pare; 
 3: escreva ( “Quarta-feira” ); 
 pare; 
 4: escreva ( “Quinta-feira” ); 
 pare; 
 5: escreva ( “Sexta-feira” ); 
 pare; 
 6: escreva ( “Sábado” ); 
 pare; 
 7: escreva ( “Domingo” ); 
 pare; 
 
 não_seja 
 escreva ( “Dia Inválido”); 
 }; 
}; 
 81
Entrada: 
1 Um número inteiro; 
Saída: 
1 Classificação do número em: 
a. Unidade; 
b. Dezena; 
c. Centena; 
d. Milhar; 
2 Mensagem de erro; 
 
Algorítmo: 
Linguagem Natural 
1 Início; 
2 Solicitar/ler um número inteiro; 
3 Classificar o número, segundo as seguintes 
opções: 
a. De 0 até 9 → Unidade; 
b. De 10 até 99 → Dezena; 
c. De 100 até 999 → centena; 
d. De 1.000 até 9.999 → milhar; 
e. Caso contrário → Erro; 
4 Fim; 
 82
Obs: Nesse caso é necessário especificar um intervalo de 
valores. Algumas linguagens, C por exemplo, não permitem a 
especificação de intervalos numa estrutura de seleção 
múltipla. Já em Pascal isso é perfeitamente possível. Em 
linguagens que não suportam intervalos usa-se uma seqüência 
de se...então...senão... encadeados. 
Fluxograma: Português Estruturado 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 17 - Escolhendo entre - Unidades, Dezena, Centena e milhar 
Num
0..9
10..99
Num
Início
100..999
1000..9999
Fim
"Unidade"
"Dezena"
"Centena"
"Milhar"
"Erro"
principal ( ) 
{ 
 inteiro Num; 
 
 escreva (“Número: ”); 
 leia ( Num ); 
 caso ( Num ) seja 
 { 
 0..9: 
 escreva (“Unidade”); 
 pare; 
 10..99: 
 escreva (“Dezena”); 
 pare; 
 100..999: 
 escreva (“Centena”); 
 pare; 
 1000..9999: 
 escreva (“Milhar”); 
 pare; 
 não_seja: 
 escreva (“Erro”); 
 }; 
}; 
 83
O mesmo resultado, obtido com uma seqüência de 
se...entao..senao encadeados 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
V. Exercícios 
1) Refazer os exercícios 7,8,9,10 fazendo uso da estrutura de 
seleção múltipla caso...seja. 
2) Solicitar o mês e o ano, calcular e apresentar o número de 
dias que o mês tem. Dica, O anos bissextos são múltiplos 
de 4. 
principal ( ) 
{ 
 inteiro Num; 
 
 escreva (“Número: ”); 
 leia ( Num ); 
 se ( Num < 0 ou Num > 9999 ) então 
 escreva(“Erro”); 
 senão 
 se (Num < 9 ) então 
 escreva (“Unidade”); 
 senão 
 se (Num < 99 ) então 
 escreva (“Dezena”); 
 senão 
 se (Num < 999 ) então 
 escreva (“Centena”); 
 senão 
 escreva (“Milhar”); 
 fim_se; 
 fim_se; 
 fim_se; 
 fim_se; 
}; 
 84
Capítulo VI Estruturas de 
Repetição 
Em muitos casos, o algoritmo solução para uma 
determinada classe de problemas, apresenta uma seqüência de 
instruções que devem ser executadas repetidas vezes para que 
o resultado desejado seja produzido. 
Escrever as mesmas instruções repetidas vezes, é 
extremamente improdutivo e em muitos casos impossível. As 
linguagens de programação estruturada definem três estruturas 
de repetição – enquanto <condição> faça, faça <instruções> 
enquanto <condição> e para <indexadores, condição, 
incrementos> faça – essas estruturas de repetição possuem 
uma condição lógica que é avaliada a cada nova interação e 
que define o ponto de parada, ou seja, a interrupção do laço. 
Essas estruturas são o objeto de trabalho deste capitulo. 
VI. 1 A Estrutura faça....enquanto 
Diferentemente da maioria dos livros de lógica de 
programação, não iniciarei pela estrutura enquanto....faça. A 
opção pôr iniciar pela instrução faça...enquanto, reside na 
 85
observação, em sala de aula, de que a lógica inclusa nessa 
estrutura é melhor entendida e compreendida pelos alunos. 
A estrutura faça...enquanto, trabalha da seguinte forma: as 
instruções em seu interior são executadas uma vez, então a 
condição lógica é avaliada, se for verdadeira a execução das 
instruções internas será repetida e a condição novamente 
avaliada, esse processo se repete enquanto a condição for 
avaliada com valor lógico (resultado) VERDADEIRO. No 
momento em que a avaliação da condição resultar em FALSO, 
ocorrerá a ruptura do laço e a execução passará para a 
instrução seguinte. 
Veja abaixo a forma como representar essa estrutura em um 
fluxograma e em português estruturado. 
VI. 1.1 Sintaxe Básica 
Observe a representação abaixo, um pequeno circulo indica 
o início da estrutura. Logo abaixo devem ser especificadas as 
instruções a serem repetidas, essas instruções podem constar 
de entradas/saídas, processamento e/ou outras estruturas. Após 
as instruções, vem a condição lógica que determinará a 
interrupção do laço. 
 
 86
 
 
 
 
 
 
 
 
 
Fluxograma 18 – Sintaxe da estrutura de repetição faça ... enquanto 
Exemplo 1 
Contar de zero até dez, de 1 em 1. 
Entrada: 
1 Não há entrada de dados; 
Saída: 
1 Seqüência de números inteiros, de zero até 10; 
Algorítmo: 
Linguagem Natural 
1 Iniciar um contador em zero; 
2 Mostrar o valor do contador; 
3 Incrementar o contador em um; 
Com uma instrução para repetir 
 
faça 
<instrução a ser executada uma ou 
mais vezes > 
enquanto <condição>; 
 
 
Com várias instruções para repetir 
 
faça 
{ 
<instruções a serem executadas uma 
ou mais vezes > 
} enquanto <condição>; 
<condição>
<Instruções a serem
executadas uma ou mais
vezes>V
F
 87
4 Enquanto o contador for menor ou igual a 10 
voltar ao passo 2, caso contrário prossiga; 
 
Fluxograma Português Estruturado 
 
 
 
 
 
 
 
 
 
Fluxograma 19 - Contando de zero a dez com a estrutura faça..enquanto 
Exemplo 2 
Monte um algoritmo (fluxograma e português estruturado) 
para o seguinte problema. Ler um número N, entre 0 e 10 
descartando qualquer valor fora desse intervalo. Apresentar atabuada do número N, no formato exemplificado: 
 
 
 
 
2 * 0 = 0
2 * 1 = 2 
2 * 2 = 4 
2 * 3 = 6 
: 
: 
2 * 10 = 20 
 
principal ( ) 
{ 
 inteiro Cont; 
 
 Cont ← 0; 
 faça 
 { 
 escreva ( Cont ); 
 Cont ← Cont + 1; 
 } enquanto ( Cont ≤ 10); 
}; 
Cont <= 10
Cont = Cont + 1
Inicio
Cont = 0
Cont
Fim
F
v
 88
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 20 - Calculando e apresentando a tabuada de um número qualquer 
entre 0 e 10. 
 
Exemplo 3 
Calcular o valor de ݔ ൌ ∑ ଵ
௡
ଶ଴
௡ୀଵ ou seja ݔ ൌ
ଵ
ଵ
,
ଵ
ଶ
, … ,
ଵ
௡
, … ,
ଵ
ଶ଴
 
 
Entrada: 
1 Não tem; 
Saída: 
principal ( ) 
{ 
 inteiro N, Cont, Tot; 
 
 escreva (“Tabuada do: ”); 
 faça 
 leia ( N ); 
 enquanto ( (N < 0) ou (N > 10)); 
 
 Cont ← 0; 
 
 faça 
 { 
 Tot ← N * Cont; 
 escreva (N, “ * ”, Cont, “ = ”, Tot); 
 Cont ← Cont + 1; 
 } enquanto ( N < 11); 
};
Inicio
N
N < 0 ou N > 10
V
Cont = 0
Tot = N * Cont
N," * ",Cont," = ", Tot
Cont = Cont + 1
N < 11
V
Fim
 89
1 O valor de x, calculado segundo o somatório dado; 
Fluxograma: Português 
estruturado 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 21 - Calculando um somatório 
Exemplo 4 
Calcular todos os divisores inteiros ( positivos ) de um 
número N qualquer. 
Entrada: 
1 Um número qualquer N – inteiro; 
Saída: 
1 A lista de todos os divisores ( positivos ) de N 
Início
Fim
x <-- 1
n <-- 2
x <-- x+1/n
n <-- n+1
N <= 20
R
"X = ",x
F
principal( ) 
{ 
 inteiro N; 
 real X; 
 
 X ← 1; 
 N ← 2; 
 faça 
 { 
 X ← X + 1/N; 
 N ← N + 1; 
 } 
 enquanto ( N ≤ 20 ); 
 escreva (“X = ”, X); 
}; 
 90
Fluxograma: Português Estruturado 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 22 - Calculando os divisores de um número qualquer inteiro 
Exemplo 5 
Ler uma seqüência de números inteiros positivos, calcular e 
apresentar a média. O final da seqüência é marcado por um 
valor negativo. 
Entrada: 
1 Uma seqüência de números inteiros positivos, um 
número negativo, marca o fim da seqüência. 
principal ( ) 
{ 
 inteiro N, i; 
 
 escreva (“Valor de N:”); 
 leia ( N ); 
 i ← 1; 
 escreva (“Os divisores são:”); 
 faça 
 { 
 se ( (N mod i) = 0) então 
 escreva ( i ); 
 fim_se; 
 } 
 enquanto ( i ≤ N); 
}; 
Início
N
i <-- 1
(N mod i ) = 0
i
i <-- i + 1
i <= N
Fim
v
F
R
F
 91
Saída: 
1 A média dentre todos os valores positivos da 
seqüência. 
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 23 - Calculando a média de uma seqüência de números 
inteiros positivos 
Início
Cont <-- 0
Soma <-- 0
N <-- 0
N > 0
 N > 0
Fim
v
F
Soma <-- Soma + N
Cont <-- Cont + 1
N
F
R
Cont > 0
Media <-- Soma/ContMedia <-- 0
"Media ", Media
VF
 92
Português Estruturado: 
 
principal ( ) 
{ 
 inteiro N, Cont, Soma; 
 real Media; 
 
 Cont ← 0; 
 Soma ← 0; 
 N ← 0; 
 escreva(“Digite uma Seqüência:”); 
 faça 
 { 
 se (N > 0) então 
 { 
 Soma ← Soma + N; 
 Cont ← Cont + 1; 
 } fim_se; 
 leia ( N ); 
 } enquanto ( N>0 ); 
 se (nCont > 0) então 
 Media ← Soma / Cont; 
 Senão 
 Media ← 0; 
 fim_se; 
 escreva(“Média: ”, Media); 
}; 
 
 
VI. Exercícios 
Para cada um dos exercícios abaixo, monte o algoritmo 
primeiro em fluxograma, depois transcreva-o para o português 
estruturado. 
1) Desenvolva um algoritmo que para apresentar no vídeo 
todos os números pares múltiplos de 4 compreendidos 
 93
entre 1 e 500. O algoritmo deverá testar todos os números 
do intervalo. Dica: usar o operador mod. 
2) Desenvolva um algoritmo para verificar se um número 
inteiro positivo é ou não primo. Lembre-se que um 
número é dito primo quando é divisível apenas pôr um e 
pôr ele mesmo. 
3) Desenvolva um algoritmo para calcular o fatorial de um 
número inteiro positivo, fornecido pelo usuário. Números 
negativos deverão gerar uma mensagem de erro. 
4) Desenvolva um algoritmo para calcular e apresentar o 
valor de π com precisão de 0,001, usando a série: 
π = 4 – 4/3 + 4/5 – 4/7 + 4/9 – 4/11 +.... 
Para obter a precisão desejada, devemos 
adicionar/subtrair apenas os termos cujo valor absoluto 
seja maior ou igual a 0,001 pois dessa forma a diferença 
entre o valor atual e o novo valor produzido será menor 
que 0,001 ou seja o erro máximo admitido. Dica abs(x) 
retorna o valor absoluto de x. 
5) Para uma turma de 50 alunos, ler as quatro notas 
bimestrais de cada aluno, calcular e apresentar a média, 
seguida de uma das seguintes mensagens: 
a) “Parabéns” se aprovado com média maior que 8 
pontos; 
b) “Aprovado” se a média for maior ou igual a 7,0, mas 
menor que 8,0 pontos; 
 94
c) “Exame” se a média for menor que 7,0, mas igual ou 
superior a 4,0 pontos; 
d) “Reprovado” se a média for inferior a 4,0 pontos; 
6) Desenvolva um algoritmo para calcular a média de idade 
em anos de um grupo de indivíduos. O número de 
indivíduos no grupo é desconhecido, sendo que uma idade 
menor ou igual a zero marca o fim das entradas. 
7) Tem-se um conjunto de dados contendo o nome, a altura e 
o sexo (Masculino – M , Feminino – F) de um grupo de 50 
pessoas. Desenvolva um algoritmo que calcule e apresente 
as seguintes informações: 
a) O nome, o sexo e altura da pessoa mais baixa; 
b) A média de altura das mulheres; 
c) O número de homens; 
8) A uma temperatura de 50oC, um determinado líquido 
evapora 1% de seu volume a cada segundo. Desenvolva 
um algoritmo que a partir do volume inicial, calcule e 
apresente o tempo necessário para que o volume se torne 
inferior a 0,1 mililitro. O tempo deve ser apresentado em 
Horas, minutos e segundos. 
9) A diretoria de uma empresa de mensagens por telefone, 
encomendou uma pesquisa para saber se os seus clientes 
estão ou não satisfeitos com os serviços prestados. 
Desenvolva um algoritmo que calcule e apresente os 
 95
resultados abaixo, sabendo que foram entrevistados 50 
clientes sorteados ao acaso. 
a) O número de clientes que responderam sim; 
b) O número de clientes que responderam não; 
c) A porcentagem de clientes do sexo masculino que se 
dizem satisfeitos; 
d) A porcentagem de clientes do sexo feminino que se 
dizem satisfeitos; 
10) Deseja-se processar os dados de uma pesquisa a respeito 
do consumo mensal de energia elétrica em uma 
determinada cidade. Os dados disponíveis são: 
i) Preço do KWH; 
ii) Número do consumidor; 
iii) Quantidade de KWH consumidos no mês; 
iv) Código de tipo de consumidor ( 1-Residencial, 2-
Comercial, 3-Industrial); 
Desenvolva um algoritmo que aceite a entrada e processe 
os dados da pesquisa, calculando e apresentando os resultados 
abaixo. O algoritmo deverá interpretar a entrada “Número do 
Consumidor = 0” como sendo o marcador de fim dos dados a 
coletados; 
a) O maior consumo industrial; 
 96
 
enquanto ( < condição> ) faça 
< instrução a ser executada 
zero ou mais vezes > 
fim_enquanto 
 
 
enquanto ( < condição> ) faça 
{ 
< instruções a serem 
executadas zero ou mais vezes 
> 
} fim_enquanto 
< Instruções a serem
executadas zero ou mais
vezes>
< condição >
v
F
V
b) O menor consumo residencial; 
c) O total de consumo para cada categoria; 
d) A média de consumo de cada categoria; 
VI. 2 Estrutura Enquanto ... faça 
A estrutura enquanto....faça difere da estrutura 
faça...enquanto, apenas pelo fato da condição ser avaliada 
antes da primeira execução de suas instruções internas.Assim 
se a primeira avaliação da condição resultar falso, as 
instruções não serão executadas nenhuma vez. Isso pode ser 
útil em muitos casos. 
VI. 2.1 Sintaxe Básica 
 
 
 
 
 
 
 
 
Fluxograma 24 - Sintaxe da estrutura de repetição enquanto...faça 
 97
Exemplo 1 
Contar de 0 a 100 de dois em dois, no final apresentar a 
soma de todos os valores da seqüência. 
Entrada: 
1 Não há entradas; 
Saída: 
1 Seqüência de números inteiros, de zero a100, com 
incremento de 2 unidades; 
2 Somatório dos valores da seqüência. 
 
Algorítmo: 
Linguagem Natural 
1 Início; 
2 Inicializar um contador e um acumulador em zero; 
3 Enquanto o contador for menor ou igual a 100; 
a. Apresentar o valor do contador; 
b. Adicionar o valor do contador ao acumulador; 
c. Incrementar o contador em duas unidades; 
4 Apresentar o valor do acumulador 
5 Fim 
 
 98
Fluxograma: Português Estruturado 
 
 
 
 
 
 
 
 
 
 
Fluxograma 25 - Contando de 0 até 100 de dois em dois, calculando o 
somatório 
 
principal ( ) 
{ 
 inteiro Cont, Soma; 
 
 Cont ← 0; 
 Soma ← 0; 
 enquanto ( Cont ≤ 100) faça 
 { 
 escreva ( Cont ); 
 Soma ← Soma + Cont; 
 Cont ← Cont + 2; 
 } fim_enquanto; 
 escreva (“Soma: ”, Soma); 
}; 
Início
Cont = 0
Soma = 0
Cont <= 100
Cont
Soma = Soma + Cont
Cont = Cont + 2
Fim
V
F
R
"Soma:", Soma
 99
Exemplo 2 
Ler um seqüência de números inteiros positivos, cujo final 
é marcado pôr um valor menor ou igual a zero, esse valor deve 
ser desprezado. Apresentar ao final os seguintes resultados: 
a) A soma dos valores; 
b) A média dos valores; 
c) O maior Valor; 
d) O menor Valor; 
 
Entrada: 
1 Seqüência de valores numéricos positivos; 
Saída: 
1 Valores referentes aos itens a), b), c) e d) pedidos; 
 
Algorítmo: 
Linguagem Natural 
1 Inicializar um contador e um acumulador com 
zero; 
2 Solicitar/ler o primeiro valor; 
3 Inicializar os indicadores de Maior e Menor valor 
com o valor obtido no passo anterior; 
4 Repetir os passos abaixo, se e enquanto o ultimo 
valor lido for maior que zero; 
a. Somar o valor lido ao total do acumulador; 
 100
b. Incrementar o contador de valores válidos em 
uma unidade; 
c. Testar se o valor lido é maior que o tido como 
maior valor atual, em caso afirmativo esse 
passa a ser o maior valor atual; 
d. Testar se o valor lido é menor que o tido como 
menor valor atual, em caso afirmativo esse 
passa a ser o menor valor atual 
e. Ler o próximo valor 
5 Testar se o contador indica que a seqüência tinha 
pelo menos um valor positivo. 
a. Em caso afirmativo: calcular a média e 
apresentar os resultados pedidos nos itens (a), 
(b), (c) e (d). 
b. No caso do contador indicar que não houve 
valores positivos, apresentar a mensagem 
“Seqüência Vazia”. 
 101
Início
Soma = 0
Cont = 0
N
N > 0
Soma = Soma + N
Cont = Cont + 1
N
Maior = N
Menor = N
Maior < N
Maior = N
Menor > N
Menor = N
V
F
V
F
v
Fim
Cont > 0
"Sequência
vazia"
Media = Soma / Cont
"Soma: ", Soma,
"Media: ", Media,
"Maior: ", Maior,
"Menor: ", Menor
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 26 - Algoritmo para ler uma seqüência de números positivos e 
calcular - Média, Soma, Maior e Menor valor. 
 102
Português Estruturado: 
 
principal ( ) 
{ 
 inteiro Num, Soma, Cont; 
 inteiro Maior, Menor; 
 real Media; 
 
 Soma ← 0; 
 Cont ← 0; 
 escreva (“Digite a seqüência:”); 
 leia ( Num ); 
 Maior ← Num; 
 Menor ← Num; 
 enquanto ( Num > 0 ) faça 
 { 
 Soma ← Soma + Num; 
 Cont ← Cont + 1; 
 se ( Num > Maior ) então 
 Maior ← Num; 
 fim_se; 
 se ( Num < Menor ) então 
 Menor ← Num; 
 fim_se; 
 leia ( Num ); 
 }fim_enquanto; 
 se ( Cont > 0) então 
 { 
 Media ← Soma / Cont; 
 escreva (“Soma: ”, Soma); 
 escreva (“Média: ”, Media); 
 escreva (“Maior: ”, Maior); 
 escreva (“Menor: ”, Menor); 
 } 
 senão 
 escreva (“Sequência Vazia”); 
 fim_se; 
}; 
 
 103
Exemplo 3 
Verificar se um número qualquer (inteiro positivo) é ou não 
primo. Números negativos não devem ser aceitos. 
Entrada: 
1 Um número inteiro positivo 
Saída: 
1 A informação sobre o fato do número ser ou não 
primo 
 
Algorítmo: 
Linguagem Natural 
1 Início; 
2 Ler um número; 
3 Verificar se o número é negativo, se for voltar ao 
passo 2, caso contrário continua – passo 4; 
4 Um número N é primo se possui apenas dois 
divisores exatos ( 1 e ele mesmo N ), nesse caso 
calcular todos os divisores de N. 
5 Se N possui mais que dois divisores, então não é 
primo. Caso contrário, N é primo 
6 Fim; 
 
Fluxograma: ? 
Português Estruturado: ? 
 104
VI. Exercícios 
11) Desenvolver um algoritmo para apresentar todos os 
múltiplos de 3 compreendidos entre dois extremos (limite 
inferior e limite superior), a serem fornecidos pelo usuário. 
A informação de um limite inferior maior que o limite 
superior, deverá causar a apresentação de uma mensagem 
de erro. 
12) Desenvolver um algoritmo para o balanço de uma conta 
bancária obedecendo aos seguintes pontos. 
a) O saldo atual deve ser solicitado antes de iniciar o 
balanço. 
b) Poderão ser efetuados débitos e créditos; 
c) O algoritmo deverá finalizar quando ocorrer um 
depósito com valor nulo 0,00. 
d) Uma tentativa de débito com saldo insuficiente deverá 
gerar a mensagem “SALDO INSUFICIENTE”. 
13) Desenvolver um algoritmo para calcular e apresentar todos 
os divisores de um número inteiro positivo, fornecido pelo 
usuário. 
14) Desenvolver um algoritmo para calcular e apresentar os 50 
primeiros termos da série de Fibonacci2 : 1, 1, 2, 3, 5, 8, 
13, 21, 34,... . Esta se caracteriza pelo fato de que a partir 
do terceiro termo, cada termo é calculado somando-se os 
dois termos anteriores. 
 
2 Matemático ........................ 
 105
15) Refazer os exercícios de 1 a 10; 
VI. 3 Estrutura para....faça 
A forma adotada neste livro é a mesma suportada pela 
linguagem C, entretanto cabe ressaltar que em outras 
linguagens, PASCAL pôr exemplo, essa estrutura pode 
apresentar variações. 
A estrutura para....faça é uma estrutura de repetição que 
reúne em seu cabeçalho três seções: 1 - a inicialização de 
indexadores; 2 - uma condição lógica que define o ponto de 
ruptura do laço; 3 – o incremento dos indexadores. 
VI. 3.1 Sintaxe Básica 
Fluxograma: 
 
 
 
 
 
 
 
 
Fluxograma 27 - Fluxograma da estrutura de repetição para ... faça 
 
 
 
Inicialização, Condição, Incremento
< instruções a serem
repetidas zero ou mais
vezes>
v
R
F
 106
Português Estruturado: 
para ( <inicialização>; <condição>; <incremento> ) faça 
 < instrução a sere executada zero ou mais vezes >; 
fim_para;
 
para ( <inicialização>; <condição>; <incremento> ) faça 
{ 
 < instrruções a serem executadas zero ou mais vezes >; 
} fim_para; 
 
 
Exemplo 1 
Calcular o fatorial de um número, N inteiro não negativo 
informado pelo usuário. Números negativos devem gerar uma 
mensagem de erro. 
Entrada: 
1 Um número inteiro; 
Saída: 
1 Valor do fatorial do número dado, ou mensagem 
de erro; 
Algorítmo: 
 
 107
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 28 - Fluxograma do algoritmo para calculo do fatorial de um 
número 
Português Estruturado: 
 
 
 
 
 
 
 
 
principal ( ) 
{ 
 inteiro N, Fat,Cont; 
 
 escreva (“Fatorial de: ”); 
 leia ( N ); 
 se ( N < 0 ) então 
 escreva (“Valor inválido”); 
 senão 
 { 
 para (Fat = 1, Cont = 1; Cont ≤ N; Cont ← Cont + 1 ) faça 
 { 
 Fat ← Fat * Cont; 
 } fim_para; 
 escreva ( N, “! = ”, Fat); 
 } fim_se; 
}; 
Inicialização 
Condição 
Incremento 
Início
N
Fat=1, Cont=1; Cont <= N; Cont = Cont+1
Fat = Fat * Cont
N < 0
"Erro"
Fim
"Fatorial :",Fat
Fv
v
F
 108
Início
N = 1; N <= 300; N = N + 1
Fim
N
aux = 2; aux < K; Aux = Aux + 1
N mod Aux = 0
Primo = Falso;
pare;
Primo
Primo = Verdadeiro
K = N div 2;
v
F
v
F
R
FR
F
V
v
Exemplo 2 
Calcular e apresentar todos os números primos entre 1 e 
300; 
Fluxograma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fluxograma 29 - Fluxograma para calcular e mostrar os números primos 
menores que 300 
 
Comando para 
interromper o laço; 
 109
Observe o comando pare apresentado no fluxograma 
acima, esse comando quando executado, interrompe o laço, 
passando a execução para a primeira instrução após a estrutura 
de repetição; O comando pare pode ser utilizado nas três 
estruturas vistas faça....enquanto, enquanto...faça e 
para....faça. 
Português Estruturado: 
principal ( ) 
{ 
 inteiro N, Aux; 
 lógico Primo; 
 
 para ( N =1; N≤ 300; N ← N + 1) faça 
 { 
 Primo = Verdadeiro; 
 para (Aux = 1; Aux ≤ N/2; Aux ← Aux + 1) faça
 { 
 se ( N mod Aux) então 
 { 
 Primo = Falso; 
 pare; 
 } fim_se; 
 } fim_para; 
 se ( Primo ) então 
 escreve ( N ); 
 fim_se; 
 } fim_para; 
}; 
 
 
No algoritmo acima, a verificação de divisibilidade é 
limitada pelo valor de K que é o quociente de N dividido por 
2. Essa limitação tem o objetivo de eliminar cálculos 
desnecessários, tornando o algoritmo mais eficiente. O valor 
de K poderia também ser calculado como sendo a raiz 
 110
quadrada de N, o que tornaria o algoritmo ainda mais eficiente 
quando da verificação de números grandes. 
O algoritmo apresentado poderia ser ainda melhorado na 
sua eficiência, eliminando-se os testes de divisibilidade pelos 
números pares maiores que dois. 
VI. Exercícios 
1) Desenvolver um algoritmo capaz de calcular mn onde m e 
n são fornecidos pelo usuário. O algoritmo deverá aceitar, 
como entradas validas, apenas números naturais. 
2) Incrementar o algoritmo desenvolvido no exercício 16, de 
modo que m e n possam ser números inteiros positivos 
e/ou negativos. 
3) Dados o primeiro termo e a razão de uma PA (progressão 
Aritmética). Calcular e apresentar os N primeiros termos. 
an = a1 + (n-1).r 
4) Dados o primeiro termo, a razão e o número de termos de 
uma PG (Progressão geométrica). Calcular e apresentar 
cada um dos termos. 
an = a1 . r(n-1) 
5) Refazer os exercícios 11 13 e 14 desse capitulo, utilizando 
a estrutura para...faça. 
 111
Capítulo VII Procedimentos e 
Funções 
Nos capítulos anteriores, foram introduzidos os conceitos 
básicos referentes à construção e expressão de algoritmos. O 
capitulo I introduziu à lógica binária, No capitulo II foram 
apresentadas algumas definições e no capitulo III, a arte da 
programação estruturada foi apresentada e com ela os 
primeiros algoritmos, eles eram muito simples e envolviam 
apenas instruções seqüências. 
No Capitulo IV, foram introduzidas as estruturas de seleção 
simples, composta e múltipla. O capitulo V introduziu, 
também, o PORTUGUÊS ESTRUTURADO como uma 
ferramenta para o desenvolvimento de algoritmos. Também 
foram apresentadas algumas técnicas de programação 
estruturada. Já no capitulo VI foram abordadas as estruturas de 
repetição e controle. 
No capitulo VII, será abordada um técnica de programação 
estruturada, cujo objetivo é reduzir a complexidade da 
programação. O segredo é dividir para conquistar. 
A partir deste capítulo, a representação de algoritmos na 
forma de fluxogramas, é posta de lado para dar lugar de 
preferência ao Português Estruturado. 
 112
VII. 1 Dividir para Conquistar 
O ponto chave da programação estruturada, é a redução da 
complexidade dos algoritmos, através da subdivisão desses. A 
solução de uma classe de problemas é obtida a partir da 
articulação de um conjunto de algoritmos independentes entre 
si. 
Neste livro são abordadas a duas construções mais 
conhecidas: procedimentos e funções. A linguagem C permite 
uma construção conhecida como “macro”, essa construção é 
muito utilizada pôr programadores C experientes. Detalhes 
sobre a construção “macro” e suas aplicações podem ser 
facilmente obtidas na respectiva literatura. 
Cada linguagem de programação possui características 
próprias que definem como um procedimento e/ou função 
deve ser declarado. Para a pseudo linguagem “PORTUGUÊS 
ESTRTURADO”, usada neste livro, será adotada uma sintaxe 
similar à da linguagem C. 
VII. 2 Procedimentos 
Um procedimento constitui-se basicamente de três partes: 
um cabeçalho, um bloco de declarações e um bloco de código, 
ou seja, o algoritmo. 
Os algoritmos que escrevemos até agora, exceto pela falta 
da palavra chave nada, constituíam-se na verdade de 
procedimentos cuja lista de parâmetros era vazia. 
 113
VII. 2.1 Sintaxe Básica 
Como comentado acima, todo procedimento possui um 
cabeçalho, um bloco de declarações e um algoritmo. A 
generalização apresentada na Fluxograma 30 - Sintaxe 
generalizada para a declaração de su-rotinas do tipo 
procedimento, define como uma construção algorítmica do 
tipo procedimento deve ser declarada, ou seja, a sua sintaxe 
básica. 
 
 
 
 
Fluxograma 30 - Sintaxe generalizada para a declaração de su-rotinas do 
tipo procedimento 
 
9 O Cabeçalho – O cabeçalho é constituído pela palavra 
chave nada, seguida pelo nome do procedimento. Após o 
nome do procedimento, entre parênteses, são listados os 
parâmetros. 
• A palavra chave nada identifica a construção como um 
procedimento, pois a mesma não retorna dados como 
seria o caso de uma função; 
• O nome do procedimento, identifica o mesmo de forma 
única. Num mesmo programa não deverão existir dois 
procedimentos como mesmo nome. Muitas linguagens 
permitem a sobrecarga do nome de uma rotina (duas ou 
mais rotinas compartilhando o mesmo nome), mas esse 
é um assunto fora do escopo deste livro. 
nada < Nome do procedimento> ( <lista de parâmetros>) 
{ 
 < Declarações de variáveis > 
 
 < Algoritmo > 
}; Cabeçalho 
 114
• A lista de parâmetros é uma porta de comunicação, que 
estabelecem quais são os valores, necessários à 
execução do algoritmo, que devem ser previamente 
informados. Essa porta de comunicação também pode 
ser usada para reportar os resultados processados pelo 
algoritmo. 
• As características dos parâmetros são: 
i _ Cada parâmetro possui um tipo associado e um 
nome que devem ser especificados. 
ii _ Um parâmetro pode ainda ser classificado em: 
(parâmetro de entrada, parâmetro de entrada e 
saída e parâmetro de saída). A classificação de 
um parâmetro será detalhada no próximo 
tópico. 
9 A Declaração de Variáveis – logo após o cabeçalho, na 
primeira linha após o símbolo { “inicio”, devem ser 
declaradas as variáveis auxiliares ( locais ) necessárias ao 
processamento das informações recebidas como parâmetros 
ou obtidas através de operações de entrada tais como: 
Entradas do usuário via teclado, mouse, scanner, leitor de 
código de barras, etc; Ou informações obtidas de 
dispositivos de armazenamento de massa (HD, Disquetes, 
etc.). 
9 O algoritmo – Após a declaração das variáveis locais 
necessárias, deixa-se uma ou mais linhas em branco, antes 
de iniciar a especificação do algoritmo que representa a 
efetivação do processamento estipuladopara o 
procedimento. 
 115
nada VolumeCilindro ( real Raio, real Altura, real *Volume) 
{ 
 real AreaBase; 
 
 AreaBase ← 3,1415 * Raio ^ 2; 
 Volume ← Altura * AreaBase; 
}; 
Parâmetros de entradas 
Variável Local 
Algoritmo 
Parâmetro de Saída 
Exemplo 1 
Sub-rotina do tipo procedimento cujo objetivo é calcular o 
volume de um cilindro qualquer. Esse procedimento recebe 
como parametros de entrada, os valores do Raio e da Altura do 
cilindro e altera o parâmetro de saída Volume, de modo que o 
mesmo passe a conter o volume do cilindro. 
 
 
 
 
 
 
Fluxograma 31 - Procedimento parametrizado para cálculo do volume de 
um cilindro 
 
Note que na declaração do parâmetro “Volume”, há um 
asterisco posto entre o seu tipo “real” e o seu nome. Como 
será explicado mais adiante, o asterisco diferencia esse 
parâmetro como sendo um parâmetro de saída, ou seja, o 
caminho pelo qual será reportado o resultado do 
processamento efetuado no algoritmo. 
VII. 2.2 Parâmetros 
Como visto anteriormente, a porta de comunicação de um 
procedimento é a sua lista de parâmetros. Cada parâmetro é 
declarado como uma variável e portanto possui um tipo 
associado (inteiro, real, caracter, lógico, etc.). 
 116
A especificação de um parâmetro pode indicar a 
necessidade de se prover uma informação necessária, sem a 
qual o procedimento não pode produzir o resultado esperado. 
A especificação de um parâmetro pode também definir que o 
mesmo representará um resultado produzido pelo 
procedimento, ou ainda as duas coisas. Assim, cada parâmetro 
deve ser classificado com pertencente a uma das classes 
abaixo: 
 
9 Parâmetro de entrada – Um parâmetro é classificado 
como “entrada”, quando o valor pôr ele representado é 
utilizado no processamento sem sofrer alterações que sejam 
relevantes fora do escopo do procedimento3. 
 
 Sintaxe 
 A declaração de um parâmetro de entrada, tem a 
mesma sintaxe da declaração de uma variável normal; 
 ( <Tipo Associado> <Nome> ) 
 No exemplo 1, os parâmetros “Raio” e “Altura” são 
parâmetros de entrada. 
 
9 Parâmetro de saída – Um parâmetro é classificado como 
“saída”, quando representa um valor que só terá 
significado após a execução do algoritmo expresso no 
corpo do procedimento. 
 
 
3 Entende-se como escopo do procedimento, o algoritmo nele especificado. 
 117
 Sintaxe 
 Para indicar que um parâmetro é do tipo saída, inclui-
se um asterisco entre a especificação do tipo associado 
ao parâmetro e o seu respectivo nome; 
 ( <Tipo Associado> * <Nome> ) 
 No exemplo 1, o parâmetro “Volume” é um parâmetro 
de saída 
 
9 Parâmetro de entrada/saída – Um parâmetro é 
classificado como “entrada/saída”, quando representa um 
valor que será inicialmente utilizado como entrada. O valor 
inicial do parâmetro é processado pelo algoritmo e 
transformado de modo a refletir o resultado do 
processamento. Após o término do algoritmo, o valor 
presente no parâmetro pode ser interpretado como 
parte/todo do resultado a ser reportado pelo procedimento. 
 
 Sintaxe 
 A declaração de um parâmetro classificado como 
entrada/saída, tem a mesma sintaxe de um parâmetro 
de saída; 
 ( <Tipo Associado> * <Nome> ) 
 
Para entender melhor a classificação dos parâmetros, é 
preciso primeiro entender como funciona a articulação entre 
os vários procedimentos que compõem um programa. Veja o 
tópico “Chamadas de Procedimentos”. A seguir 
 118
VII. 2.3 Chamadas de Procedimentos 
Os procedimentos podem ser classificados como 
procedimentos de biblioteca padrão e procedimentos definidos 
pelo usuário. Os procedimentos de biblioteca são aqueles que 
figuram como parte das bibliotecas básicas que integram uma 
linguagem e fornecem as operações elementares de 
entrada/saída, são exemplos leia (<lista de variáveis>), 
escreva (<Texto e/ou lista de variáveis> ), etc. Já, os 
procedimentos definidos pelo usuário, são aqueles criados e 
especificados pelo construtor do programa. 
VII. 2.3.1 Sintaxe 
A chamada de um procedimento definido funciona da 
mesma forma que a chamada de um procedimento de 
biblioteca padrão. Basta que se escreva o seu nome, seguido 
pelos respectivos parâmetros entre parênteses. 
<Nome do Procedimento> (<parâmetros enviados>); 
VII. 2.3.2 Associação dos Parâmetros 
Ao enviar um parâmetro, devemos lembrar da sua 
classificação: entrada, entrada/saída ou saída. 
9 Um parâmetro classificado como de “entrada”, configura 
uma associação pôr valor, o que significa que o importante 
é o valor do mesmo. Dessa forma, podemos enviar um 
literal, o valor armazenado em uma variável, ou até mesmo 
o resultado de uma instrução. Veja a seguir: 
 
 119
escreva (“Alo Mundo”); enviando um valor 
literal 
escreva ( 5 ); enviando um valor 
literal 
escreva ( Altura ); enviando o valor 
armazenado numa 
variável 
escreva ( Altura* AreaBase); enviando o resultado de 
uma instrução 
• A associação pôr valor define que o parâmetro 
especificado no cabeçalho do procedimento receberá 
uma cópia do valor enviado no ato da chamada do 
procedimento, dessa forma qualquer alteração feita no 
valor desse parâmetro, estará confinada nos limites do 
procedimento, ou seja, não será refletida no valor 
original. É como uma fotocópia de um documento, se 
rasgar a cópia nada acontece com o original. 
9 Se o parâmetro é classificado como parâmetro de saída, 
então está configurada uma associação pôr referência. 
Nesse tipo de associação espera-se que seja enviada uma 
variável, um local para armazenar o resultado de um 
processamento; o valor contido na variável enviada não é 
relevante pois será simplesmente substituído pelo valor 
produzido no procedimento. O envio de um literal, nesse 
caso será um erro de sintaxe. Veja os dois exemplos 
abaixo. 
leia ( Altura ); correto 
 120
leia ( 5 ); erro de sintaxe, o procedimento leia 
espera um parâmetro associado pôr 
referência (saída) e não um literal; 
• A associação pôr referência define um “apelido ou 
indicador” para a variável enviada como parâmetro, 
desta forma, tem outro nome para a mesma variável. 
Qualquer alteração efetuada sobre o valor armazenado 
num parâmetro associado pôr referência estará na 
verdade sendo efetuada sobre o valor armazenado na 
variável que foi enviada como parâmetro no ato da 
chamada ao procedimento. As modificações efetuadas 
sobre parâmetros de saída, não estão confinadas ao 
procedimento e refletem-se diretamente no valor da 
variável enviada como parâmetro no ato da sua 
chamada. 
 
9 Os parâmetros classificados como entrada/saída também 
configuram uma associação pôr referência, a única 
diferença é que o valor armazenado na variável enviada 
como parâmetro, não será simplesmente descartado, ele 
será inicialmente usado como um parâmetro de entrada, 
sendo substituído pelo resultado do processamento. 
 121
VII. 2.4 Programas 
No capitulo II, “programa” foi definido como sendo um 
conjunto de um ou mais algoritmos, articulados de forma a 
proverem solução para uma ou mais classes de problemas. 
Agora neste capitulo, foi mostrado que cada um desses 
algoritmos é um procedimento. Um programa, pôr mais 
simples que seja, constará sempre com pelo menos um 
procedimento chamado principal. O procedimento nomeado 
“principal”, é o ponto de partida do programa, os demais 
procedimentos serão chamados a partir dele. 
Um procedimento está para outro como uma instrução, que 
pode ser expressa em qualquer parte do algoritmo. A chamada 
de um procedimento é trivial, e embora não tenha sido 
explicitado, estamos fazendo uso delas desde os primeiros 
exercícios. As instruções leia (<variável>) e escreva (< Texto 
e/ou variáveis>), são naverdade chamadas a procedimentos 
incorporados como parte da pseudo linguagem de 
programação. Toda linguagem possui um conjunto de 
bibliotecas de procedimentos e funções padrão, que permitem 
realizar as tarefas básicas de entrada e saída, cálculos 
matemáticos, manipulação de arquivos, etc. 
Para que um procedimento possa ser invocado, é necessário 
que o mesmo seja parte da linguagem, ou esteja definido no 
programa, acima do ponto de chamada. Também é necessário 
prover os parâmetros necessários, conforme a definição no 
cabeçalho do mesmo. 
 
 122
Exemplo 1 
 
 
 
 
 
 
 
 
 
 
 
 
 
Neste exemplo o procedimento chamado VolumeCilindro, 
possui dois parâmetros de entrada “Altura, Raio” e um 
parâmetro de saída “Volume”. Também está ilustrada a 
chamada do mesmo a partir do procedimento principal. 
Observe que os nomes das variáveis no procedimento 
principal não são iguais aos nomes dos parâmetros requeridos 
pelo procedimento “VolumeCilindro”, isso acontece porque, o 
importante não é o nome da variável e sim a forma como o 
parâmetro está associado. Note ainda que a variável “V” não 
recebeu nenhum valor no procedimento “principal”, mas ao 
ter sido enviada como parâmetro associado pôr referência, 
teve seu valor modificado no procedimento 
nada VolumeCilindro ( real Raio, real Altura, real *Volume) 
{ 
 real AreaBase; 
 
 AreaBase ← 3,1415 * Raio ^ 2; 
 Volume ← Altura * AreaBase; 
}; 
 
 
nada principal () 
{ 
 real R, H, V; 
 
 escreva (“Programa volume de CILINDROS ”); 
 escreva(“Raio da Base em cm: ”); 
 leia ( R ); 
 escreva(“Altura em cm: ”); 
 leia ( H ); 
 VolumeCilindro ( R, H, V); 
 Escreva (“O volume é:”, V, “cm3”); 
}; 
Chamada de procedimento 
 123
“VolumeCilindro”. Cabe lembrar que pôr terem sido enviadas 
como parâmetros associados pôr valor, mesmo que o 
procedimento “VolumeCilindro” modificasse os valores 
recebidos em “Raio” e “Altura”, essas alterações não seriam 
refletidas nas variáveis “R “e “H”. 
 
Exemplo 2 
Montar uma calculadora para operar com as quatro 
operações básicas (Adição, Subtração, Multiplicação e 
Divisão). A cada nova conta, são informados os dois valores e 
a operação. 
Entrada: 
1 Dois números quaisquer; 
2 Um símbolo ( +, - , *, /) que indica a operação; 
Saída: 
1 O resultado da operação pedida sobre os valores 
informados; 
Linguagem Natural 
1 Solicitar/Ler dois números reais; 
2 Solicitar/Ler a operação; 
3 Chamar o procedimento de calculo para efetuar a 
operação pedida; 
4 Informar os resultados; 
5 Perguntar se o usuário quer ou não fazer outra 
conta; 
 124
6 Enquanto o usuário responder sim, repetir os 
passos de 1 a 5; 
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*----------------------------------------------------------------------------------- 
 Procedimento para calculo das quatro operções matemáticas básicas 
Parâmetros de entrada : 
 A, B → Operandos; 
 Op → Operador; 
Parametros de saída: 
 R → Resultado da operção 
 Ok → Status de erro; 
----------------------------------------------------------------------------------*/ 
 
nada Calcula ( real A; real B; caracter Op; real *R; logico *Ok ) 
{ 
 Ok ← VERDADEIRO; 
 caso (Op) seja 
 { 
 ‘+’ : 
 R ← A + B; 
 pare; 
 ‘−’ : 
 R ← A - B; 
 pare; 
 ‘*’ : 
 R ← A * B; 
 pare; 
 ‘/’ : 
 se ( B ≠ 0 ) então 
 R ← A / B; 
 senão 
 Ok ← FALSO; 
 fim_se; 
 pare; 
 
 não_seja 
 Ok ← FALSO; 
 }; 
}; 
 125
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*----------------------------------------------------------------------------------- 
 Procedimento principal para comandar o calculo das quatro operções 
matemáticas básicas 
 
Parâmetros de entrada : 
 Nenhum 
Parametros de saída: 
 Nenhum 
----------------------------------------------------------------------------------*/ 
 
nada principal ( ) 
{ 
 real A, B, R; 
 caracter Op, Resp; 
 logico Ok; 
 
 faça 
 { 
 escreva (“A: ”); 
 leia ( A ); 
 escreva (“B: ”); 
 leia ( B ); 
 escreva (“Operação: ”); 
 leia ( Op ); 
 Calcula ( A, B, Result, Ok); 
 se ( Ok ) então 
 escreva ( Result ); 
 senão 
 escreva ( “Erro”); 
 fim_se; 
 escreva (“Continuar (S/N) ?”); 
 leia ( Resp ); 
 } enquanto ( ( Resp = ‘S’ ) ou ( Resp = ‘s’ )); 
}; 
 126
VII. Exercícios 
1) Escrever uma rotina “QuantosDias”, cujos parâmetros 
sejam: Ano, Mês, Dia, N. Após o processamento, N 
deverá representar o número de dias transcorridos, a partir 
de 1o de janeiro de 2000 até a data informada. Lembre-se 
que o mês de fevereiro tem 28 ou 29 dias, dependendo do 
ano ser ou não bissexto. 
 
2) Escreva uma rotina para trocar os valores de duas 
variáveis A e B entre si. 
 
3) Montar um programa, baseado em procedimentos, para 
apresentar a taboada de um número qualquer fornecido 
pelo usuário. 
 
4) Refaça o exemplo 2, de modo que cada uma das operações 
seja efetuada pôr um procedimento em separado. 
 
Escreva um programa para cálculo de áreas de figuras 
geométricas planas regulares. O programa deve possuir um 
menu que ofereça pelo menos 5 opções de figuras diferentes e 
uma opção “sair” para encerrar o programa. Dica: Use a 
estrutura de seleção múltipla para controlar o menu. 
 127
VII. 3 Funções 
Em termos de construções algorítmicas, uma função difere 
de um procedimento pôr 2 aspectos: 1 – Não são admitidos 
parâmetros de “saída” ou “entrada/saída”. 2 – O resultado 
produzido pôr uma função é reportado no próprio nome da 
função. 
Sintaxe: 
 
 
 
 
 
 
9 Tipo do retorno – É o tipo associado ao valor retornado 
pela função, ou seja o valor que a função produziu como 
resultado e que deve ser reportado ao chamador. Uma 
função é como uma expressão matemática, que após ser 
avaliada produz um resultado. 
9 Nome da função – É o nome dado à função, a sua 
identificação; 
9 Lista de parâmetros – A lista de parâmetros tem 
exatamente a mesma constituição usada com 
procedimentos. É aconselhável que a lista de parâmetros 
das funções possuam apenas parâmetros do tipo “entrada”, 
ou seja, associados pôr valor. 
<tipo do retorno> < Nome da função> ( <lista de parâmetros>) 
{ 
 < Declarações de variáveis > 
 
 < Algoritmo > 
 
}< Nome da função>; 
 
No algoritmo deverá aparecer o comando 
retorne (<Dado a ser retornado>) 
 128
9 Retorno – A instrução retorne(<dado>), é de presença 
obrigatória no algoritmo de toda e qualquer função. Essa 
instrução efetiva o término do processamento. O valor 
constante em “dado” é reportado como resultado da função. 
Uma função pode ser vista como uma variável, a diferença 
é que ela não armazena, calcula, o seu valor. Dessa forma, 
funções podem figurar como operandos em expressões 
matemáticas, desde que o tipo de retorno seja numérico. 
Funções também podem figurar como parâmetros associados 
pôr valor (“entrada”) para outras funções e/ou procedimentos. 
Exemplo 1 
Montar um programa para verificar se um numero é par ou 
impar. Tal programa deve possuir uma estrutura de repetição 
para efetuar a verificação de uma seqüência de N números 
inteiros positivos, sendo que o final da seqüência é marcada 
pôr um valor negativo. 
Entrada: 
1 Uma seqüência de números inteiros; 
Saída: 
1 Uma mensagem “Par” ou “Impar” para cada 
número da seqüência, conforme o caso. 
Linguagem Natural 
1 solicitar/Ler um número; 
2 Se o número obtido for positivo, chamar a função 
de verificação éImpar; 
 129
3 Mostra a mensagem “PAR” ou a mensagem 
“IMPAR”, de acordocom o resultado da função 
éImpar; 
4 Repetir os passos 1,2,3 enquanto o número 
fornecido for positivo. 
 
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* -------------------------------------------------------------------- 
função para verificar se um número é par ou impar 
Parâmetro de entrada: 
 N → número a ser verificado; 
Retorno : 
 Verdadeiro caso N seja impar, 
 Falso caso N não seja impar; 
----------------------------------------------------------------------*/ 
 
logico éImpar ( inteiro N ); 
{ 
 se ( N mod 2 ≠ 0 ) então 
 retorne( VERDADEIRO ); 
 fim_se; 
 retorne( FALSO ); 
}éImpar; 
 130
 
 
 
 
 
/*-------------------------------------------------------------------- 
Procedimento principal 
Descrição: 
 Lê uma sequência de números, informando um a 
um se é PAR ou IMPAR. Um número não positivo finaliza o 
programa. 
--------------------------------------------------------------------*/ 
 
nada principal () 
{ 
 inteiro Numero; 
 
 faça 
 { 
 escreva (“Digite um número”); 
 leia( Numero ); 
 se ( Numero > 0 ) então 
 se ( éImpar (Numero) ) então 
 escreva(“IMPAR”); 
 senão 
 escreva(“PAR”); 
 fim_se; 
 fim_se; 
 }enquanto ( Numero > 0); 
}principal; 
 131
Exemplo 2 
Montar um programa calculadora com as operações 
Adição e Subtração. O programa deve possuir, além do 
procedimento principal, funções para cálculo das operações 
suportadas; Um procedimento para solicitação/leitura dos 
operandos, processamento da operação pedida através da 
chamada às respectivas funções e apresentação dos resultados. 
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*-------------------------------------------------------------------- 
Função para efetuar a operação de ADIÇÃO; 
Parametros de entrada: 
 NumA, NumB → valores reais a serem somados; 
Retorno: 
 O resultado da operação NumA + NumB 
----------------------------------------------------------------------*/ 
 
real Soma ( real NumA; real NumB) 
{ 
 retorne ( NumA + NumB ); 
};// Soma 
/*-------------------------------------------------------------------- 
Função para efetuar a operação de SUBTRAÇÃO; 
Parametros de entrada: 
 NumA, NumB → valores reais a serem subtraídos; 
Retorno: 
 O resultado da operação NumA - NumB 
----------------------------------------------------------------------*/ 
 
real Subtração ( real NumA; real NumB) 
{ 
 retorne ( NumA - NumB ); 
};// Subtração 
 132
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*-------------------------------------------------------------------- 
Procedimento de controle; 
Descrição 
 Este procedimento controla a interação com o usuário e 
comanda a execução das operações solicitadas. 
----------------------------------------------------------------------*/ 
 
nada Calculadora ( ) 
{ 
 real N1, N2; 
 Carcacter Op, Resp; 
 
 faça 
 { 
 escreva ( “A: ”); 
 leia ( N1 ); 
 escreva ( “B: ”); 
 leia ( N2 ); 
 escreva ( “Operação: ”); 
 leia ( Op ); 
 caso ( Op ) seja 
 { 
 ‘+’ : 
 escreva ( Soma (N1, N2 ) ); 
 ‘-’ : 
 retorne ( Subtração ( N1, N2 ); 
 
 não_seja 
 escreva(“Operação Não Suportada”); 
 }; //caso 
 escreva (“Nova conta (S/N):”); 
 leia ( Resp ); 
 } enquanto ( Resp ≠ ‘N’ e Resp ≠ ‘n’); 
}; // Subtração 
 133
VII. Exercícios 
5) Amplie o exemplo 2, de modo a suportar também as 
operações de multiplicação, divisão e exponenciação. 
Lembre-se que divisão pôr zero não existe; 
 
6) Refaça o exercício 3, utilizando funções. 
 
7) Monte um programa de cálculo para as grandezas físicas 
do movimento retilíneo e uniforme “MRU”. O programa 
deve considerar todas as possibilidades de incógnitas que 
envolvam as seguintes equações: 
a) Vf = Vi + a.Δt 
b) ΔE = Vi.t + ½.a.Δt2 
 
8) Escreva uma função que: 1- receba como parâmetros, as 
coordenadas (x, y) de dois pontos quaisquer do plano 
cartesiano; 2 – Calcule e retorne a respectiva distância 
entre eles. d2 = (X2-X1)2 + (Y2-Y1)2. 
 
9) Escreva uma função que receba como parâmetro um 
número inteiro N, a função deverá retornar: -1 caso o 
 134
número seja negativo caso contrário deverá retornar um 
valor correspondente a N! (Fatorial de N). 
 
10) Escreva uma função capaz de calcular o máximo divisor 
comum (MDC) entre dois números inteiros. 
 
11) Escreva uma função para calcular o mínimo múltiplo 
comum (MMC) entre dois números inteiros. 
 
12) Escreva uma função que, dado um número inteiro N, 
calcule e retorne a soma dos divisores desse número, 
exceto ele próprio. 
 
 
 
 
 
 135
Capítulo VIII Estruturas de 
Dados Homogêneas 
Os capítulos anteriores tiveram como ênfase a apresentação 
e o detalhamento das construções algorítmicas utilizadas na 
programação estruturada: comandos seqüenciais, estruturas de 
seleção, estruturas de repetição e controle, procedimentos e 
funções. 
A partir deste capítulo, a ênfase passa a ser as estruturas de 
armazenamento de dados/informações. As primeiras estruturas 
a serem abordadas são as estruturas homogêneas ( Vetores e 
Matrizes). Ao contrário das variáveis vistas até o momento, 
variáveis declaradas como sendo estruturas homogêneas, 
permitem o armazenamento de vários valores de um mesmo 
tipo. Esses valores são armazenados seqüencialmente, sendo 
que o acesso e a manipulação individual de cada valor é 
realizada pela indicação da sua posição “índice” dentro da 
estrutura. 
 136
VIII. 1 O que é um Vetor ? 
Um vetor pode ser visto como sendo uma coleção 
enumerada de elementos de um mesmo tipo. Em se tratando 
de programação de computadores, a declaração de uma 
variável como sendo um vetor, indica a reserva de uma 
quantidade de memória contígua, para o armazenamento de 
um ou mais elementos de um determinado tipo. 
VIII. 1.1 Vetores Unidimensionais 
Um vetor unidimensional, é uma estrutura matricial 
composta de uma única linha e várias colunas. Cada elemento 
da matriz tem capacidade para armazenar um valor do tipo 
especificado na declaração do vetor. A figura abaixo ilustra 
graficamente um vetor com capacidade para 10 números 
inteiros. 
Índices 0 1 2 3 4 5 6 7 8 9 
Valor armazenado 23 45 12 3 0 -2 6 87 10 -6 
 
VIII. 1.1.1 Sintaxe Básica 
A declaração de uma variável, como sendo um vetor 
unidimensional, é simples como mostrado a baixo: 
<Tipo> <Nome da variável> [<número de elementos>]; 
 
Exemplos: 
 137
9 inteiro iVetor[10]; →Um vetor com dez 
elementos do tipo 
inteiro; 
9 real rVetor [50]; →Um vetor com 
capacidade para 
armazenar cinqüenta 
valores numéricos 
reais; 
9 caracter cVetor [35]; →Um vetor com 
capacidade para 
armazenar 35 
caracteres; 
VIII. 1.1.2 Acesso aos Elementos 
O acesso aos elementos individuais dos vetores 
unidimensionais é efetuado através da indicação do índice do 
elemento dentro do vetor. O primeiro elemento tem índice 
zero (0), o segundo tem índice um (1), o terceiro dois (2) e 
assim sucessivamente, sendo que o elemento N estará, 
portanto na posição de índice N-1. 
 
Exemplos: 
Considerando duais variáveis vetoriais unidimensionais 
VetA e VetB, ambas com capacidade para 10 números 
inteiros, temos: 
 
9 VetA ← VetB; →Não é permitido. 
 138
Variáveis vetoriais não podem ser atribuídas diretamente. 
A cópia deve ser realizada elemento a elemento. Para tal 
consideraremos que a biblioteca padrão de nossa pseudo 
linguagem possua procedimentos de cópia de vetores cujos 
elementos sejam de um dos tipos básicos. 
Estes procedimentos têm os seguintes cabeçalhos:• CopiaVetInt (inteiro VetOrig[]; inteiro VetDest[]; 
inteiro N ) 
i _ A declaração – inteiro VetOrig[] – indica que 
“VetOrig” é um parâmetro do tipo vetor de inteiros, 
com qualquer número de elementos. O mesmo 
ocorre com “VetDest”. 
Obs: Parâmetros vetoriais, sempre serão 
associados pôr referência. 
ii _ O parâmetro “N” identifica/informa qual é o 
número de elementos de “VetOrig” e “VetDest”; 
iii _ O procedimento CopiaVetInt, realiza a cópia dos 
elementos de “VetOrig” para “VetDest”; 
iv _ No exemplo, o correto seria: CopiaVetInt (VetA, VetB, 
10); 
v _ O vetor destino VetDest passado como parâmetro 
deve necessariamente ter tamanho igual ou superior 
ao passado como origem VetOrig para que a copia 
possa ser efetuada com sucesso. 
 
• CopiaVetReal ( real VetOrig[]; real VetDest[]; inteiro 
N ) 
 139
• CopiaVetCar ( caracter VetOrig[]; caracter VetDest[]; 
inteiro N ); 
i _ Como atividade, escreva o corpo dos três 
procedimentos de cópia de vetores citados acima. 
 
Outros comandos: 
9 VetA [ 0 ] ← VetB [ 0 ]; 
Indica a atribuição do valor armazenado no primeiro 
elemento de VetB, para o primeiro elemento de VetA. 
 
9 VetB [ 10 ] ← VetA [ 4 ]; 
Erro, os índices de um vetor começam em 0 (zero), logo 
o ultimo elemento de VetB está na posição 9, dado que 
VetB tem 10 elementos. A instrução indica uma 
atribuição para o 11o elemento de VetB, mas esse vetor 
tem apenas 10 e não 11 elementos. 
 
9 VetA [ 4 ] ≥ VetA [ 5 ] 
Comparação entre dois elementos do mesmo vetor; 
9 VetA [ i ] ← VetB [ j ]; 
Indica a atribuição do valor armazenado na posição j de 
VetB, para a posição i de VetA. É importante lembrar 
que tanto i como j devem ser variáveis inteiras e seus 
respectivos valores devem figurar entre 0 e 9, pois os 
vetores VetA e VetB possuem 10 elementos cada. 
 
 140
9 leia ( VetB [ 7 ] ); 
Indica a operação de entrada/ armazenamento de um 
valor inteiro para o oitavo elemento de VetB; 
• A entrada de valores para os elementos de um 
vetor, deve ser feita elemento a elemento. Não é 
possível especificar a leitura de todos os elementos 
de um vetor, numa única instrução. 
i _ Como atividade, escreva um procedimento para 
leitura e preenchimento de um vetor com N 
elementos do tipo inteiro. 
 
9 leia ( VetB ); 
Erro, não está indicado qual é o elemento do vetor que 
irá receber o valor; 
 
9 leia ( VetB[i] ); 
Indica a operação de entrada/armazenamento de um 
valor inteiro para posição i de VetB. A variável i deve 
ser do tipo inteiro, e seu valor deve estar entre zero e 9, 
pois VetB possui 10 elementos. 
 
9 escreva ( VetA ); 
Erro, não foi especificado qual é o elemento de VetA 
que deve ser apresentado no vídeo. A apresentação dos 
elementos de um vetor, deve ser efetuada elemento a 
elemento. Para apresentar todos os elementos de um 
vetor, é necessária uma estrutura de repetição. 
 141
 
i _ Como atividade, escreva um procedimento para 
apresentar todos os caracteres armazenados 
num vetor com N elementos. 
VIII. 1.2 Vetores Bidimensionais – Matrizes 
As estruturas matriciais bidimensionais, possuem a mesma 
definição dos vetores unidimensionais, diferindo apenas no 
fato de que tem-se não apenas um índice, mas um par de 
índices (linha, coluna), para identificar cada elemento da 
matriz; A figura abaixo ilustra uma construção matricial com 
5 linhas e 6 colunas de inteiros; 
 Colunas
0 1 2 3 4 5 
L
i
n
h
a
s
 
0 -49 45 5 3 65 -654 
1 67 32 6 2 2 3 
2 89 -53 5 0 765 1 
3 100 1 6 0 2 0 
4 -345 0 9 -23 1 857 
 
VIII. 1.2.1 Sintaxe Básica 
A declaração de uma variável, como sendo uma matriz 
bidimensional, é simples como mostrado a baixo: 
<Tipo> <Nome da variável> [<número de linhas>][<número de 
colunas>]; 
 142
Exemplos: 
9 inteiro iMat[5][10]; 
Uma matriz de números inteiros, com cinco linhas e dez 
colunas; 
 
9 real rMat [10][5]; 
Uma matriz com capacidade para armazenar cinqüenta 
valores numéricos reais; Dez linhas e cinco colunas. 
 
VIII. 1.2.2 Acesso aos Elementos 
O acesso aos elementos de uma construção matricial 
bidimensional, é realizado de forma semelhante aos vetores 
unidimensionais, diferindo apenas no fato de ser necessário 
informar dois valores de índice em vez de um. 
 
Exemplos: 
Considere a matriz iMat do exemplo dado acima, abaixo 
são dadas operações exemplo, válidas e inválidas. 
9 leia( iMat ); 
Operação inválida, a leitura de uma matriz deve ser 
realizada elemento a elemento; 
 
9 leia( iMat [ 1 ] [ 0 ] ); 
 143
Operação válida. Indica a leitura “entrada” de um valor 
para a 2a linha 1a coluna; 
 
9 escreva ( iMat [ 4 ] [ 9 ] ); 
Operação válida. Indica a apresentação, no vídeo, do 
valor armazenado na 5a linha e 10a coluna; 
 
9 iMAt [ 2 ] [ 8 ] ← 5; 
Operação válida. Indica a atribuição do valor 5 para o 
elemento a2,8 da matriz ( 3a linha e 9a coluna); 
 
9 iMat [ 0 ] [ 10 ] ← 9; 
Operação inválida. Indica a atribuição do valor 5 para a 
posição 1a linha e 11a coluna, entretanto a matriz iMat 
tem apenas 10 colunas; 
 
Exemplo 1 
Montar uma rotina para realizar a leitura de um vetor 
unidimensional com N elementos; 
 
 144
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Comentários: 
 iVet é um parâmetro do tipo vetor/matriz 
unidimensional com qualquer número de elementos. Todo 
parâmetro matricial é associado pôr referência, portanto não é 
necessário antepor o ‘*’ ao nome da variável; 
 N é um parâmetro associado pôr valor e representa o 
tamanho do vetor; 
 Na estrutura para...faça, observe que a condição de 
prosseguimento é i < N e não i ≤ N, isso porque as posições 
são enumeradas a partir de 0 e não de 1; 
/*-------------------------------------------------------------------- 
Procedimento: Leitura de Vetor; 
Parâmetros: 
 iVet[ ] → Vetor de números inteiros; 
 N → Tamanho do vetor; 
Descrição: 
 Este procedimento realiza a leitura de um vetor 
unidimensional de inteiros, com N elementos; 
----------------------------------------------------------------------*/ 
 
nada LeVetInt (inteiro iVet [ ]; inteiro N) 
{ 
 inteiro i; 
 
 para( i ← 0; i < N; i ← i + 1) faça 
 { 
 escreva ( i, “o elemento: ”); 
 leia ( iVet[ i ]); 
 }fim_para; 
}; // LeVetInt 
 145
Exemplo 2 
Escrever uma rotina para somar duas matrizes 
bidimensionais de inteiros; 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Comentários: 
 i, j são variáveis locais auxiliares, são usadas para 
percorrer as linhas e as colunas das matrizes. O primeiro laço 
percorre linha pôr linha, enquanto que o laço mais interno 
percorre os elementos de cada linha, ou seja, as colunas. 
 
/*-------------------------------------------------------------------- 
Procedimento: Soma de Matrizes Bidimensionais; 
Parâmetros: 
 iMatA[ ][ ], iMatB → Matrizes a serem somadas; 
 iMatC [ ][ ] → Matriz Soma iMatA + iMatB 
 M,N → Dimensões das Matrizes; 
Descrição: 
 Este procedimento realiza a soma de matrizes bidimensionais 
com M linhas e N colunas, o resultado é armazenado em iMatC; 
----------------------------------------------------------------------*/ 
 
nada SomaMatInt ( inteiro iMatA [ ][ ]; inteiro iMatB [ ][ ]; 
inteiro iMatC [ ][ ]; inteiro M; inteiro N) 
{ 
 inteiro i, j; 
 
 para ( i ← 0; i < M; i ← i + 1) faça //percorre as linhas 
 { 
 para ( j ← 0; j < N; j ← j + 1) faça //percorre as colunas 
 { 
 iMatC[ i ][ j ] ← iMatA[ i ][ j ] + iMatB[ i ][ j ]; 
 }fim_para; 
 }fim_para; 
}; // SomaMatInt 
 146
VIII. Exercícios 
1) Escreva uma rotina para montar a matriz transposta, de 
uma matriz dada. 
 
2) Escreva uma rotina (procedimento ou função) para efetuar 
oproduto de duas matrizes AM1,N1 e BM2,N2. Lembre-se 
que A x B só será possível se N1 = M2. 
 
3) Escreva uma rotina para efetuar a diferença entre duas 
matrizes de ordem M x N. 
 
4) Escreva um programa para trabalhar com matrizes 2x2 e 
3x3. O programa deve interrogar o usuário sobre a ordem 
da matriz e qual a opção desejada (Soma, Diferença, 
Produto, transposta), então deverá solicitar a entrada dos 
dados necessários, efetuar a operação pedida e apresentar 
os resultados. A leitura / apresentação dos elementos das 
matrizes, deve ser feita de modo a identificar claramente a 
posição de cada elemento na matriz. 
 
5) Escreva um programa que solicite ao usuário a entrada de 
20 números inteiros armazenando esses num vetor. A 
seguir inverter o vetor e apresentar os vinte valores na 
nova ordem. 
 147
6) Escreva um programa que solicite ao usuário a entrada de 
uma seqüência de caracteres, armazenando-os num vetor 
de 100 posições. A seguir permitir ao usuário consultar o 
número de vezes que um dado caracter aparece na 
seqüência. Deve ser permitido, ao usuário, efetuar quantas 
consultas desejar. 
 
7) Dada a rotina abaixo, simule uma chamada com um vetor 
de 10 posições e faça o teste de mesa. Você deve montar 
uma representação gráfica do vetor e efetuar sobre ele as 
operações indicadas na rotina. Depois explique com suas 
palavras: O que faz a rotina ? Qual é o princípio utilizado 
nesse algoritmo? Qual o melhor nome para essa rotina? 
 
 
 
 
 
 
 
 
 
nada XXXXXX ( inteiro iVet [ ]; inteiro N) 
{ 
 inteiro i, j, Aux; 
 
 para ( i ← 0; i < N-1; i ← i + 1) faça 
 { 
 para ( j← i + 1; j < N; j ← j + 1) faça 
 { 
 se ( iVet [ i ] > iVet [ j ] ) então 
 { 
 Aux ← iVet [ i ]; 
 iVet [ i ] ← iVet [ j ]; 
 iVet [ j ] ← Aux; 
 }fim_se; 
 }fim_para; 
 }fim_para; 
 
};//XXXXXX 
 148
Capítulo IX Ordenação e Pesquisa 
em Vetores 
Os vetores unidimensionais são estruturas de dados que nos 
permitem escrever algoritmos poderosos e aprimorados para o 
tratamento das informações armazenadas. Entre os pontos 
mais interessantes, destacam-se a ordenação e a pesquisa. 
Embora esse seja um tema para um livro de estruturas de 
dados, farei aqui uma pequena introdução dos conceitos de 
ordenação e pesquisa de dados armazenados em estruturas do 
tipo vetor. 
Neste capítulo você terá um primeiro contato com as 
técnicas de ordenação e pesquisa. Inicialmente é tratada a 
pesquisa seqüencial, aplicada sobre dados não ordenados. Em 
seguida é apresentado o método de ordenação conhecido como 
bolha e posteriormente o método de pesquisa binária. 
 
 149
IX. 1 Pesquisa Seqüencial 
Considere um vetor contendo 10 números inteiros, como o 
representado na figura abaixo: 
Índices 0 1 2 3 4 5 6 7 8 9 
Valor armazenado 23 45 12 3 0 -2 6 87 10 -6 
 
Observe que o valor “0” encontra-se na 5ª posição (índice 
4), nós seres humanos inteligentes podemos chegar a essa 
conclusão facilmente, bastando para tal olharmos o vetor 
como um todo. Mas imagine que esse vetor não tivesse apenas 
10 elementos mas sim 10.000, dessa forma não seria assim tão 
simples verificar em qual posição um determinado valor se 
encontra, dado que não somos capazes de observar, com 
clareza, uma tal quantidade de números de uma só vez. 
Em termos computacionais é um pouco mais crítico, o 
computador só é capaz de comparar o valor procurado com 
uma posição do vetor pôr vez, assim é necessário efetuar uma 
varredura, iniciando em uma das extremidades do vetor e 
percorrendo-o em direção à outra extremidade, comparando o 
valor procurado com o valor armazenado, até encontra-lo em 
uma dada posição. Pôr outro lado, se percorrer todo o vetor, 
de uma extremidade até a outra, sem encontrar o valor 
procurado, é porque o mesmo está presente no vetor. Esse tipo 
de varredura é conhecido como Pesquisa Seqüencial. 
A função dada abaixo tem pôr objetivo verificar, através de 
uma pesquisa seqüencial, se um determinado valor procurado 
encontra-se ou não presente num determinado vetor. Discuta-a 
com seus colegas de estudo. 
 150
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Embora a pesquisa seqüencial seja eficaz, ela não é nada 
eficiente e só é indicada para casos em que os valores 
armazenados não estão ordenados. Suponha pôr exemplo um 
vetor de 10000 elementos, ordenado de forma crescente. 
Suponha também que o valor procurado está na posição 6743, 
serão necessárias 6744 comparações para a rotina poder 
concluir que o referido valor objeto da pesquisa está 
armazenado nessa posição. Agora pense e responda: Quantas 
comparações seriam necessárias para concluir que o valor 
procurado não está presente no vetor? 
/*------------------------------------------------------------------------------------ 
Função: PesquisaSequencial; 
Parâmetros: 
 iVet → Vetor de números inteiros, contendo os valores sobre os 
quais será efetuada a pesquisa; 
 N → Número de elementos do vetor; 
 VlrPesq → Valor objeto da pesquisa; 
Retorno: 
 Um valor de 0 até N-1, indicando a posição no vetor onde o valor 
procurado foi encontrado. 
 -1, Indica que o valor procurado não está presente no vetor. 
-------------------------------------------------------------------------------------*/ 
 
inteiro PesquisaSequencial (inteiro iVet [], inteiro N, inteiro VlrPesq ) 
{ 
 inteiro i; 
 
 para (i ← 0; i < N; i ← i + 1) faça 
 { 
 se ( iVet[ i ] = VlrPesq ) então 
 retorne ( i ); // Encontrado 
 fim_se; 
 }fim_para; 
 retorne ( -1 ); //Não encontrado 
}; // PesquisaSequencial 
 151
IX. 2 Ordenação 
A necessidade de ordenar os valores armazenados em um 
vetor, pode surgir pôr vários fatores, seja para a geração de um 
relatório, ou mesmo para a finalidade de agilizar pesquisas. 
Nesse ultimo caso, a ordenação se justifica quando o conjunto 
de dados é grande e a pesquisa será repetida diversas vezes 
sobre o mesmo conjunto, pois como veremos mais adiante, 
neste capítulo, a aplicação da pesquisa seqüencial é mais 
eficiente quando os dados estão ordenados. Veremos também 
a técnica de pesquisa conhecida como pesquisa binária, que é 
muito mais eficiente que a pesquisa seqüencial. 
Dentre os vários métodos de ordenação, escolhi o mais 
simples que é o método conhecido como BOLHA. Segundo 
esse método, para uma ordenação crescente, procedemos 
segundo o algoritmo abaixo: 
Linguagem Natural 
1 Pegue o primeiro elemento e compare com o segundo, 
troque-os de posição, se necessário, de tal forma que 
fiquem em ordem crescente (o menor primeiro, depois o 
maior). Repita o processo, agora com o segundo e o 
terceiro elemento. E assim sucessivamente até chegar 
aos dois últimos elementos. Nesse ponto o ultimo 
elemento do vetor é o maior de todos os elementos e 
portanto encontra-se ordenado. 
2 Repita todo o processo descrito acima, N-1 vezes (N é o 
número de elementos do vetor). Observando que a cada 
novo ciclo será necessário fazer uma comparação a 
menos, pois a ultima posição comparada no ciclo 
anterior, não mais precisa ser comparada, uma vez que 
 152
armazena o maior valor encontrado no respectivo ciclo 
de comparações. 
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Monte uma representação gráfica para um vetor com 10 
números inteiros desordenados. Depois faça o teste de mesa 
(execução passo a passo) do algoritmo acima e verifique se o 
mesmo realmente funciona. 
/*----------------------------------------------------------------------------- 
Procedimento: OrdBolha; 
Parâmetros: 
 iVet → Vetor de números inteiros, a ser ordenado 
 N → Número de elementos do vetor; 
Descrição: 
 Efetua a ordenação de um vetor de números inteiros com N 
elementos,através do método de ordenação conhecido como 
BOLHA. 
------------------------------------------------------------------------------*/ 
 
nada OrdBolha (inteiro iVet [ ], inteiro N) 
{ 
 inteiro i, j, k, AuxTroca; 
 
 para (i ← 1; i < N; i ← i + 1 ) faça 
 { 
 k ← N – i; 
 para ( j ← 0; j < K; j ← j + 1 ) faça 
 { 
 se ( iVet[ j ] > iVet[ j + 1] ) então 
 { 
 AuxTroca ← iVet [ j ]; 
 iVet [ j ] ← iVet [ j + 1 ]; 
 iVet [ j +1 ] ← AuxTroca; 
 }fim_se; 
 }fim_para; 
 }fim_para; 
}; // OrdBolha 
 153
IX. 3 Pesquisa Seqüencial com Dados 
Ordenados 
Uma pesquisa seqüencial sobre dados desordenados só 
pode concluir que o valor procurado não está presente após 
varrer todo o conjunto (vetor). Entretanto se os dados 
estiverem em ordem, é possível melhorar seu desempenho de 
forma substancial. Analise o algoritmo proposto abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*-------------------------------------------------------------------------------------
Função: PesqSequencialOrd; 
Parâmetros: 
 iVet → Vetor de números inteiros, contendo os valores sobre os 
quais será efetuada a pesquisa; 
 N → Número de elementos do vetor; 
 VlrPesq → Valor objeto da pesquisa; 
Retorno: 
 Um valor de 0 até N-1, indicando a posição no vetor onde o valor 
procurado foi encontrado. 
 -1, Indica que o valor procurado não está presente no vetor. 
-------------------------------------------------------------------------------------*/
inteiro PesqSequencialOrd (inteiro iVet [], inteiro N, inteiro VlrPesq ) 
{ 
 inteiro i; 
 
 para (i ← 0; i < N; i ← i + 1) faça 
 { 
 se ( iVet[ i ] = VlrPesq ) então 
 retorne ( i ); // Encontrado 
 senão 
 se ( iVet [ i ] > VlrPesq ) então 
 retorne (-1); // Não Encontrado 
 fim_se; 
 fim_se; 
 }fim_para; 
 retorne ( -1 ); //Não encontrado 
}; // PesqSequencialOrd 
Quando encontramos um valor 
maior que o procurado, concluímos 
que o mesmo não está presente, 
pois deste ponto em diante os 
valores serão cada vez maiores, 
dado que o vetor está em ordem 
crescente 
 154
IX. 4 Pesquisa Binária 
A pesquisa binária é um método de pesquisa muito 
eficiente se comparado ao método seqüencial, mas só pode ser 
aplicado sobre vetores ordenados. O nome pesquisa binária 
faz referência ao fato do ponto chave do algoritmo ser 
justamente a divisão sucessiva do vetor em duas partes. 
Para melhor compreender o algoritmo, vamos trabalhar 
com um exemplo, considere que inicialmente queremos 
encontrar a posição em que o número 34 está armazenado no 
vetor abaixo. 
Vet 
Índices 0 1 2 3 4 5 6 7 8 9 
Valor 2 12 34 45 48 52 53 60 61 80 
 
1 Inicialmente atribuir para “inicio,” o índice da primeira 
posição do vetor “zero” e para “fim”, o índice a ultima 
posição “nove”. 
2 Dividir o vetor em duas partes iguais, tomando a posição 
meio como alvo da comparação – meio ← (fim + inicio) 
div 2 – logo a posição 4 será considerada como a 
posição “meio” do vetor; 
a. Comparar o valor procurado “34” com o valor 
armazenado na posição tida como meio do vetor ( 
vet[4] = 34 ??? ), neste exemplo vet[4] é 48 
i. Se forem iguais encontrou, logo retornar o índice 
da posição “meio”, fim da pesquisa – não é o caso 
deste exemplo; 
ii. Se não encontrou, então verificar se o valor 
procurado for maior que o valor armazenado na 
 155
posição “meio” ( 34 > vet [meio] ??? ), se for 
descartar a parte inferior do vetor, tomando como 
alvo da pesquisa, somente a parte superior do 
vetor, as posições que estão acima da posição 
“meio” ( inicio ← meio +1). 
iii. Pôr outro lado se o valor procurado for menor que 
o valor da posição tida como meio ( 34 < Vet 
[Meio] ??? ), descartar a parte superior do vetor, e 
prosseguir a pesquisa na parte inferior. Nesse caso 
o fim “lógico” do vetor passa a ser a posição 
“meio – 1” (fim ← meio – 1) 
3 repetir o passo 2 com a parte do vetor atualmente 
considerada para a pesquisa. Esse passo deverá ser 
repetido enquanto o inicio lógico do vetor for menor ou 
igual ao fim lógico do vetor (“inicio” <= “fim” ???). Se 
o inicio se tornar maior que o fim, significará que a 
pesquisa está esgotada e que o valor procurado não se 
encontra armazenado no vetor, retornar (-1) indicando 
tal situação. 
Obs: O valor de retorno –1 não pode ser interpretado como 
uma posição válida para o vetor, uma vez que o índice de um 
vetor começa sempre em zero. Esse é um artifício conhecido 
como valor impossível, e é muito utilizado para a indicação de 
falha. 
 
Ao executarmos o passo 2 no 2º ciclo teremos: inicio = 0 e 
fim = 3, portanto meio = 1. Na posição 1 do vetor, temos o 
valor 12, comparando com o valor procurado 34, concluímos 
que devemos descartar a parte inferior do vetor ( inicio ← 
 156
meio + 1), logo inicio = 2. Comparando inicio e fim conclui-se 
que é necessário repetir o passo 2 novamente pois ( 2 < 3). 
No terceiro ciclo, teremos inicio = 2 e fim = 3, calculando 
meio temos meio = 2 e comparando o valor de Vet na posição 
meio ( Vet[meio] ) com o valor procurado 34 temos uma 
igualdade – Vet[meio] = 34 – logo retornamos o valor 2 que é 
a posição onde o valor 34 está armazenado. 
 
Se estivéssemos procurando pelo valor 35 ao invés de 34, 
concluiríamos que deveríamos descartar a parte inferior do 
vetor, fazendo inicio = meio + 1, e voltaríamos a repetir no 
passo 2 no 4º ciclo, pois “inicio” ainda é menor ou igual a 
“fim”. 
No 4º ciclo teríamos inicio = 3 e fim = 3, portanto meio = 
3. O valor armazenado na posição 3 é 45, como 45 > 35 seria 
descartada a parte superior do vetor fazendo-se fim = meio –1, 
nesse ponto o “fim lógico” do vetor se tornou menor que o 
“inicio lógico” tal fato indica que o valor procurado não está 
presente no vetor e o valor de retorno deve ser –1. 
 
 
 
 
 157
Português Estruturado: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*---------------------------------------------------------------------------------- 
Procedimento: LeituraGrupos; 
Parâmetros: 
 Vet → Um vetor ordenado sobre o qual será realizada a pesquisa; 
 N → O número de elementos do vetor; 
 Pesq → O valor objeto da pesquisa; 
Retorno: 
 Fracasso: –1 → indicando que o valor procurado não está 
armazenado no vetor; 
 Sucesso: Um valor de 0 até N-1, indicando a posição do vetor 
onde o valor procurado está 
armazenado 
---------------------------------------------------------------------------------*/ 
inteiro leituraGrupos (inteiro Vet[ ], inteiro N, inteiro Pesq ) 
{ 
 inteiro Inicio, Fim, Meio; 
 
 Inico ← 0; 
 Fim ← N-1; 
 enquanto ( Inicio <= Fim ) faça 
 { 
 Meio ← (Inicio + Fim ) div 2; 
 se ( Vet [ Meio ] = Pesq ) então 
 retorne ( Meio ); // Encontrado ( Sucesso ) 
 senão 
 se ( Vet [ Meio ] > Pesq ) então 
 Inicio ← Meio + 1; 
 senão 
 Fim ← Meio –1; 
 fim_se; 
 fim_se; 
 }; //fim_enquanto 
 retorne ( -1 ); // Não encontrado ( Fracasso ) 
}; 
 158
 
Capítulo X Estruturas de 
Dados Heterogêneas 
No capítulo VIII você trabalhou com as estruturas de dados 
homogêneas. Tais estruturas possibilitam o armazenamento de 
vários valores de um mesmo tipo numa distribuição contígua 
de forma matricial. 
Embora os vetores e matrizes sejam de grande ajuda, as 
vezes se faz necessário agrupar, num mesmo conjunto de 
dados, informações de vários tipos diferentes mas que só 
possuem um significado quando estão juntas. Pôr exemplo, os 
dados referentes a um cliente ( Nome, Idade, Sexo, Estado 
Civil, RG, CPF, Renda, etc). 
A estrutura de dados heterogênea “registro” é, muitas 
vezes, apontada como a principal estrutura de dados de uma 
linguagem, com ela é possível definiragrupamentos de dados 
de tipos diferentes numa estrutura simples e fácil de 
manipular. Neste capitulo, você terá a oportunidade de 
conhecer a sintaxe de declaração e manipulação dessas 
estruturas. 
 159
X. 1 Tipos de Dados do Usuário 
O mecanismo de definição de tipos permite ao 
programador definir novos tipos de dados, tendo sempre como 
base os tipos básicos preestabelecidos pela linguagem. 
No PORTUGUÊS ESTRUTURADO, a definição de um 
novo tipo deve ser estabelecida acima de todos os 
procedimentos e funções, é o bloco de definições. A 
declaração de um novo tipo é simples, observe a sintaxe 
básica: 
 
define_tipo <tipo base> <Nome do Novo Tipo>; 
Exemplo 1 
 
 
 
 
 
 
 
 
 
 
 
 
define_tipo inteiro TpiVet10 [10]; 
 
nada principal () 
{ 
 TpiVet10 Vetor; 
 inteiro i; 
 
 para ( i ← 0; i ≤ 10; i ← i + 1) faça 
 { 
 escreva ( i,“o número:”); 
 leia ( Vetor[i] ); 
 } fim_para; 
} principal; 
É o mesmo que: 
inteiro Vetor[10]; 
Define TpiVet10 como sendo 
um identificador de tipo para 
um vetor de inteiros com 
capacidade para 10 elementos 
 160
Neste exemplo, foi estabelecido que TpiVet10 é um novo 
tipo de dado. Toda e qualquer variável pertencente a esse tipo 
de dado, é uma matriz unidimensional (vetor) de inteiros com, 
capacidade para 10 elementos. 
A definição de tipos é uma técnica utilizada para melhorar 
a legibilidade e a manutenibilidade de um programa. Essa 
técnica também nos ajuda a gerenciar a complexidade na 
especificação de variáveis locais em procedimentos e funções. 
X. 1.2 Tipos Estruturados Heterogêneos 
A agregação de diferentes dados em uma estrutura de 
dados, possibilita um mecanismo para armazenar e manipular 
informações complexas, aquelas que compõem de mais de um 
dado. O cadastro de um cliente, pôr exemplo: Nome, 
Sobrenome, Data de Nascimento, Sexo, Idade, Endereço, 
telefone, CPF, RG, etc. 
A composição de vários dados de tipos diferentes em um 
conjunto único, define um novo tipo de dado conhecido como 
tipo definido pelo usuário. Cada novo agrupamento de dados 
forma um novo tipo de dados estruturado heterogêneo, uma 
nova estrutura de dados heterogênea. Quando bem utilizada, 
essa é uma ferramenta muito poderosa. 
Antes de poder declarar uma variável como sendo um 
conjunto de dados estruturado, será necessário estabelecer um 
identificador de tipo para a estrutura. Essa definição de tipo 
será necessária sempre que se desejar fazer uso de uma 
estrutura de dados cujo tipo ainda não tenha sido definido. 
A definição de um tipo estruturado heterogêneo, exige uma 
sintaxe apropriada que é apresentada abaixo. 
 161
X. 1.2.1 Sintaxe Básica 
define_tipo registro <Nome do Tipo> 
{ 
 <tipo> <Campo 1>; 
 <tipo> <Campo 2>; 
 : 
 <tipo> <Campo N>; 
}; 
A palavra chave registro indica que o tipo que está sendo 
definido é um tipo estruturado, uma estrutura de dados heterogênea, 
ou seja, pode ser composta pôr vários campos de tipos diferentes. 
Os campos que compõem a estrutura e seus respectivos tipos são 
elencados no bloco após o nome do novo tipo estruturado. 
X. 1.2.2 Acesso aos elementos 
Para acessar os campos internos de uma variável 
estruturada do tipo “registro”, é necessário indicar o nome do 
campo, um ponto é usado como separador entre o nome da 
variável e o nome do campo a ser acessado. Veja o exemplo: 
define_tipo registro TpCadCliente { 
 inteiro Código; 
 frase Nome; 
 inteiro Idade; 
 caracter Sexo 
}; 
 162
Sendo “Reg” e “AuxReg” duas variáveis do tipo 
TpCadCliente, os exemplos abaixo representam operações 
válidas: 
9 Reg ← AuxReg; 
Atribuição de todos os valores armazenados em AuxReg 
para os seus correspondentes em Reg. A partir dessa 
instrução as duas variáveis possuem os mesmos dados; 
 
9 leia( Reg.Código ); 
Indica a entrada de um valor inteiro para ser armazenado 
no campo “Código” da variável “Reg”; 
 
9 escreva (Reg.Nome); 
Indica a apresentação, no vídeo, do dado armazenado no 
campo “Nome” da variável “Reg”; 
 
9 Reg.Sexo ← ‘M’; 
Indica a atribuição do literal ‘M’ ao campo “Sexo” da 
variável “Reg”. 
 
Exemplo 1 
Construir um programa capaz de aceitar a entrada de uma 
lista com 10 grupos de informações. Cada grupo de 
informação é composto pôr (Nome, Sexo, Idade). Ordenar pôr 
idade de forma decrescente e apresentar a lista na nova ordem. 
 163
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*Definição dos tipos necessários */ 
 
/*O tipo TpGrupo define o agrupamento individual das 
informações*/ 
 
define_tipo registro TpGrupo 
{ 
 frase Nome; 
 caracter Sexo; 
 inteiro Idade; 
}; 
 
/*-------------------------------------------------------------------- 
Procedimento: LeituraGrupos; 
Parâmetros: 
 Lista → Lista para armazenar os grupos de dados; 
Descrição: 
 Este procedimento procede a leitura de 10 grupos de 
informação do tipo TpGrupo, Os valores informados pelo 
usuário irão preencher o vetor “Lista” passado como 
parâmetro 
----------------------------------------------------------------------*/ 
 
nada leituraGrupos (TpLista Lista[ ] ) 
{ 
 inteiro i; 
 
 para (i ← 0; i < 10; i ← i + 1) faça 
 { 
 escreva (“Nome: ”); 
 leia ( Lista[ i ].Nome ); 
 escreva (“Sexo: ”); 
 leia ( Lista[ i ].Sexo ); 
 escreva (“Idade: ”); 
 leia ( Lista[ i ].Idade); 
 }fim_para; 
};//leituraCrupos; 
 164
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*-------------------------------------------------------------------- 
Procedimento: OrdenaLista; 
Parâmetros: 
 Lista → vetor que armazena os grupos de dados; 
Descrição: 
 Este procedimento efetua a ordenação decrescente do vetor 
“Lista”, pelo campo “Idade”, através do metodo de ordenação 
BOLHA 
----------------------------------------------------------------------*/ 
nada OrdenaLista (TpLista Lista[ ] ) 
{ 
 inteiro i, j; 
 TpGrupo Aux; 
 
 para ( i ← 0; i < N-1; i ← i + 1) faça 
 { 
 para ( j← i + 1; j < N; j ← j + 1) faça 
 { 
 se ( Lista [ i ].Idade < Lista [ j ].Idade ) então 
 { 
 Aux ← Lista [ i ]; 
 Lista [ i ] ← Lista [ j ]; 
 Lista [ j ] ← Aux; 
 }fim_se; 
 }fim_para; 
 }fim_para; 
 
};//OrdenaLista 
 165
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*-------------------------------------------------------------------- 
Procedimento: ApresentaGrupos; 
Parâmetros: 
 Lista → Vetor que armazena os grupos de dados; 
Descrição: 
 Este procedimento apresenta todos os 10 grupos de dados 
armazenados na Lista. 
----------------------------------------------------------------------*/ 
 
nada ApresentaGrupos (TpLista Lista[ ] ) 
{ 
 inteiro i; 
 
 escreva ( “Nome Sexo Idade ” ); 
 para (i ← 0; i < 10; i ← i + 1) faça 
 { 
 escreva ( Lista[ i ].Nome, Lista[ i ].Sexo, Lista[ i 
].Idade ); 
 }fim_para; 
} //A C
/*-------------------------------------------------------------------- 
Procedimento: principal; 
Parâmetros: 
 nenhum; 
Descrição: 
 Este procedimento representa a rotina principal e é 
responsável por efetuar as chamadas de procedimentos 
necessárias ao desenvolvimento das ações indicadas no 
enunciado do problema. 
----------------------------------------------------------------------*/ 
 
nada principal ( ) 
{ 
 TpLista Lst; 
 
 LeituraGrupos ( Lst ); 
 OrdenaGrupos ( Lst ); 
 ApresentaGrupos ( Lst ); 
}; //principal 
 166
X. Exercícios 
1) Escreva um programa “Endereços” que seja capaz de 
armazenar os seguintes dados deaté 100 clientes: Nome, 
Endereço (Rua, Nº, Apto nº/Casa, Bairro), Telefone, Sexo, 
Idade. O programa deve possuir as características abaixo: 
a) Um menu de opções; 
b) Opção inserir um cliente (observar número máximo); 
c) Opção Pesquisar pelo nome; 
d) Opção Remover um cliente; 
e) Opção Listar todos de um determinado sexo; 
f) Opção Listar todos de uma determinada faixa etária; 
g) Opção Listar todos de um determinado sexo e faixa 
etária.