algoritmosCarlaParte1 (Recovered)

Prévia do material em texto

Algoritmo e Lógica de programação 
- 1 - 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Apostila
Algoritmo e Lógica de Programação 
Agosto / 2017
- 2 - 
 
Capítulo 1 ........................................................................................................... 3 
Introdução....................................................................................................... 3 
1. Conceito de Algoritmo............................................................................. 3 
1.1 Algumas Definições de Algoritmo ......................................................... 3 
Capítulo 2 ........................................................................................................... 4 
Formas de Representação de Algoritmos....................................................... 4 
2.1 Descrição Narrativa............................................................................... 4 
2.2 Fluxograma Convencional..................................................................... 4 
2.3 Pseudocódigo ....................................................................................... 5 
2.4 Síntese .................................................................................................. 6 
Capítulo 3 ........................................................................................................... 7 
Tipos de Dados............................................................................................... 7 
3.1 Dados Numéricos.................................................................................. 7 
3.2 Dados Literais ....................................................................................... 8 
3.3 Dados Lógicos ...................................................................................... 9 
3.4 Síntese .................................................................................................. 9 
3.5 Exercício Proposto .............................................................................. 10 
Capítulo 4 ......................................................................................................... 11 
Variáveis ....................................................................................................... 11 
4.2 Armazenamento de Dados na Memória.............................................. 11 
4.3 Conceito e Utilidade de Variáveis ....................................................... 13 
4.4 Definição de Variáveis em Algoritmos................................................. 14 
4.5 Síntese ................................................................................................ 15 
4.6 Exercícios Propostos........................................................................... 15 
Capítulo 5 ......................................................................................................... 24 
Expressões ................................................................................................... 24 
5.1 Conceito .............................................................................................. 24 
5.2 Operadores ......................................................................................... 24 
5.3 Tipos de Expressões........................................................................... 25 
5.4 Síntese ................................................................................................ 27 
5.6 Exercícios Propostos........................................................................... 28 
Capítulo 6 ......................................................................................................... 27 
Instruções Primitivas..................................................................................... 27 
6.1 Instrução Primitiva de Atribuição......................................................... 28 
6.2 Instrução Primitiva de Saída de Dados ............................................... 29 
6.3 Instrução Primitiva de Entrada de Dados .............................................. 1 
6.4 Síntese ................................................................................................ 32 
6.5 Exercícios Resolvidos ......................................................................... 32 
6.6 Exercícios Propostos........................................................................... 36 
Algoritmo e Lógica de programação 
Algoritmo e Lógica de programação 
- 3 - 
Capítulo 1 
Introdução 
 
1. Conceito de Algoritmo 
 
A automação é o processo em que uma tarefa deixa de ser desempenhada pelo 
homem e passa a ser realizada por máquinas, sejam estes dispositivos mecânicos, eletrônicos 
(como os computadores) ou de natureza mista. 
 
Para que a automação de uma tarefa seja bem-sucedida é necessário que a máquina 
que passará a realizá-la seja capaz de desempenhar cada uma das etapas constituintes do 
processo a ser automatizado com eficiência, de modo a garantir a repetibilidade do mesmo. 
Assim, é necessário que seja especificado com clareza e exatidão o que deve ser realizado em 
cada uma das fases do processo a ser automatizado, bem como a seqüência em que estas 
fases devem ser realizadas. 
 
À especificação da seqüência ordenada de passos que deve ser seguida para a 
realização de uma tarefa, garantindo a sua repetibilidade, dá-se o nome de algoritmo. 
 
Ao contrário do que se pode pensar, o conceito de algoritmo não foi criado para 
satisfazer às necessidades da computação. Pelo contrário, a programação de computadores é 
apenas um dos campos de aplicação dos algoritmos. Na verdade, há inúmeros casos que 
podem exemplificar o uso (involuntário ou não) de algoritmos para a padronização do exercício 
de tarefas rotineiras (vide exemplos da Seção 2.1). No entanto, daqui adiante a atenção desta 
apostila estará voltada à automação de tarefas utilizando computadores. 
 
Para que um computador possa desempenhar uma tarefa é necessário que esta seja 
detalhada passo-a-passo, numa forma compreensível pela máquina, utilizando aquilo que se 
chama de programa. Neste sentido, um programa de computador nada mais é que um 
algoritmo escrito numa forma compreensível pelo computador (linguagem de programação). 
 
1.1 Algumas Definições de Algoritmo 
 
 
"Serve como modelo para programas, pois sua linguagem é intermediária à linguagem 
humana e às linguagens de programação, sendo então, uma boa ferramenta na validação da 
lógica de tarefas a serem automatizadas." 
 
“Os algoritmos, servem para representar a solução de qualquer problema, mas no caso 
do Processamento de Dados, eles devem seguir as regras básicas de programação para que 
sejam compatíveis com as linguagens de programação.” 
Algoritmo e Lógica de programação 
- 4 - 
 
Capítulo 2 
 
Formas de Representação de Algoritmos 
 
Existem diversas formas de representação de algoritmos, mas não há um consenso 
com relação à melhor delas. 
 
O critério usado para classificar hierarquicamente estas formas está diretamente ligado 
ao nível de detalhe ou, inversamente, ao grau de abstração oferecido. 
 
Algumas formas de representação de algoritmos tratam os problemas apenas em nível 
lógico, abstraindo-se de detalhes de implementação muitas vezes relacionados com alguma 
linguagem de programação específica. Por outro lado existem formas de representação de 
algoritmos que possuem uma maior riqueza de detalhes e muitas vezes acabam por 
obscurecer as idéias principais do algoritmo, dificultando seu entendimento. 
 
Dentre as formas de representação de algoritmos mais conhecidas podemos citar: 
 
ƒ Descrição Narrativa; 
 
ƒ Fluxograma Convencional; 
 
ƒ Pseudocódigo, também conhecido como Linguagem Estruturada ou Portugol. 
 
2.1 Descrição Narrativa 
 
Nesta forma de representaçãoos algoritmos são expressos diretamente em linguagem 
natural. Como exemplo, têm-se os algoritmos seguintes: 
 
 
ƒ Receita de bolo: 
 
Misture os ingredientes 
Unte a forma com manteiga 
Despeje a mistura na forma 
Se houver coco ralado 
então despeje sobre a mistura 
Leve a forma ao forno 
Enquanto não corar 
deixe a forma no forno 
Retire do forno 
Deixe esfriar 
 
ƒ Troca de um pneu furado: 
 
Afrouxar ligeiramente as porcas 
Suspender o carro 
Retirar as porcas e o pneu 
Colocar o pneu reserva 
Apertar as porcas 
Abaixar o carro 
Dar o aperto final nas porcas 
ƒ Tomando um banho: 
 
Entrar no banheiro e tirar a roupa 
Abrir a torneira do chuveiro 
Entrar na água 
Ensaboar-se 
Sair da água 
Fechar a torneira 
Enxugar-se 
Vestir-se 
 
 
 
 
ƒ Cálculo da média de um aluno: 
 
Obter as suas 2 notas de provas 
Calcular a média aritmética 
Se a média for maior que 7, 
o aluno foi aprovado, 
senão ele foi reprovado 
Algoritmo e Lógica de programação 
- 4 - 
Esta representação é pouco usada na prática porque o uso da linguagem natural 
muitas vezes dá oportunidade a más interpretações, ambigüidades e imprecisões. 
 
Por exemplo, a instrução "afrouxar ligeiramente as porcas" no algoritmo da troca de 
pneus está sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais 
precisa seria: "afrouxar a porca, girando-a 30º no sentido anti-horário". 
 
2.2 Fluxograma Convencional 
 
É uma representação gráfica de algoritmos onde formas geométricas diferentes 
implicam ações (instruções, comandos) distintos. Tal propriedade facilita o entendimento das 
idéias contidas nos algoritmos e justifica sua popularidade. 
 
Esta forma é aproximadamente intermediária à descrição narrativa e ao pseudocódigo 
(subitem seguinte), pois é menos imprecisa que a primeira e, no entanto, não se preocupa com 
detalhes de implementação do programa, como o tipo das variáveis usadas. 
 
Nota-se que os fluxogramas convencionais preocupam-se com detalhes de nível físico 
da implementação do algoritmo. Por exemplo, figuras geométricas diferentes são adotadas 
para representar operações de saída de dados realizadas em dispositivos distintos, como uma 
fita magnética ou um monitor de vídeo. Como esta apostila não está interessada em detalhes 
físicos da implementação, mas tão somente com o nível lógico das instruções do algoritmo, 
será adotada a notação simplificada da Figura 2.1 para os fluxogramas. De qualquer modo, o 
Apêndice A contém uma tabela com os símbolos mais comuns nos fluxogramas convencionais. 
 
Início e final do fluxograma
Operação de entrada de dados
Operação de saída de dados
Operação de atribuição
Decisão
 
 
Figura 2.1 Principais formas geométricas usadas em fluxogramas. 
 
 
Algoritmo e Lógica de programação 
- 5 - 
De modo geral, um fluxograma se resume a um único símbolo inicial por onde a 
execução do algoritmo começa, e um ou mais símbolos finais, que são pontos onde a 
execução do algoritmo se encerra. Partindo do símbolo inicial, há sempre um único caminho 
orientado a ser seguido, representando a existência de uma única seqüência de execução das 
instruções. Isto pode ser melhor visualizado pelo fato de que, apesar de vários caminhos 
poderem convergir para uma mesma figura do diagrama, há sempre um único caminho saindo 
desta. Exceções a esta regra são os símbolos finais, dos quais não há nenhum fluxo saindo, e 
os símbolos de decisão, de onde pode haver mais de um caminho de saída (usualmente dois 
caminhos), representando uma bifurcação no fluxo. 
 
A Figura 2.2 mostra a representação do algoritmo de cálculo da média de um aluno sob 
a forma de um fluxograma. 
 
Início
N1, N2
"Aprovado"
MEDIA aaa
(N1 + N2) / 2
MEDIA >= 7
"Reprovado"
Fim
.V. .F.
 
 
Figura 2.2 Exemplo de um fluxograma convencional. 
 
2.3 Pseudocódigo 
 
Esta forma de representação de algoritmos é rica em detalhes, como a definição dos 
tipos das variáveis usadas no algoritmo. Por assemelhar-se bastante à forma em que os 
programas são escritos, encontra muita aceitação. 
 
Na verdade, esta representação é suficientemente geral para permitir a tradução de um 
algoritmo nela representado para uma linguagem de programação específica seja praticamente 
direta. 
 
A forma geral da representação de um algoritmo na forma de pseudocódigo é a 
seguinte: 
Algoritmo e Lógica de programação 
- 6 - 
Algoritmo <nome_do_algoritmo> 
 <declaração_de_variáveis> 
 <subalgoritmos> 
Início 
 <corpo do algoritmo> 
Fim 
 
Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de 
pseudocódigo. 
 
<nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalidade de 
distingui-los dos demais. 
 
<declaração_de_variáveis> consiste em uma porção opcional onde são declaradas 
as variáveis globais usadas no algoritmo principal e, eventualmente, nos subalgoritmos. 
 
<subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são 
definidos os subalgoritmos (Capítulo 8). 
 
Início e Fim são respectivamente as palavras que delimitam o início e o término do 
conjunto de instruções do corpo do algoritmo. 
 
Como exemplo, a Figura 2.3 mostra a representação do algoritmo do cálculo da média 
de um aluno, na forma de um pseudocódigo. 
 
Algoritmo Calculo_Media 
Var N1, N2, MEDIA: real 
Início 
Leia N1, N2 
MEDIA ← (N1 + N2) / 2 
Se MEDIA >= 7 então 
Escreva “Aprovado” 
Senão 
Escreva “Reprovado” 
Fim_se 
Fim 
 
Figura 2.3 Exemplo de um pseudocódigo. 
 
2.4 Síntese 
 
Há diversas formas de representação de algoritmos que diferem entre si pela 
quantidade de detalhes de implementação que fornecem ou, inversamente, pelo grau de 
abstração que possibilitam com relação à implementação do algoritmo em termos de uma 
linguagem de programação específica. 
 
Dentre as principais formas de representação de algoritmos destacam-se: a descrição 
narrativa, o fluxograma convencional e o pseudocódigo (ou linguagem estruturada). 
 
Algoritmo e Lógica de programação 
- 7 - 
Capítulo 3 
 
Tipos de Dados 
 
Todo o trabalho realizado por um computador é baseado na manipulação das 
informações contidas em sua memória. Grosso modo, estas informações podem ser 
classificadas em dois tipos: 
 
ƒ As instruções, que comandam o funcionamento da máquina e determinam a 
maneira como devem ser tratados os dados. As instruções são específicas para 
cada modelo de computador, pois são funções do tipo particular de processador 
utilizado em sua implementação. 
 
ƒ Os dados propriamente ditos, que correspondem à porção das informações a 
serem processadas pelo computador. 
 
A maior parte das pessoas não ligadas à área de informática ignora o potencial dos 
computadores e imagina que eles são capazes de tratar apenas com dados numéricos. Na 
realidade, a capacidade dos mesmos se estende a outros tipos de dados. 
 
O objetivo deste capítulo é justamente o de classificar os dados de acordo com o tipo 
de informação contida neles. A classificação apresentada não se aplica a nenhuma linguagem 
de programação específica; pelo contrário, ela sintetiza os padrões utilizados na maioria das 
linguagens. 
 
3.1 Dados Numéricos 
 
Antes de apresentar formalmente os tipos de dados numéricos, é conveniente recordar 
alguns conceitos básicos relacionados à teoria dos números e conjuntos. 
 
O conjunto dos números naturais é representado por N e é dado por: 
 
N = {1, 2, 3, 4, ...} 
 
Algumas correntes de matemáticos teóricos convencionam que o número 0 está 
contido neste conjunto; contudo, não convém perder tempo em tais discussões filosóficas, uma 
vez que isto não influenciará de forma alguma este estudo. 
 
Na seqüência, encontramos o conjunto dos números inteiros: 
 
Z = {...,-3, -2, -1, 0, 1, 2, 3, ...} 
 
O conjunto Z contém todos os elementos de N, bem como alguns números que não 
pertencem a N (os números negativos e o zero). Portanto, dizemos que N está contido em Z, 
ou então, que Z contém N. 
 
Englobando o conjunto dos números inteiros, existe o conjunto dos números 
fracionários (Q), dado pelo universo dos números que podem ser expressos na forma de uma 
fração, isto é, um quociente onde o numerador e o denominador são números inteiros. Mais 
formalmente: 
 
Q = ( p/q | p, q pertencem a Z} 
 
Algoritmo e Lógica de programação 
- 8 - 
Por último, surge o conjunto dos números reais (R), formado pela união do conjunto 
dos números fracionários Q com o conjunto dos números que não podem ser expressos na 
forma de uma fração (os números irracionais). Ex.: 2 = 1.1412... , PI = 3.14159... 
 
 
3.1.1 Dados Numéricos Inteiros 
 
Os números inteiros são aqueles que não possuem componentes decimais ou 
fracionários, podendo ser positivos ou negativos. 
 
Os elementos pertencentes aos conjuntos N e Z, apesar de serem representáveis na 
classe dos números reais, são classificados como dados do tipo inteiro, por não possuírem 
parte fracionária. Esta possibilidade é interessante por permitir uma economia do espaço de 
memória, como veremos adiante. 
 
Por sua vez, os elementos dos conjuntos Q e R, por possuírem parte fracionária, não 
podem ser representados na classe inteira, pertencendo necessariamente aos tipos de dados 
ditos reais. 
 
Como exemplos de números inteiros temos: 
 
24 - número inteiro positivo 
 
0 - número inteiro 
 
-12 - número inteiro negativo 
 
3.1.2 Dados Numéricos Reais 
 
Os dados de tipo real são aqueles que podem possuir componentes decimais ou 
fracionários, e podem também ser positivos ou negativos. 
 
Como dito anteriormente, os elementos dos conjuntos de números fracionários e reais 
são necessariamente representados no computador por dados do tipo real. 
 
Exemplos de dados do tipo real: 
 
24.01 - número real positivo com duas casas decimais 
 
144. - número real positivo com zero casas decimais 
 
-13.3 - número real negativo com uma casa decimal 
 
0.0 - número real com uma casa decimal 
 
0. - número real com zero casas decimais 
 
Observe que há uma diferença entre “0”, que é um dado do tipo inteiro “0.” (ou “0.0”) 
que é um dado do tipo real. Portanto, a simples existência do ponto decimal serve para 
diferenciar um dado numérico do tipo inteiro de um do tipo real. 
 
3.2 Dados Literais 
 
O tipo de dados literal é constituído por uma seqüência de caracteres contendo letras, 
dígitos e/ou símbolos especiais. Este tipo de dados é também muitas vezes chamado de 
alfanumérico, cadeia (ou cordão) de caracteres, ainda, do inglês, string. 
Algoritmo e Lógica de programação 
- 9 - 
 
Usualmente, os dados literais são representados nos algoritmos pela coleção de 
caracteres, delimitada em seu início e término com o caractere aspas ("). 
 
Diz-se que o dado do tipo literal possui um comprimento dado pelo número de 
caracteres nele contido. 
 
Exemplos de dados do tipo literal: 
 
"QUAL ?" - literal de comprimento 6 
 
" " - literal de comprimento 1 
 
"qUaL ?!$" - literal de comprimento 8 
 
" AbCdefGHi" - literal de comprimento 9 
 
"1-2+3=" - literal de comprimento 6 
 
“0” - literal de comprimento 1 
 
Note que, por exemplo, "1.2" representa um dado do tipo literal de comprimento 3, 
constituído pelos caracteres "1", "." e "2", diferindo de 1.2 que é um dado do tipo real. 
 
3.3 Dados Lógicos 
 
A existência deste tipo de dado é, de certo modo, um reflexo da maneira como os 
computadores funcionam. Muitas vezes, estes tipos de dados são chamados de booleanos, 
devido à significativa contribuição de BOOLE à área da lógica matemática. 
 
O tipo de dados lógico é usado para representar dois únicos valores lógicos possíveis: 
verdadeiro e falso. É comum encontrar-se em outras referências outros tipos de pares de 
valores lógicos como sim/não, 1/0, true/false. 
 
Nos algoritmos apresentados nesta apostila os valores lógicos serão delimitados pelo 
caractere ponto (.). 
 
Exemplo: 
 
.V. - valor lógico verdadeiro 
 
.F. - valor lógico falso 
 
3.4 Síntese 
 
Os dados numéricos dividem-se em duas classes: 
 
ƒ inteiros, que não possuem parte fracionária e podem ser positivos ou negativos; 
 
ƒ reais, que podem possuir parte fracionária e podem ser positivos ou negativos. 
 
Os dados do tipo literal podem conter seqüências de letras, dígitos ou símbolos 
especiais, delimitados por aspas ("). Seu comprimento é dado pelo número de caracteres em 
string. 
 
Algoritmo e Lógica de programação 
- 10 - 
Os dados do tipo lógico só possuem dois valores possíveis (.V. e .F.). 
 
A árvore abaixo resume a classificação dos dados com relação aos tipos de dados 
apresentados. 
 
 
 
Figura 3.2 Representação dos diversos tipos de dados 
 
3.5 Exercício Proposto 
 
1. Classifique os dados especificados abaixo de acordo com seu tipo, assinalando com I os 
dados do tipo inteiro, com R os reais, com L os literais, com B os lógicos (booleanos), e 
com N aqueles para os quais não é possível definir a priori um tipo de dado. 
 
( ) 0.21 
( ) 1 
( ) V 
( ) “0.” 
( ) 1% 
( ) “José” 
( ) 0,35 
( ) .F. 
( ) -0.001 
( ) .T. 
( ) +3257 
( ) “a” 
( ) “+3257” 
( ) +3257. 
( ) “-0.0” 
( ) “.F.” 
( ) ± 3 
( ) .V. 
( ) .V 
( ) “abc” 
( ) F 
( ) C 
( ) Maria 
( ) +36 
Algoritmo e Lógica de programação 
- 11 - 
Capítulo 4 
 
Variáveis 
 
A todo momento durante a execução de qualquer tipo de programa os computadores 
estão manipulando informações representadas pelos diferentes tipos de dados descritos no 
capítulo anterior. Para que não se "esqueça" das informações, o computador precisa guardá-
las em sua memória. 
 
Este capítulo é destinado ao estudo da forma como os computadores armazenam e 
acessam informações contidas em sua memória. 
 
4.2 Armazenamento de Dados na Memória 
 
Cada um dos diversos tipos de dados apresentados no capítulo anterior necessita de 
uma certa quantidade de memória para armazenar a informação representada por eles. 
 
Esta quantidade é função do tipo de dado considerado, do tipo da máquina 
(computador) e do tipo de linguagem de programação. Por isso, o que será exposto nos 
subitens seguintes não deve ser tomado como padrão, apenas como exemplo. 
 
4.2.1 Armazenamento de Dados do Tipo Literal 
 
Devemos sempre ter em mente que um byte consegue representar 256 (28) 
possibilidades diferentes. 
 
Uma informação do tipo literal nada mais é do que um conjunto de caracteres que 
podem ser letras, dígitos ou símbolos especiais. 
 
A união de todos os caracteres existentes nos computadores resulta num conjunto com 
um número de elementos menor que 256. Deste resultado surgiu a idéia de associar a cada 
caractere um número (código) variando de 0 a 255 (256 possibilidades). No princípio, cada 
fabricante de computador adotava uma convenção diferente para este código. Mais 
recentemente, esta convenção foi padronizada a fim de facilitar a portabilidade (migração) de 
programas entre máquinas diferentes. Esta convenção é representada na forma de uma tabela 
de mapeamento de caracteres em números. O padrão mais universalmente aceito é o ASCII, 
cuja tabela é mostrada no Apêndice B. 
 
Assim, cada célula de memória (byte) pode conter um caractere, representado pelo seu 
código ASCII. 
 
Retornando à questão do armazenamento de informações do tipo literal na memória, 
deve-se lembrar que um dado deste tipo possui um certo comprimento dado pelo número de 
caracteres nele contido. Portanto, para guardar um dado do tipo literal devemos alocar 
(reservar) um espaço contíguo de memória igual ao comprimentodo mesmo, destinando um 
byte para cada caractere da informação. 
 
Exemplificando, a informação do tipo literal "banana" possui seis caracteres e, portanto, 
seis bytes são necessários para reter a referida informação na memória. A princípio, estes 
bytes podem estar em qualquer lugar da memória, mas é conveniente que estejam juntos 
(posições contíguas). A primeira posição deste conjunto de bytes é absolutamente arbitrária e 
sua escolha geralmente é feita automaticamente pelo compilador (isto é, pelo programa que 
Algoritmo e Lógica de programação 
- 12 - 
traduz um outro escrito em alguma linguagem de programação para outra geral, a linguagem 
de máquina do computador com que se trabalha). 
 
A Figura 4.3 mostra o caso em que se armazena a literal "banana" no conjunto de seis 
bytes contíguos de memória iniciando pela posição de memória 0. Na verdade, ao invés dos 
caracteres da literal, os códigos correspondentes aos mesmos é que são guardados na 
memória. 
 
 
Endereço Informação 
0 b (98) 
1 a (97) 
2 n (110) 
3 a (97) 
4 n (110) 
5 a (97) 
 
Figura 4.3 Armazenamento da literal “banana” na memória de um computador. 
 
4.2.2 Armazenamento de Dados do Tipo Lógico 
 
Uma informação do tipo lógico só possui dois valores possíveis: .V. ou .F.. Assim, a 
princípio, um único bit seria suficiente para armazenar uma informação deste tipo. Contudo, 
deve-se lembrar que a menor porção de memória que se pode acessar é o byte. Portanto, uma 
informação do tipo lógico é armazenada em um byte de memória. De certa forma, se por um 
lado isto pode ser como um "desperdício" de memória, por outro simplifica bastante a 
arquitetura de memória dos computadores (por motivos que fogem ao contexto desta apostila). 
Além do mais, isto não é tão relevante, uma vez que na prática o número de ocorrências de 
dados do tipo lógico é bastante inferior ao de ocorrências de dados do tipo literal ou numérico. 
 
4.2.3 Armazenamento de Dados do Tipo Inteiro 
 
O conjunto dos números inteiros (Z) contém um número infinito de elementos: 
 
Z = { -∞, ..., -3, -2, -1, 0, 1, 2, 3, ..., +∞} 
 
Obviamente é inviável o armazenamento de todos os números deste conjunto num 
computador. Faz-se necessário realizar um estudo para que se limite o número de elementos 
representáveis deste conjunto. 
 
Se apenas um byte fosse utilizado para armazenar os dados do tipo inteiro, existiriam 
apenas 256 números diferentes neste conjunto: 
 
{-127, -126, ..., -2, -1, 0, 1, 2, ..., 127, 128) 
 
Esta restrição é bastante forte, uma vez que boa parte das aplicações práticas 
necessitam de números inteiros maiores que estes. 
 
Se forem utilizados dois bytes para armazenar um número inteiro, o universo de 
números representáveis cresce para 28 x 28 = 216 = 65.536 possibilidades: 
 
{-32767, -32766, ..., -2, -1, 0, 1, 2, ..., 32767, 32768} 
 
Este conjunto satisfaz à grande maioria das necessidades práticas. Assim, em geral 
utilizam-se dois bytes para representar os números inteiros em computadores. Contudo, restam 
algumas aplicações muito específicas em que se precisa de um conjunto ainda maior. Para 
Algoritmo e Lógica de programação 
- 13 - 
estes casos, algumas linguagens de programação fornecem mecanismos para trabalhar 
números inteiros com quatro bytes. Nestes casos os dados são ditos inteiros longos ou 
estendidos. 
 
4.2.4 Armazenamento de Dados do Tipo Real 
 
O conjunto dos números reais (R) contém um número infinito de elementos e, pelas 
mesmas razões que o conjunto dos números inteiros, precisa ser limitado. 
 
Para dados deste tipo julgou-se apropriado adotar quatro bytes para sua representação 
interna nos computadores. 
 
São muito comuns situações como as aplicações científicas em que é necessária uma 
maior precisão de cálculo, intimamente ligada ao número de casas decimais dos dados. Para 
este caso, em analogia com o que acontece com os dados do tipo inteiro, algumas linguagens 
de programação decidiram criar dados do tipo real estendido (com oito bytes). 
 
4.3 Conceito e Utilidade de Variáveis 
 
Como visto anteriormente, informações correspondentes a diversos tipos de dados são 
armazenadas na memória dos computadores. Para acessar individualmente cada uma destas 
informações, a princípio, seria necessário saber o tipo de dado desta informação (ou seja, o 
número de bytes de memória por ela ocupados) e a posição inicial deste conjunto de bytes na 
memória. 
 
Percebe-se que esta sistemática de acesso a informações na memória é bastante 
ilegível e difícil de se trabalhar. Para contornar esta situação criou-se o conceito de variável, 
que é uma entidade destinada a guardar uma informação. 
 
Basicamente, uma variável possui três atributos: um nome, um tipo de dado 
associado à mesma e a informação por ela guardada. 
 
Nome
Tipo de
dado
Informação
 
 
Figura 4.4 Atributos de uma variável. 
 
Toda variável possui um nome que tem a função de diferenciá-la das demais. Cada 
linguagem de programação estabelece suas próprias regras de formação de nomes de 
variáveis. Adotaremos nesta apostila as seguintes regras: 
 
ƒ um nome de variável deve necessariamente começar com uma letra; 
ƒ um nome de variável não deve conter nenhum símbolo especial exceto a sublinha 
(_). 
 
Exemplos: 
Algoritmo e Lógica de programação 
- 14 - 
 
SALARIO 
1ANO 
ANO1 
A CASA 
SAL/HORA 
SAL_HORA 
_DESCONTO 
= correto 
= errado (não começou com uma letra) 
= correto 
= errado (contém o caractere espaço em branco) 
= errado (contém o caractere "/”) 
= correto 
= errado (não começou com uma letra) 
 
4.4 Definição de Variáveis em Algoritmos 
 
Todas as variáveis utilizadas em algoritmos devem ser definidas antes de serem 
utilizadas. Isto se faz necessário para permitir que o compilador reserve um espaço na 
memória para as mesmas. 
 
Nos algoritmos apresentados nesta apostila será adotada a seguinte convenção: 
 
ƒ todas as variáveis utilizadas em algoritmos serão definidas no início do mesmo, por 
meio de um comando de uma das formas seguintes: 
 
VAR <nome_da_variável> : <tipo_da_variável> 
 
VAR <lista_de_variáveis> : <tipo_das_variáveis> 
 
ƒ a palavra-chave VAR deverá estar presente sempre e será utilizada uma única vez na 
definição de um conjunto de uma ou mais variáveis; 
 
ƒ numa mesma linha poderão ser definidas uma ou mais variáveis do mesmo tipo. Para 
tal, deve-se separar os nomes das mesmas por vírgulas; 
 
ƒ variáveis de tipos diferentes devem ser declaradas em linhas diferentes. 
 
A forma de utilização deste comando ficará mais clara quando da utilização da 
representação de algoritmos em linguagem estruturada (pseudocódigo). 
 
Esta convenção é válida para a representação de algoritmos na forma de pseudocódigo. 
Em termos de fluxograma, não é usual adotar-se qualquer forma de definição de variáveis. 
 
Exemplo de definição de variáveis: 
 
VAR NOME : literal[10] 
 IDADE : inteiro 
 SALARIO : real 
 TEM_FILHOS : lógico 
 
No exemplo acima foram declaradas quatro variáveis: 
 
ƒ a variável NOME, capaz de armazenar dados literais de comprimento 10 (dez 
caracteres); 
 
ƒ a variável IDADE, capaz de armazenar um número inteiro; 
 
ƒ a variável SALARIO, capaz de armazenar um número real; 
 
ƒ a variável TEM_FILHOS, capaz de armazenar uma informação lógica. 
 
Algoritmo e Lógica de programação 
- 15 - 
4.5 Síntese 
 
A memória dos computadores é composta por células numeradas ordenadamente 
denominadas bytes. Cada byte é constituído por 8 bits. 
 
Cada tipo de dado requer um número diferente de bytes para armazenar a informação 
representada por ele na memória. Esta quantidade também pode variar em função do tipo de 
computador considerado. 
 
Uma variável é uma entidade dotada de um nome para diferenciá-ladas demais e um 
tipo de dado que define o tipo de informação que ela é capaz de guardar. Uma vez definidos, 
o nome e o tipo de uma variável não podem ser alterados no decorrer de um programa. Por 
outro lado, a informação útil da variável é objeto de constante modificação durante o decorrer 
do programa, de acordo com o fluxo de execução do mesmo. 
 
4.6 Exercícios Propostos 
 
1. Assinale com C os identificadores corretos e com I os incorretos. Explique o que está 
errado nos identificadores incorretos. 
 
( ) valor 
( ) _b248 
( ) nota*do*aluno 
( ) a1b2c3 
( ) 3 x 4 
( ) Maria 
( ) km/h 
( ) xyz 
( ) nome empresa 
( ) sala_215 
( ) “nota” 
( ) ah! 
 
 
2. Supondo que as variáveis NB, NA, NMAT e SX sejam utilizadas para armazenar a nota 
do aluno, o nome do aluno, o número da matrícula e o sexo, declare-as corretamente, 
associando o tipo adequado ao dado que será armazenado. 
 
Algoritmo e Lógica de programação 
- 24 - 
Capítulo 5 
 
Expressões 
 
5.1 Conceito 
 
O conceito de expressão em termos computacionais está intimamente ligado ao 
conceito de expressão (ou fórmula) matemática, onde um conjunto de variáveis e constantes 
numéricas relacionam-se por meio de operadores aritméticos compondo uma fórmula que, uma 
vez avaliada, resulta num valor. 
 
 
 
Figura 5.1 Triângulo de base (B) e altura (H). 
 
 
Por exemplo, a fórmula de cálculo da área do triângulo da Figura 5.1 é dada por: 
 
AREA = 0.5 x B x H 
 
Esta fórmula utiliza três variáveis: B e H, que contêm as dimensões do triângulo, e 
AREA, onde é guardado o valor calculado (resultado da avaliação da expressão). Há, também, 
uma constante (0.5) e o operador de multiplicação (x), que aparece duas vezes na expressão. 
 
O conceito de expressão aplicado à computação assume uma conotação mais ampla: 
uma expressão é uma combinação de variáveis, constantes e operadores, e que, uma vez 
avaliada, resulta num valor. 
 
5.2 Operadores 
 
Operadores são elementos funcionais que atuam sobre operandos e produzem um 
determinado resultado. Por exemplo, a expressão 3 + 2 relaciona dois operandos (os números 
3 e 2) por meio do operador (+) que representa a operação de adição. 
 
De acordo com o número de operandos sobre os quais os operadores atuam, os 
últimos podem ser classificados em: 
 
ƒ binários, quando atuam sobre dois operandos. Ex.: os operadores das operações 
aritméticas básicas (soma, subtração, multiplicação e divisão); 
Algoritmo e Lógica de programação 
- 25 - 
ƒ unários, quando atuam sobre um único operando. Ex.: o sinal de (-) na frente de 
um número, cuja função é inverter seu sinal. 
 
Outra classificação dos operadores é feita considerando-se o tipo de dado de seus 
operandos e do valor resultante de sua avaliação. Segundo esta classificação, os operadores 
dividem-se em aritméticos, lógicos e literais. Esta divisão está diretamente relacionada com 
o tipo de expressão onde aparecem os operadores. 
 
Um caso especial é o dos operadores relacionais, que permitem comparar pares de 
operandos de tipos de dados iguais, resultando sempre num valor lógico. 
 
Mais adiante serão apresentados os operadores dos diversos tipos acima relacionados. 
 
5.3 Tipos de Expressões 
 
As expressões são classificadas de acordo com o tipo do valor resultante de sua 
avaliação. 
 
5.3.1 Expressões Aritméticas 
 
Expressões aritméticas são aquelas cujo resultado da avaliação é do tipo numérico, 
seja ele inteiro ou real. Somente o uso de operadores aritméticos e variáveis numéricas é 
permitido em expressões deste tipo. 
 
Os operadores aritméticos relacionados às operações aritméticas básicas estão 
sumarizados na Tabela 5.1. 
 
Tabela 5.1 Operadores aritméticos e sua ordem de prioridade. 
 
Operador Tipo Operação Prioridade 
+ Binário Adição 4 
- Binário Subtração 4 
* Binário Multiplicação 3 
/ Binário Divisão 3 
** Binário Exponenciação 2 
+ Unário Manutenção de sinal 1 
- Unário Inversão de sinal 1 
 
A prioridade entre operadores define a ordem em que os mesmos devem ser avaliados 
dentro de uma mesma expressão. Este assunto será tratado com maior profundidade numa 
seção posterior. 
 
O caractere (*) é adotado na maioria das linguagens de programação para representar 
a operação de multiplicação, ao invés do caractere (x), devido à possibilidade da ocorrência do 
mesmo no nome de variáveis. Pela mesma razão, o símbolo (**) é adotado para representar a 
operação de exponenciação. Algumas linguagens de programação adotam o símbolo (^ - 
circunflexo) para esta finalidade, mas isto é pouco freqüente. 
 
As variáveis usadas em expressões aritméticas podem somente ser do tipo inteiro ou 
real. Se todas as variáveis que aparecem numa expressão são do tipo inteiro, então o valor 
resultante da expressão é também do tipo inteiro. Se ao menos uma das variáveis da 
expressão aritmética for do tipo real, então o valor resultante da avaliação da expressão é 
necessariamente do tipo real. 
 
Nos exemplos seguintes, assumiremos que: 
 
Algoritmo e Lógica de programação 
- 26 - 
ƒ A, B e C são variáveis do tipo inteiro; 
 
ƒ X, Y e Z são variáveis do tipo real. 
 
Exemplos: 
 
A + B * C = expressão de resultado inteiro 
A + B + Y = expressão de resultado real 
A / B = expressão de resultado real 
X / Y = expressão de resultado real 
 
5.3.2 Expressões Lógicas 
 
Expressões lógicas são aquelas cujo resultado da avaliação é um valor lógico (.V. ou 
.F.). 
 
Os operadores lógicos e suas relações de precedência são mostrados na Tabela 5.2. 
 
Existem outros operadores lógicos, como por exemplo o OU_EXCLUSIVO., mas suas 
funções podem ser exercidas por combinações dos três tipos de operadores da Tabela 5.2. 
 
Tabela 5.2 Operadores lógicos e suas relações de prioridade. 
 
Operador Tipo Operação Prioridade 
.OU. Binário Disjunção 3 
.E. Binário Conjunção 2 
.NÃO. Unário Negação 1 
 
Para exemplificar o uso de operadores lógicos, a Tabela 5.3 apresenta duas variáveis 
lógicas A e B. Uma vez que cada variável lógica possui somente dois valores possíveis, então 
há exatamente quatro combinações para estes valores, razão pela qual a tabela tem quatro 
linhas. As diversas colunas contêm os resultados das operações lógicas sobre as combinações 
possíveis dos valores das variáveis A e B. 
 
Tabela 5.3 Tabela-Verdade dos operadores apresentados na Tabela 5.2. 
 
A B .NÃO. A .NÃO. B A .OU. B A .E. B 
.F. .F. .V. .V. .F. .F. 
.F. .V. .V. .F. .V. .F. 
.V. .F. .F. .V. .V. .F. 
.V. .V. .F. .F. .V. .V. 
 
Tabelas como a da Figura 5.3 são chamadas de Tabelas-Verdade. Convém salientar 
as seguintes conclusões que podem ser extraídas por observação da Tabela 5.3: 
 
ƒ O operador lógico .NÃO. sempre inverte o valor de seu operando. Ex.: .NÃO. .V. = 
.F. e .NÃO. .F. = .V.; 
 
ƒ Para que a operação lógica .OU. tenha resultado verdadeiro basta que um de seus 
operandos seja verdadeiro; Para melhor visualizar este efeito, podemos imaginar 
que as variáveis lógicas A e B são como dois interruptores ligados em paralelo 
num circuito de acionamento de uma lâmpada (Figura 5.2). 
 
Algoritmo e Lógica de programação 
- 27 - 
 
Nas expressões lógicas onde aparecem apenas os operadores lógicos da Tabela 5.2 
somente variáveis do tipo lógico podem ser usadas. Isto parece óbvio, uma vez que os 
operadores lógicos somente atuam sobre valores (constantes ou variáveis) lógicos. 
 
Há, ainda, outro tipo de operador que pode aparecer em operações lógicas: os 
operadores relacionais, mostrados na Tabela 5.4. 
 
 
Tabela 5.4 Operadores relacionais. 
 
Operador Operação 
= Igual 
<> Diferente 
< Menor 
<= Menor ou igual 
> Maior 
>= Maior ou igual 
 
Estes operadores são somente usados quando se deseja efetuar comparações. 
Comparações sópodem ser feitas entre objetos de mesma natureza, isto é, variáveis do 
mesmo tipo de dado. O resultado de uma comparação é sempre um valor lógico. 
 
O uso de operadores relacionais possibilita o aparecimento em expressões lógicas de 
variáveis de outros tipos de dados que não o lógico. 
 
 
5.3.3 Expressões Literais 
 
Expressões literais são aquelas cujo resultado da avaliação é um valor literal. Este tipo 
de expressão é bem menos freqüente que os anteriores. Os tipos de operadores existentes 
variam de uma linguagem de programação para outra, não havendo uma padronização. 
 
Para que o assunto não passe em branco, considere-se como exemplo a operação de 
concatenação de strings: toma-se duas strings e acrescenta-se (concatena-se) a segunda 
delas ao final da primeira. Em algumas linguagens esta operação é representada pelo símbolo 
(+). Por exemplo, a concatenação das strings "REFRIGERA" e "DOR" é representada por 
"REFRIGERA" + "DOR" e o resultado de sua avaliação é "REFRIGERADOR". 
 
5.4 Síntese 
 
Uma expressão é uma combinação de variáveis, constantes e operadores, que resulta 
num valor quando avaliada. 
 
Operadores são elementos funcionais que atuam sobre operandos. Segundo o 
número de operandos sobre os quais atua, um operador pode ser classificado em unário ou 
binário. Segundo os tipos de dados de seus operandos e do valor resultante de sua avaliação, 
os operadores podem ser classificados em aritméticos, lógicos ou literais. 
 
Um tipo especial de operador é o relacional, que é usado na comparação de 
operandos de um mesmo tipo de dado e cujo resultado da avaliação é sempre um valor lógico. 
 
As expressões são classificadas de acordo com o valor resultante de sua avaliação em: 
 
ƒ Aritméticas, que resultam num valor numérico (real ou inteiro); 
 
Algoritmo e Lógica de programação 
- 28 - 
ƒ Lógicas, que resultam num valor lógico; 
 
ƒ Literais, que resultam num valor literal. 
 
Há três regras básicas que definem a seqüência correta de avaliação passo a passo de 
expressões: 
 
1. Operadores de maior prioridade devem ser avaliados primeiro. Em caso de 
empate, a avaliação se faz da esquerda para a direita. 
 
2. O uso de parênteses em subexpressões força a avaliação das mesmas com maior 
prioridade. 
 
3. Os diversos tipos d operadores devem ser avaliados na seguinte seqüência dentro 
de uma expressão complexa: primeiro os aritméticos e literais; a seguir, os 
relacionais e, por último, os lógicos. 
 
5.6 Exercícios Propostos 
 
1. Dada a declaração de variáveis: 
 
VAR A, B, C : inteiro 
 X, Y, Z : real 
 NOME, RUA : literal[20] 
 L1, L2 : lógico 
 
Classifique as expressões seguintes de acordo com o tipo de dado do resultado de sua 
avaliação, em I (inteiro), R (real), L (literal), B (lógico) ou N (quando não for possível 
defini-lo): 
 
( ) A + B + C 
( ) A + B + Z 
( ) NOME + RUA 
( ) A B 
( ) A Y 
( ) NOME RUA 
( ) L1 .OU. L2 
( ) RUA <> NOME 
( ) A + B / C 
( ) A + X / Z 
( ) A + Z / A 
( ) A B = L1 
( ) (A = B) 
( ) X + Y / Z 
( ) X = Z / A 
( ) L1 ** L2 
( ) A + B / L2 
( ) X < L1 / RUA 
 
 
2. Para as mesmas variáveis declaradas no exercício 1, às quais são dados os valores 
seguintes: 
 
A = 1 
B = 2 
C = 3 
X = 2.0 
Y = 10.0 
Z = -1.0 
L1 = .V. 
NOME = “PEDRO” 
RUA = “PEDRINHO” 
L2 = .F. 
 
Determine o resultado da avaliação das expressões abaixo: 
 
A + C / B → ___________________________________________________________ 
 
A + B + C → __________________________________________________________ 
 
C / B / A → ___________________________________________________________ 
Algoritmo e Lógica de programação 
- 26 - 
 
-X ** B → _____________________________________________________________ 
 
- (X ** B) → ___________________________________________________________ 
 
(-X) ** B → ____________________________________________________________ 
 
NOME + RUA → _______________________________________________________ 
 
NOME = RUA → _______________________________________________________ 
 
L1 .OU. L2 → _________________________________________________________ 
 
(L1 .E.(.NÃO. L2)) → ____________________________________________________ 
 
(L2 .E. (.NÃO. L1)) → ___________________________________________________ 
 
(L1 .E. (.NÃO. L2)) .OU. (L2 .E. (.NÃO. L1)) → ________________________________ 
_____________________________________________________________________ 
 
X Y .E. C = B → ________________________________________________________ 
_____________________________________________________________________ 
 
(C - 3 * A) (X + 2 * Z) → _________________________________________________ 
_____________________________________________________________________ 
 
Algoritmo e Lógica de programação 
- 27 - 
Capítulo 6 
 
Instruções Primitivas 
 
Como o próprio nome diz, instruções primitivas são os comandos básicos que 
efetuam tarefas essenciais para a operação dos computadores, como entrada e saída de 
dados (comunicação com o usuário e com os dispositivos periféricos), e movimentação dos 
mesmos na memória. Estes tipos de instrução estão presentes na absoluta maioria das 
linguagens de programação. De fato, um programa que não utiliza nenhuma instrução primitiva 
- como as que serão definidas neste capítulo - é incapaz de se comunicar com o mundo 
exterior e, portanto, não tem utilidade alguma. 
 
Antes de passar à descrição das instruções primitivas, é necessária a definição de 
alguns termos que serão utilizados mais à frente: 
 
ƒ Dispositivo de entrada é o meio pelo qual as informações (mais especificamente 
os dados) são transferidas pelo usuário ou pelos níveis secundários de memória ao 
computador. Os exemplos mais comuns são: o teclado, o cartão perfurado (já 
obsoleto), as fitas e os discos magnéticos, entre outros; 
 
ƒ Dispositivo de saída é o meio pelo qual as informações (geralmente, os 
resultados da execução de um programa) são transferidas pelo computador ao 
usuário ou aos níveis secundários de memória. Exemplos: monitor de vídeo, 
impressora, fitas e discos magnéticos, entre outros; 
 
ƒ Sintaxe é a forma como os comandos devem ser escritos, a fim de que possam ser 
entendidos pelo tradutor de programas. A violação das regras sintáticas é 
considerada um erro sujeito à pena do não-reconhecimento do comando por parte 
do tradutor; 
 
ƒ Semântica é o significado, ou seja, o conjunto de ações que serão exercidas pelo 
computador durante a execução do referido comando. 
 
Daqui por diante, todos os comandos novos serão apresentados por meio de sua 
sintaxe e sua semântica, isto é, a forma como devem ser escritos e a(s) ação(ões) que 
executam. 
Algoritmo e Lógica de programação 
- 28 - 
6.1 Instrução Primitiva de Atribuição 
 
A instrução primitiva de atribuição, ou simplesmente atribuição, é a principal 
maneira de se armazenar uma informação numa variável. Sua sintaxe é: 
 
<nome_de_variável> ← <expressão> 
 
Em termos de fluxograma, os comandos de atribuição são representados como na 
Figura 6.1. 
 
<variável> aa
<expressão>
 
 
Figura 6.1 Forma de representação de comandos de atribuição em fluxogramas. 
 
O modo de funcionamento (semântica) de uma atribuição consiste 1) na avaliação da 
expressão e 2) no armazenamento do valor resultante na posição de memória correspondente 
à variável que aparece à esquerda do comando. 
 
 
Fluxograma 
 
Início
PRECO_UNIT aaa 5.0
QUANT aaa 10
PRECO_TOT aaa
PRECO_UNIT *
QUANT
Fim
 
Pseudocódigo 
 
Algoritmo EXEMPLO_6.1 
Var PRECO_UNIT, PRECO_TOT : real 
 QUANT : inteiro 
Início 
 PRECO_UNIT ← 5.0 
 QUANT ← 10 
 PRECO_TOT ← PRECO_UNIT * QUANT 
Fim. 
 
Figura 6.2 Exemplo de aplicação de comandos de atribuição.Técnicas de Programação 
- 29 - 
 
6.2 Instrução Primitiva de Saída de Dados 
 
As instruções primitivas de saída de dados são o meio pelo qual informações contidas 
na memória dos computadores são colocadas nos dispositivos de saída, para que o usuário 
possa visualizá-las. 
 
Há duas sintaxes possíveis para esta instrução: 
 
Escreva <lista de variáveis> 
 
ou 
 
Escreva <literal> 
 
Daqui por diante, Escreva será considerada uma palavra reservada e não mais poderá 
ser utilizada como nome de variável, de modo que toda vez que for encontrada em algoritmos 
será identificada como um comando de saída de dados. 
 
Uma lista_de_variáveis é um conjunto de nomes de variáveis separados por vírgulas. 
Um literal é simplesmente um dado do tipo literal delimitado por aspas. 
 
Em termos de fluxograma, uma instrução de saída de dados é representada como na 
Figura 6.3. 
 
<lista_de_
variáveis>
ou
<literal>
 
 
Figura 6.3 Forma de representação de uma instrução de saída de dados em fluxogramas. 
 
Repare que a representação no fluxograma dispensa o uso da palavra reservada 
Escreva, uma vez que a mesma já está embutida na forma geométrica da figura. 
 
A semântica da instrução primitiva de saída de dados é muito simples: os argumentos 
do comando são enviados para o dispositivo de saída. No caso de uma lista de variáveis, o 
conteúdo de cada uma delas é pesquisado na posição de memória correspondente à variável e 
depois enviado para o dispositivo de saída. No caso de argumentos do tipo string, estes são 
enviados diretamente ao referido dispositivo. 
 
Há, ainda, a possibilidade de se misturar nomes de variáveis com literais na lista de um 
mesmo comando. O efeito obtido é bastante útil e interessante: a lista é lida da esquerda para 
a direita e cada elemento da mesma é tratado separadamente; se um nome de variável for 
encontrado, então a informação da mesma é pega da memória e colocada no dispositivo de 
saída; no caso de um literal, o mesmo é escrito diretamente no dispositivo de saída. 
 
O exemplo da Figura 6.2 torna-se muito mais interessante com a aplicação de 
instruções de saída de dados, como na Figura 6.4. 
 
Técnicas de Programação 
- 1 - 
Fluxograma 
 
Início
PRECO_UNIT aaa 5.0
QUANT aaa 10
PRECO_TOT aaa
PRECO_UNIT *
QUANT
Fim
PRECO_TOT
 
Pseudocódigo 
 
Algoritmo EXEMPLO_6.4 
Var PRECO_UNIT, PRECO_TOT : real 
 QUANT : inteiro 
Início 
 PRECO_UNIT ← 5.0 
 QUANT ← 10 
 PRECO_TOT ← PRECO_UNIT * QUANT 
 Escreva PRECO_TOT 
Fim. 
 
 
Figura 6.4 Exemplo de aplicação da instrução primitiva de saída de dados. 
6.3 Instrução Primitiva de Entrada de Dados 
 
O algoritmo da Figura 6.4 ainda necessita de uma melhoria essencial. Toda vez que ele 
é executado, o mesmo valor é calculado, já que os valores das variáveis PRECO_UNIT e 
QUANT permanecem inalterados. Seria interessante que estes valores pudessem ser 
fornecidos ao computador pelo usuário do programa toda vez que o programa fosse executado, 
para que o usuário tivesse um maior controle sobre o valor calculado. A instrução primitiva de 
entrada de dados foi criada para suprir esta necessidade. 
 
Sua sintaxe é: 
 
Leia <lista_de_variáveis> 
 
Da mesma forma que Escreva, daqui em diante Leia será tratada como uma palavra-
reservada e não mais poderá ser usada como nome de variável em algoritmos. A 
lista_de_variáveis é um conjunto de um ou mais nomes de variáveis, separados por vírgulas. 
 
A Figura 6.5 mostra como uma instrução de entrada de dados é representada em 
fluxogramas. Esta representação dispensa o uso da palavra-reservada Leia, pelo fato da 
mesma já estar de certo modo embutida na forma geométrica da figura. 
 
<lista_de_
variáveis>
 
Algoritmo e Lógica de Programação 
- 30 - 
 
Figura 6.5 Forma de representação de uma instrução de entrada de dados em fluxogramas. 
 
A semântica da instrução de entrada (ou leitura) de dados é, de certa forma, inversa à 
da instrução de escrita: os dados são fornecidos ao computador por meio de um dispositivo de 
entrada e armazenados nas posições de memória das variáveis cujos nomes aparecem na 
lista_de_variáveis. 
 
O algoritmo da Figura 6.4, modificado para que os valores das variáveis PRECO_UNIT 
e QUANT sejam lidos no dispositivo de entrada, está na Figura 6.6. 
 
Pseudocódigo 
 
Algoritmo EXEMPLO_6.6 
Var PRECO_UNIT, PRECO_TOT : real 
 QUANT : inteiro 
Início 
 Leia PRECO_UNIT, QUANT 
 PRECO_TOT ← PRECO_UNIT * QUANT 
 Escreva PRECO_TOT 
Fim. 
 
Fluxograma 
 
Início
PRECO_TOT aaa
PRECO_UNIT *
QUANT
PRECO_UNIT,
QUANT
Fim
PRECO_TOT
A
B
 
 
Figura 6.6 Exemplo de aplicação da instrução primitiva de 
entrada de dados num algoritmo. 
 
O algoritmo da Figura 6.6 ainda precisa sofrer algumas modificações para ficar perfeito. 
Em sua forma atual, ao início de sua execução, ele procura ler os valores para as variáveis 
PRECO_UNIT e QUANT.Um usuário diferente daquele que criou o programa, a não ser que 
esteja bem treinado no uso do mesmo, poderá encontrar dificuldades na interação com o 
programa. Ele pode confundir a ordem em que os dados devem ser fornecidos ou 
simplesmente esquecer o que o programa deseja que ele digite. Ao término da execução o 
programa escreve como resultado um número que pode não possuir nenhum significado ao 
usuário se este não souber a finalidade para a qual o algoritmo foi concebido. 
 
Uma preocupação constante de um bom programador deve ser a de conceber um 
programa "amigo do usuário". Esta preocupação é traduzida no planejamento de urna 
interface com o usuário (meio pelo qual um programa e o usuário "conversam") bastante 
amigável. Em termos práticos, isto se resume à aplicação de duas regras básicas: 
Algoritmo e Lógica de Programação 
- 31 - 
 
ƒ toda vez que um programa estiver esperando que o usuário forneça a ele um 
determinado dado (operação de leitura), ele deve antes enviar uma mensagem 
dizendo ao usuário o que ele deve digitar, por meio de uma instrução de saída de 
dados; 
 
ƒ antes de enviar qualquer resultado ao usuário, um programa deve escrever uma 
mensagem explicando o significado do mesmo. 
 
Estas medidas tornam o diálogo entre o usuário e o programador muito mais fácil. 
 
A versão final do algoritmo estudado é mostrada na Figura 6.7. 
 
Fluxograma 
 
Início
PRECO_UNIT
"Digite o preço
unitário:"
"Digite a quantidade:"
PRECO_TOT aaa
PRECO_UNIT *
QUANT
Fim
"Preço total: ",
PRECO_TOT
QUANT
A
A
 
 
 
Pseudocódigo 
 
Algoritmo EXEMPLO_6.7 
Var PRECO_UNIT, PRECO_TOT : real 
 QUANT : inteiro 
Início 
 Escreva “Digite o preço unitário: ” 
 Leia PRECO_UNIT 
 Escreva “Digite a quantidade: ” 
 Leia QUANT 
 PRECO_TOT ← PRECO_UNIT * QUANT 
 Escreva “Preço total: “, PRECO_TOT 
Fim. 
 
Figura 6.7 Exemplo de aplicação das instruções primitivas de atribuição, 
Algoritmo e Lógica de Programação 
- 32 - 
entrada e saída de dados num algoritmo. 
 
6.4 Síntese 
 
A instrução primitiva de atribuição avalia uma expressão e armazena o valor 
resultante numa variável. O valor resultante da expressão e a variável devem ter tipos 
compatíveis. 
 
A instrução primitiva de saída de dados admite como argumentos uma lista de 
variáveis, um literal, ou uma mistura de ambos. No primeiro caso, o valor de cada uma das 
variáveis é buscado na memória e colocado no dispositivo de saída. No caso de literais, estes 
são copiados diretamente no dispositivo de saída. 
 
A instrução primitiva de entrada de dados busca, no dispositivo de entrada, dados 
que são guardados nas posições de memória correspondentes às variáveis da lista que lhe são 
passadas como argumento. 
 
6.5 Exercícios Resolvidos 
 
1. Escreva um algoritmo (fluxograma e pseudocódigo) para calculara média entre dois 
números quaisquer. 
 
Solução: 
 
A idéia principal do algoritmo está centrada na expressão matemática utilizada no 
cálculo da média (M) entre dois números, N1 e N2, dada por: 
 
M = (N1 + N2) / 2 
 
Para que o valor de M possa ser calculado pelo algoritmo, é necessário que os valores 
de N1 e N2 tenham sido fornecidos ao mesmo com antecedência. Portanto, a primeira 
etapa do algoritmo consiste da obtenção (leitura) dos valores de N1 e N2 e 
armazenamento dos mesmos em posições distintas de memória (variáveis). 
 
Na seqüência, o valor da média deve ser calculado por meio de uma expressão 
apropriada e atribuído a uma terceira variável (M). 
 
Por fim, deve-se relatar ao usuário o valor calculado por meio de uma instrução 
primitiva de saída de dados. 
 
O fluxograma do algoritmo descrito é mostrado a seguir. Note que ele está enriquecido 
com instruções para informar sua finalidade, os dados que devem ser fornecido ao 
usuário e o significado do valor calculado. 
 
Algoritmo e Lógica de Programação 
- 33 - 
Início
N1
"Digite o primeiro
número: "
"Digite o segundo
número: "
"Algoritmo para calcular
a média entre dois
números"
M aaa (N1 + N2) / 2
Fim
"A média é ", M
N2
A
A
 
Algoritmo e Lógica de Programação 
- 34 - 
A transformação do fluxograma em pseudocódigo exige a disponibilidade de algumas 
informações adicionais concernentes ao tipo das variáveis utilizadas. Como o algoritmo 
opera apenas com dados numéricos, certamente as variáveis utilizadas serão do tipo 
inteiro ou real. Como se deseja calcular a média entre dois números quaisquer, então 
as variáveis N1 e N2 devem ser capazes de armazenar números com ou sem parte 
fracionária e, portanto, é necessário que estas sejam do tipo real. Como o valor médio 
entre dois números reais é um número que pode ou não ter parte fracionária, então a 
variável M também deve ser do tipo real. 
 
De posse dessa informação, pode-se escrever o pseudocódigo do algoritmo em 
questão, a partir de seu fluxograma. 
 
Algoritmo MEDIA 
Var N1, N2, M : real 
Início 
 Escreva “Algoritmo para calcular a média entre dois números” 
 Escreva “Digite o primeiro número: ” 
 Leia N1 
 Escreva “Digite o segundo número: ” 
 Leia N2 
 M ← (N1 + N2) / 2 
 Escreva “O valor da média é:”, M 
Fim. 
 
 
2. Escreva um algoritmo para calcular o valor de y como função de x, segundo a função 
y(x) = 3x + 2, num domínio real. 
 
Solução: 
 
Essencialmente o algoritmo usado na solução deste problema consiste na obtenção do 
valor de x para o qual se deseja calcular a função, o cálculo desta propriamente dito e 
a mostra do resultado obtido ao usuário: 
 
Veja fluxograma correspondente a seguir: 
 
Início
"X:"
"Algoritmo para
calcular
y = 3x + 2"
Y aaa 3 * X + 2
Fim
"Y = ", Y
A
A
X
 
 
Algoritmo e Lógica de Programação 
- 35 - 
Para que se possa escrever o pseudocódigo do algoritmo deve-se decidir qual será o 
tipo das variáveis X e Y. Como especificado no enunciado do problema, o algoritmo 
deve operar num domínio real e, portanto, as variáveis X e Y devem ser do tipo real. 
Então, o pseudocódigo fica assim: 
 
Algoritmo FUNCAO_DE_X 
Var X, Y : real 
Início 
 Escreva “Algoritmo para calcular 
y = 3x +2” 
 Escreva “X: ” 
 Leia X 
 Y ← 3 * X + 2 
 Escreva “Y = ”, Y 
Fim. 
 
 
3. Escreva um algoritmo para calcular o consumo médio de um automóvel (medido em 
Km/l), dado que são conhecidos a distância total percorrida e o volume de combustível 
consumido para percorrê-la (medido em litros). 
 
Solução: 
 
A principal questão a ser levantada na obtenção do algoritmo pedido consiste na 
formulação da expressão usada para calcular o consumo médio (CM) a partir da 
distância total percorrida (DIST) e do volume de combustível consumido (VOL), que é 
dada por: 
 
CM = DIST / VOL 
 
Uma vez obtida esta expressão, a formulação do algoritmo desejado consiste em uma 
simples repetição daqueles apresentados nas questões anteriores: deve-se obter o 
valor das variáveis DIST e VOL, calcular o consumo pela expressão acima e, 
finalmente, mostrar ao usuário o valor calculado. 
 
O fluxograma correspondente ao algoritmo é o seguinte: 
 
Início
"Distância total
percorrida (Km):"
"Algoritmo para calcular
o consumo"
CM aaa DIST / VOL
Fim
"Consumo médio = ",
CM, "Km/l"
A
B
DIST
"Volume de
combustível
gasto (L):"
B
A
VOL
 
Algoritmo e Lógica de Programação 
- 36 - 
Assumindo que todas as variáveis utilizadas (CM, DIST e VOL) são do tipo real, pode-
se escrever o pseudocódigo seguinte para o fluxograma anterior: 
 
Pseudocódigo 
 
Algoritmo CONSUMO_MEDIO 
Var CM, DIST, VOL : real 
Início 
 Escreva “Algoritmo para calcular o consumo” 
 Escreva “Distância total percorrida (Km): ” 
 Leia DIST 
 Escreva “Volume de combustível gasto (L): ” 
 Leia VOL 
 CM ← DIST / VOL 
 Escreva “Consumo médio =”, CM, “Km/l” 
Fim. 
 
6.6 Exercícios Propostos 
 
Para cada um dos problemas propostos a seguir, expresse um algoritmo que pode ser 
usado em sua solução na forma de fluxograma e pseudocódigo. 
 
1. Calcule a média de quatro números inteiros dados. 
 
2. Leia uma temperatura dada na escala Celsius (C) e imprima o equivalente em 
Fahrenheit (F). (Fórmula de conversão: F = 9/5 * C + 32) 
 
3. Leia uma quantidade de chuva dada em polegadas e imprima o equivalente em 
milímetros (25,4 mm = 1 polegada). 
 
4. Calcule o quadrado de um número, ou seja, o produto de um número por si mesmo. 
 
5. O custo ao consumidor de um carro novo é a soma do custo de fábrica com a 
porcentagem do distribuidor e dos impostos, ambos aplicados ao custo de fábrica. 
Supondo que a porcentagem do distribuidor seja de 12% e a dos impostos de 45%, 
prepare um algoritmo para ler o custo de fábrica do carro e imprimir o custo ao 
consumidor. 
 
6. O cardápio de uma lanchonete é dado abaixo. Prepare um algoritmo que leia a 
quantidade de cada item que você consumiu e calcule a conta final. 
 
Hambúrguer................. R$ 3,00 
Cheeseburger.............. R$ 2,50 
Fritas............................ R$ 2,50 
Refrigerante................. R$ 1,00 
Milkshake..................... R$ 3,00 
 
7. Uma companhia de carros paga a seus empregados um salário de R$ 500,00 por mês 
mais uma comissão de R$ 50,00 para cada carro vendido e mais 5% do valor da 
venda. Elabore um algoritmo para calcular e imprimir o salário do vendedor num dado 
mês recebendo como dados de entrada o nome do vendedor, o número de carros 
vendidos e o valor total das vendas. 
 
8. Calcule a média de um aluno na disciplina de MDS. Para isso solicite o nome do aluno, 
a nota da prova e a nota qualitativa. Sabe-se que a nota da prova tem peso 2 e a nota 
qualitativa peso 1. Mostre a média como resultado. 
Algoritmo 
- 37 - 
Capítulo 7 
Controle de Fluxo de Execução 
 
Até o momento os algoritmos estudados utilizam apenas instruções primitivas de 
atribuição, e de entrada e saída de dados. Qualquer conjunto de dados fornecido a um 
algoritmo destes será submetido ao mesmo conjunto de instruções, executadas sempre na 
mesma seqüência. 
 
No entanto, na prática muitas vezes é necessário executar ações diversas em função 
dos dados fornecidos ao algoritmo. Em outras palavras, dependendo do conjunto de dados de 
entrada do algoritmo, deve-se executar um conjunto diferente de instruções. Além disso, pode 
ser necessário executar um mesmo conjunto de instruções um número repetido de vezes. Em 
resumo, é necessário controlar o fluxo de execução das instruções (a seqüência em que as 
instruções são executadas num algoritmo) em função dos dados fornecidos como entrada ao 
mesmo. 
 
Neste capítulo serão estudadas as estruturas básicas de controle do fluxo de 
instruções de um algoritmo. De acordocom o modo como este controle é feito, estas estruturas 
são classificadas em: 
 
ƒ estruturas seqüenciais; 
 
ƒ estruturas de decisão; 
 
ƒ estruturas de repetição. 
 
7.1 Comandos Compostos 
 
Um comando composto é um conjunto de zero ou mais comandos (ou instruções) 
simples, como atribuições e instruções primitivas de entrada ou saída de dados, ou alguma das 
construções apresentadas neste capítulo. 
 
Este conceito é bastante simples e será útil e conveniente nos itens seguintes, na 
definição das estruturas básicas de controle de execução. 
 
7.2 Estrutura Seqüencial 
 
Na estrutura seqüencial os comandos de um algoritmo são executados numa 
seqüência pré-estabelecida. Cada comando é executado somente após o término do comando 
anterior. 
 
Em termos de fluxogramas, a estrutura seqüencial é caracterizada por um único fluxo 
de execução (um único caminho orientado) no diagrama. Em pseudocódigos, a estrutura 
seqüencial caracteriza-se por um conjunto de comandos dispostos ordenadamente. Como 
exemplos de aplicação desta estrutura de controle tem-se os algoritmos do capítulo anterior, 
onde não há estruturas de decisão ou de repetição. 
 
Algoritmo 
- 38 - 
 
Fluxograma 
 
<comando 1>
<comando 2>
<comando 3>
 
Pseudocódigo 
 
... 
<comando 1> 
<comando 2> 
<comando 3> 
... 
 
 
Figura 7.1 Trecho seqüencial de um algoritmo. 
 
7.3 Estruturas de Decisão 
 
Neste tipo de estrutura o fluxo de instruções a ser seguido é escolhido em função do 
resultado da avaliação de uma ou mais condições. Uma condição é uma expressão lógica. 
 
A classificação das estruturas de decisão é feita de acordo com o número de condições 
que devem ser testadas para que se decida qual o caminho a ser seguido. Segundo esta 
classificação, têm-se dois tipos de estruturas de decisão: 
 
ƒ Se 
 
ƒ Escolha 
 
 
7.3.1 Estruturas de Decisão do Tipo Se 
 
Nesta estrutura uma única condição (expressão lógica) é avaliada. Se o resultado 
desta avaliação for verdadeiro (.V.), então um determinado conjunto de instruções (comando 
composto) é executado. Caso contrário, ou seja, quando o resultado da avaliação for falso (.F.), 
um comando diferente é executado. 
 
Em termos de fluxogramas, uma construção do tipo Se pode ser encarada como uma 
bifurcação onde há dois caminhos que podem ser seguidos (Figura 7.2). A execução do 
algoritmo prosseguirá necessariamente por um deles. Esta escolha é feita em função do 
resultado da expressão: um dos caminhos é rotulado com (.V.) e será seguido quando a 
condição for falsa. 
 
Algoritmo 
- 39 - 
A sintaxe da estrutura de decisão do tipo Se é mostrada na Figura 7.2. 
 
Fluxograma 
 
<condição>
<comando_
composto_1>
<comando_
composto_2>
.V. .F.
 
 
Pseudocódigo 
 
Se <condição> 
 Então 
 <comando_composto_1> 
 Senão 
 <comando_composto_2> 
Fim_se 
 
Figura 7.2 Sintaxe da estrutura de decisão Se-Então-Senão-Fim_se. 
 
Note-se o aparecimento de novas palavras-reservadas Se, Então, Senão e Fim_se. 
 
A semântica desta construção é a seguinte: a condição é avaliada. Se o resultado for 
verdadeiro, então o comando_composto_1 é executado. Ao término de sua execução o fluxo 
do algoritmo prossegue pela instrução seguinte à construção, ou seja, o primeiro comando 
após o Fim_se. 
 
Nos casos em que a condição é avaliada como falsa, o comando_composto_2 é 
executado e, ao término do mesmo, o fluxo de execução prossegue pela primeira instrução 
seguinte ao Fim_se. 
 
Há casos particulares e muito comuns desta construção, onde o comando composto 2 
é um conjunto vazio de instruções. Neste caso, a porção relativa ao Senão pode ser omitida, 
resumindo a sintaxe da construção à forma mostrada na Figura 7.3. 
Algoritmo 
- 40 - 
 
Fluxograma 
 
<condição>
<comando_
composto_1>
.V.
.F.
 
 
Pseudocódigo 
 
Se <condição> 
 Então 
 <comando_composto_1> 
Fim_se 
 
 
Figura 7.3 Sintaxe da estrutura de decisão Se-Então-Fim_se. 
 
A semântica desta construção é a seguinte: no caso da condição ser verdadeira, o 
Comando_composto_1 é executado e, após seu término, o fluxo de execução prossegue pela 
próxima instrução após o Fim_se. Quando a condição é falsa, o fluxo de execução prossegue 
normalmente pela primeira instrução após o Fim_se. 
 
A Figura 7.4 exemplifica o uso da construção Se-Então-Senão-Fim_se num algoritmo 
para determinar se uma pessoa é maior ou menor de idade. 
 
Fluxograma 
 
Início
IDADE
"Maior de idade"
IDADE >= 18
"Menor de idade"
Fim
.V. .F.
 
 
Algoritmo 
- 41 - 
Pseudocódigo 
 
Algoritmo Exemplo_7.4 
Var IDADE : inteiro 
Início 
 Leia IDADE 
 Se IDADE >= 18 
 Então 
 Escreva “Maior de idade” 
 Senão 
 Escreva “Menor de idade” 
 Fim_se 
Fim. 
 
Figura 7.4 Exemplo de aplicação da estrutura de decisão Se-Então-Senão-Fim_se. 
 
7.3.2 Estruturas de Decisão do Tipo Escolha 
 
Este tipo de estrutura é uma generalização da estrutura Se, onde somente uma 
condição era avaliada e dois caminhos podiam ser seguidos. Na estrutura de decisão do tipo 
Escolha pode haver uma ou mais condições a serem testadas e um comando composto 
diferente associado a cada uma destas. 
 
Fluxograma 
 
<condição_1> <comando_composto_1>.V.
.F.
<condição_2> <comando_composto_2>.V.
.F.
<condição_n> <comando_composto_n>.V.
.F.
<comando_composto_s>
 
 
Algoritmo 
- 42 - 
Pseudocódigo 
 
Escolha 
 Caso <condição_1> 
 <comando_composto_1> 
 Caso <condição_2> 
 <comando_composto_2> 
 Caso <condição_n> 
 <comando_composto_n> 
 Senão 
 <comando_composto_s> 
Fim_escolha 
 
Figura 7.5 Sintaxe usada em fluxograma e pseudocódigo para construção Escolha. 
 
Seu funcionamento é o seguinte: ao entrar-se numa construção do tipo Escolha, a 
condição_1 é testada: se for verdadeira, o comando_composto_1 é executado e, após seu 
término, o fluxo de execução prossegue pela primeira instrução após o final da construção 
(Fim_escolha); se a condição_1 for falsa, a condição_2 é testada: se esta for verdadeira, o 
comando_composto_2 é executado e, ao seu término, a execução prossegue normalmente 
pela instrução seguinte ao Fim_escolha. O mesmo raciocínio é estendido a todas as 
condições da construção. No caso em que todas as condições são avaliadas como falsas, o 
comando_composto_s (correspondente ao Senão da construção) é executado. 
 
Um exemplo de aplicação desta construção é mostrado na Figura 7.6, baseado num 
algoritmo de reajuste salarial variável em função da profissão. 
 
Fluxograma 
 
Início
Fim
"Salário Reajustado = ",
SAL_REAJ
SALARIO, PROF
PROF =
"Técnico" SAL_REAJ aaa 1.5 * SALARIO
.V.
.F.
PROF =
"Gerente" SAL_REAJ aaa 1.3 * SALARIO
.V.
.F.
SAL_REAJ aaa 1.1 * SALARIO
 
 
Algoritmo 
- 43 - 
Pseudocódigo 
 
Algoritmo Exemplo_7.6 
Var SALARIO, SAL_REAJ : real 
 PROF : literal[20] 
Início 
 Leia SALARIO, PROF 
 Escolha 
 Caso PROF = “Técnico” 
 SAL_REAJ ← 1.5 * SALARIO 
 Caso PROF = “Gerente” 
 SAL_REAJ ← 1.3 * SALARIO 
 Senão 
 SAL_REAJ ← 1.1 * SALARIO 
 Fim_escolha 
 Escreva “Salário Reajustado = “, SAL_REAJ 
Fim. 
 
Figura 7.6 Exemplo de aplicação da construção Escolha. 
 
Um caso particular desta construção é aquele em que o Comando_composto_s não 
contém nenhuma instrução. Isto ocorre nas situações em que não se deseja efetuar nenhuma 
ação quando todas as condições testadas são falsas. Assim, pode-se dispensar o uso do 
Senão na construção, como acontece também na construção Se. 
 
7.4 Estruturas de Repetição 
 
São muito comuns as situações em que se deseja repetir um determinado trecho de 
um programa certo número de vezes. Por exemplo, pode-se citar o caso em que se deseja 
realizar um mesmo processamento para conjuntosde dados diferentes. Exemplo: 
processamento de folha de pagamentos de uma empresa em que o mesmo cálculo é efetuado 
para cada um dos funcionários. 
 
As estruturas de repetição são muitas vezes chamadas de Laços ou, também, de 
Loops. 
 
A classificação das estruturas de repetição é feita de acordo com o conhecimento 
prévio do número de vezes que o conjunto de comandos será executado. Assim, os laços 
dividem-se em: 
 
ƒ laços contados, quando se conhece previamente quantas vezes o comando 
composto no interior da construção será executado; 
 
ƒ laços condicionais, quando não se conhece de antemão o número de vezes que 
o conjunto de comandos no interior do laço será repetido, pelo fato de o mesmo 
estar amarrado a uma condição sujeita à modificação pelas instruções do interior 
do laço. 
 
7.4.1 Laços Contados 
 
Os laços contados são úteis quando se conhece previamente o número de vezes que 
se deseja executar um determinado conjunto de comandos. Então, este tipo de laço nada mais 
é que uma estrutura dotada de mecanismos para contar o número de vezes que o corpo do 
laço (ou seja, o comando composto em seu interior) é executado. A sintaxe usada em 
pseudocódigos para os laços contados é mostrada na Figura 7.7. 
 
Algoritmo 
- 44 - 
Fluxograma 
 
<var> = <ínicio>
<fim> <inc>
<comando_
composto>
 
 
 
Pseudocódigo 
 
Para <var> de <início> até <final> incr de <inc> faça 
 <comando_composto> 
Fim_para 
 
Figura 7.7 Sintaxe usada para os laços contados. 
 
 
A semântica do laço contado é a seguinte: no início da execução da construção o valor 
<início> é atribuído à variável <var>. A seguir, o valor da variável <var> é comparado com o 
valor <final>. Se <var> for maior que <final>, então o comando composto não é executado e a 
execução do algoritmo prossegue pelo primeiro comando seguinte ao Fim_para. Por outro 
lado, se o valor de <var> for menor ou igual a <final>, então o comando composto no interior 
da construção é executado e, ao final do mesmo, o valor é adicionado à variável <var>. Feito 
isso, retorna-se à comparação entre <var> e <final> e repete-se o processo até que <var> 
tenha um valor maior que <final>, quando o laço é finalizado e a execução do algoritmo 
prossegue pela instrução imediatamente seguinte ao Fim_para. 
 
Algumas observações interessantes devem ser feitas: 
 
ƒ <var> é necessariamente uma variável, uma vez que seu valor é alterado a cada 
iteração (volta do laço); 
 
ƒ <início>, <fim> e <inc> podem ser constantes ou variáveis. No segundo caso 
(variáveis), algumas linguagens de programação proíbem que seus valores sejam 
modificados durante a execução do laço; 
 
ƒ <inc> é o valor que é adicionado à variável <var> ao final de cada iteração do laço. 
Há linguagens de programação que permitem que lhe seja atribuído um valor 
negativo, de modo que o valor da variável <var> diminui a cada iteração. Neste 
caso, deve-se atentar à necessidade de inversão do sinal da comparação (de > 
para <) que é feito a cada volta do laço, para seu correto funcionamento. Contudo, 
este texto assumirá que <inc> possui um valor sempre positivo, o que não causa 
perda de generalidade, já que um resultado análogo pode ser obtido com o uso das 
construções enquanto e repita, apresentadas a seguir; 
 
ƒ na grande maioria dos casos <inc> tem o valor 1 (incremento unitário). Portanto, 
admite-se a omissão do trecho incr de <inc> da sintaxe do comando Para e, 
quando isto ocorre, assume-se um incremento de 1. 
 
Algoritmo 
- 45 - 
7.4.2 Laços Condicionais 
 
Laços condicionais são aqueles cujo conjunto de comandos em seu interior é 
executado até que uma determinada condição seja satisfeita. Ao contrário do que acontece nos 
laços contados, nos laços condicionais não se sabe de antemão quantas vezes o corpo do laço 
será executado. 
 
As construções que implementam laços condicionais mais comuns nas linguagens de 
programação modernas são: 
 
ƒ Enquanto 
 
ƒ Repita 
 
7.4.2.1 Construção Enquanto 
 
Sua semântica é a seguinte: ao início da construção Enquanto a condição é testada. 
Se seu resultado for falso, então o comando composto no seu interior não é executado e a 
execução prossegue normalmente pela instrução seguinte ao Fim_enquanto. 
 
Se a condição for verdadeira o comando composto é executado e ao seu término 
retorna-se ao teste da condição. Assim, o processo acima será repetido enquanto a condição 
testada for verdadeira. Quando esta for falsa, o fluxo de execução prosseguirá normalmente 
pelas instruções posteriores ao Fim_enquanto. 
 
Fluxograma 
 
<comando_
composto>
.V.
.F.<condição>
 
 
Pseudocódigo 
 
Enquanto <condição> faça 
 <comando_composto> 
Fim_enquanto 
Figura 7.8 Sintaxe da construção Enquanto para laços condicionais. 
 
Uma vez dentro do corpo do laço, a execução somente abandonará o mesmo quando a 
condição for falsa. O usuário deste tipo de construção deve estar atento à necessidade de que 
em algum momento a condição deverá ser avaliada como falsa. Caso contrário, o programa 
permanecerá indefinidamente no interior do laço, o que é conhecido como laço infinito. 
 
7.4.2.2 Construção Repita 
 
Seu funcionamento é bastante parecido ao da construção Enquanto. O comando é 
executado uma vez. A seguir, a condição é testada: se ela for falsa, o comando composto é 
executado novamente e este processo é repetido até que a condição seja verdadeira, quando 
então a execução prossegue pelo comando imediatamente seguinte ao final da construção. 
 
Algoritmo 
- 46 - 
 
Fluxograma 
 
<comando_
composto>
.V.
.F. <condição>
 
 
Pseudocódigo 
 
Repita 
 <comando_composto> 
Até que <condição> 
Figura 7.9 Sintaxe da construção Repita para laços condicionais. 
 
Esta construção difere da construção Enquanto pelo fato de o comando composto ser 
executado uma ou mais vezes (pelo menos uma vez), ao passo que na construção Repita o 
comando composto é executado zero ou mais vezes (possivelmente nenhuma). Isto acontece 
porque na construção Repita o teste da condição é feito ao final da construção, ao contrário do 
que acontece na construção Enquanto, onde o teste da condição é feito no início da mesma. 
 
7.5 Aninhamentos 
 
Um aninhamento ou embutimento é o fato de se ter qualquer um dos tipos de 
construção apresentados anteriormente dentro do conjunto de comandos (comando composto) 
de uma outra construção. 
 
Em qualquer tipo de embutimento é necessário que a construção interna esteja 
completamente embutida na construção externa. 
 
A Figura 7.10 ilustra aninhamentos válidos e inválidos. 
 
(a) (b) 
 
Figura 7.10 Exemplos de aninhamentos (a) válidos e (b) inválidos. 
 
Algoritmo 
- 47 - 
7.6 Síntese 
 
As estruturas de controle do fluxo de execução são essenciais para que se possa 
alterar a seqüência de execução dos comandos de um programa em função dos dados do 
mesmo. 
 
Um comando composto é um conjunto de zero ou mais comandos simples, sejam 
eles instruções primitivas ou construções como as estudadas neste capítulo. 
 
Uma estrutura seqüencial é aquela em que os comandos vão sendo executados 
numa seqüência pré-estabelecida, um após o outro. 
 
As estruturas de decisão permitem escolher qual o caminho a ser seguido num 
algoritmo em função de uma ou mais condições. A construção Se utiliza apenas uma condição, 
ao passo que a construção Escolha utiliza uma ou mais condições. 
 
As estruturas de repetição são usadas quando se deseja repetir um trecho de um 
algoritmo (comando composto). Quando o número de vezes que o trecho será repetido é 
conhecido diz-se que o laço é do tipo contado (construção Para). Quando este número não é 
conhecido, mas é função de uma determinada condição, então têm-se os laços condicionais 
(construção Enquantoe Repita). 
 
As construções Repita e Enquanto diferem uma da outra pelo fato de a primeira 
efetuar o teste da condição no final da construção e, portanto, executar o comando composto 
ao menos uma vez. Por outro lado, a construção Enquanto efetua o teste da condição em seu 
início e executa o comando composto zero ou mais vezes. 
 
Os aninhamentos podem usar qualquer uma das construções apresentadas neste 
capítulo; desde que atendam a uma regra única: a construção mais interna deve estar 
inteiramente contida na construção imediatamente mais externa.