Algorítimos e Programação I

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

ALGORITIMOS E PROGRAMAÇÃO I
Algoritmos e programação I.indd 1Algoritmos e programação I.indd 1 7/8/2013 16:00:327/8/2013 16:00:32
Process BlackProcess Black
Obra organizada pela Universidade Luterana do Brasil. 
Informamos que é de inteira responsabilidade dos autores a 
emissão de conceitos.
Nenhuma parte desta publicação poderá ser reproduzida por 
qualquer meio ou forma sem a prévia autorização da Editora 
da ULBRA.
A violação dos direitos autorais é crime estabelecido na Lei nº .610/98 
e punido pelo Artigo 184 do Código Penal.
Conselho Editorial EAD
Dóris Cristina Gedrat
Thomas Heimman
Mara Salazar Machado
Andréa de Azevedo Eick
Astomiro Romais
Setor de Processamento Técnico da Biblioteca Martinho Lutero - ULBRA/Canoas
Dados Internacionais de Catalogação na Publicação (CIP)
I74a Isaia Filho, Eduardo.
 Algoritimos e programação I / Eduardo Isaia Filho, Vanessa Lindemann. – 
 Canoas: Ed. ULBRA, 2013.
 144p.
 1. Algoritmo. 2. Programação. 3. Computação. 4. Informática. 
I. Lindemann, Vanessa. II. Título. 
 
 CDU: 681.3.421.2
Editoração: Roseli Menzen
Dados técnicos do livro
Fontes: Palatino Linotype, Franklin Gothic Demi Cond
Papel: oě set 75g (miolo) e supremo 240g (capa)
Medidas: 15x22cm
ISBN 978-85-7528-510-7
Algoritmos e programação I.indd 2Algoritmos e programação I.indd 2 7/8/2013 16:00:547/8/2013 16:00:54
Process BlackProcess Black
APRESENTAÇÃO 
Prezado(a) aluno(a)
Seja bem-vindo(a) ao estudo da disciplina de Algoritmos e Programação I!
Esta disciplina introduz o aluno no universo da lógica de programação, de forma 
que no final do semestre você estará capacitado a construir algoritmos. Para isso, 
vamos estudar conceitos básicos como tipos de dados, variáveis, constantes, 
operadores e expressões, formas de representação de algoritmos e, por fim, 
estruturas de controle sequencial, de seleção e de repetição. A disciplina também 
prevê uma introdução à linguagem de programação C, possibilitando que você 
valide os algoritmos construídos durante o semestre. 
Um algoritmo pode ser definido como uma sequência de passos que visam atingir 
um objetivo. Algoritmos são comuns no nosso cotidiano como, por exemplo, uma 
receita de bolo. Nela temos uma lista de ingredientes e uma sequência de passos que 
devem ser seguidos para atingirmos o objetivo final: o bolo. Quando construímos 
um algoritmo, devemos especificar ações claras e precisas, que a partir de um estado 
inicial, após um período de tempo finito, produzem um estado final previsível e bem 
definido. Isso significa que um algoritmo define um padrão de comportamento a 
ser seguido visando resolver um problema, garantindo que sempre que executado, 
sob as mesmas condições, produza o mesmo resultado. 
O principal objetivo do estudo da lógica de programação é a construção de 
algoritmos. Um algoritmo representa o raciocínio envolvido na lógica de 
programação e, dessa forma, permite-nos abstrair detalhes computacionais 
atrelados às linguagens de programação que podem ser acrescentados mais 
tarde. Assim, podemos focar nossa atenção naquilo que é importante: a lógica 
da construção de algoritmos. Vale lembrar que: uma vez concebida uma solução 
algorítmica para um problema, esta pode ser traduzida para qualquer linguagem 
de programação (processo denominado codificação). 
O livro texto desta disciplina está organizado em dez capítulos, subdivididos 
em seções, para facilitar sua leitura e compreensão e favorecer a realização das 
atividades propostas ao final de cada capítulo. 
Algoritmos e programação I.indd 3Algoritmos e programação I.indd 3 7/8/2013 16:00:557/8/2013 16:00:55
Process BlackProcess Black
4
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Só é possível aprender a construir algoritmos, construindo algoritmos! Portanto, 
resolver os exercícios propostos no final de cada capítulo é fundamental para 
desenvolver o raciocínio lógico e atingir o objetivo desta disciplina. A disciplina 
possui conteúdos cumulativos, ou seja, no final do semestre ainda estaremos 
utilizando conceitos estudados nas primeiras semanas de aula. Sendo assim, é 
importante organizar o estudo, resolver os problemas propostos periodicamente 
e não deixar as dúvidas para depois.
As referências bibliográficas sugerem obras de autores que fundamentam os 
estudos realizados e oferecem a você possibilidades de aprofundamento com 
leituras complementares.
Um bom trabalho!
 
 Professora Vanessa Lindemann
Algoritmos e programação I.indd 4Algoritmos e programação I.indd 4 7/8/2013 16:00:557/8/2013 16:00:55
Process BlackProcess Black
SOBRE O AUTOR
Eduardo Isaia Filho
Mestre, Coordenador dos Cursos de Computação da ULBRA unidade Canoas. 
Professor titular da disciplina de Algoritmos e Programação I presencial.
Vanessa Lindemann
Mestre em Ciência da Computação - UFRGS - 2002; Doutora em Informática 
na Educação - UFRGS - 2008. Professora dos cursos de Computação da ULBRA 
Canoas. 
Algoritmos e programação I.indd 5Algoritmos e programação I.indd 5 7/8/2013 16:00:557/8/2013 16:00:55
Process BlackProcess Black
6
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
Algoritmos e programação I.indd 6Algoritmos e programação I.indd 6 7/8/2013 16:00:557/8/2013 16:00:55
Process BlackProcess Black
SUMÁRIO
1 INTRODUÇÃO ............................................................................................................9
 1.1 Conceito de algoritmo ..........................................................................................9
 1.2 Construção do algoritmo ....................................................................................10
 1.3 Formas de representação de algoritmos..............................................................11
 1.4 Estrutura básica de um algoritmo .......................................................................15
 Atividades .............................................................................................................17
2 CONCEITOS FUNDAMENTAIS ....................................................................................19
 2.1 Dados .............................................................................................................19
 2.2 Variáveis ..........................................................................................................20
 2.3 Constantes .......................................................................................................22
 2.4 Expressões .......................................................................................................22
 Atividades .............................................................................................................26
3 INSTRUÇÕES PRIMITIVAS ........................................................................................29
 3.1 Instrução primitiva de atribuição ......................................................................29
 3.2 Instrução primitiva de saída ..............................................................................32
 3.3 Instrução primitiva de entrada ...........................................................................34
 Atividades .............................................................................................................36
4 ESTRUTURA SEQUENCIAL ........................................................................................39
 4.1 Estrutura básica de um algoritmo sequencial ......................................................39
 4.2 Exemplo de um algoritmo com estrutura sequencial ............................................40
 4.3 Construção de algoritmos sequenciais ...............................................................42
4.4 Teste de mesa de algoritmos com estrutura sequencial .......................................46
 Atividades .............................................................................................................52
5 ESTRUTURA DE CONTROLE CONDICIONAL: SE ...........................................................53
 5.1 Estrutura condicional SE simples ........................................................................53
 5.2 Estrutura condicional SE composta ....................................................................55
 5.3 Estrutura condicional SE encadeada ..................................................................59
 5.4 Formatação da solução do algoritmo ..................................................................65
 Atividades .............................................................................................................66
Algoritmos e programação I.indd 7Algoritmos e programação I.indd 7 7/8/2013 16:00:557/8/2013 16:00:55
Process BlackProcess Black
8
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 6 ESTRUTURA DE CONTROLE CONDICIONAL: ESCOLHA .................................................73
 Atividades .............................................................................................................78
7 ESTRUTURA DE CONTROLE DE REPETIÇÃO: ENQUANTO ..............................................81
 Atividades .............................................................................................................94
8 ESTRUTURA DE CONTROLE DE REPETIÇÃO: REPITA ....................................................99
 Atividades ...........................................................................................................106
9 ESTRUTURA DE CONTROLE DE REPETIÇÃO: PARA .....................................................111
 Atividades ........................................................................................................... 117
10 INTRODUÇÃO À LINGUAGEM C ...............................................................................121
 10.1 Identifi cadores ..............................................................................................122
 10.2 Tipos de dados ..............................................................................................123
 10.3 Modeladores .................................................................................................123
 10.4 Declaração, inicialização e escopo de variáveis ...............................................124
 10.5 Defi nição de constantes ................................................................................124
 10.6 Códigos de formato .......................................................................................125
 10.7 Caracteres especiais ....................................................................................127
 10.8 Comando de atribuição .................................................................................127
 10.9 Operadores e funções ....................................................................................128
 10.10 Comentários................................................................................................130
 10.11 Funções de entrada e saída ..........................................................................130
 10.12 Estruturas de controle condicional ...............................................................131
 10.13 Estruturas de controle de repetição .............................................................133
 Atividades ...........................................................................................................137
Algoritmos e programação I.indd 8Algoritmos e programação I.indd 8 7/8/2013 16:00:567/8/2013 16:00:56
Process BlackProcess Black
1 INTRODUÇÃO
 
Eduardo Isaia Filho
Um programa de computador é resultado da atividade intelectual de um 
programador. Para isso, são necessários alguns conhecimentos prévios em 
abstração, modelagem de problemas e lógica de programação. Todo programa 
de computador começa a partir de um algoritmo, ou seja, através da organização 
lógica das instruções que resolvem o problema. Neste capítulo, serão apresentados 
os conceitos introdutórios para a construção de algoritmos, suas formas de 
representação, seus métodos de construção e sua estrutura básica. Por fim, são 
propostos alguns exercícios de fixação. 
1.1 Conceito de algoritmo
Um algoritmo é uma sequência de passos finitos que visam solucionar um 
determinado problema. Estamos acostumados a resolver algoritmos todos os 
dias, mas os fazemos de forma tão automática que nem nos damos conta. Por 
exemplo: trocar uma lâmpada, fazer um bolo, preparar um café passado, escovar 
os dentes, trocar um pneu, entre outros. Todas as atividades do nosso dia a dia que 
possuem uma sequência de passos para serem resolvidas podem ser consideradas 
um algoritmo. 
Se utilizarmos o exemplo do preparo de um café passado, teremos os seguintes 
passos:
1° passo: reservar os utensílios fi ltro de café, chaleira e recipiente para colocar o 
café passado;
2° passo: reservar o pó de café e a água;
3° passo: aquecer a água;
Algoritmos e programação I.indd 9Algoritmos e programação I.indd 9 7/8/2013 16:00:567/8/2013 16:00:56
Process BlackProcess Black
10
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 4° passo: colocar o pó de café no fi ltro;
5° passo: despejar a água aquecida no fi ltro.
Se você seguir estes passos, ao final, você provavelmente terá um café passado. 
O que pode ser observado é que alguns destes passos podem ser alterados em 
sua ordem. Por exemplo, se reservarmos os ingredientes antes dos utensílios, não 
teremos alteração no produto final. Porém, se colocássemos a água no filtro com 
café antes de aquecê-la, o resultado seria indesejado. 
Um algoritmo computacional pode ser definido como uma sequência lógica 
de instruções ou comandos, que devem ser seguidas para se obter a solução de 
um problema. Da mesma forma que um algoritmo do dia a dia, deve seguir 
uma sequência de passos lógicos, que devem ser ordenados de forma clara para 
solucionar o problema. 
1.2 Construção do algoritmo
Para construir um algoritmo, temos que saber claramente qual o problema que 
desejamos solucionar, ou seja, qual o objetivo do algoritmo. Para isso, precisamos 
analisar o problema identificando três elementos básicos: entrada, processamento 
e saída. 
A entrada são os elementos necessários para dar início à solução do problema, o 
processamento é a manipulação dos elementos de entrada para obtenção da saída 
e a saída é o resultado esperado. Se considerarmos o exemplo do café passado, 
apresentado anteriormente, podemos identificar:
• entrada: fi ltro de café, chaleira, recipiente para colocar o café passado, pó de 
café e água;
• processamento: aquecer a água, colocar o pó no fi ltro e despejar a água no 
fi ltro;
• saída: o café passado.
 Se considerarmos os algoritmos computacionais, podemos descrever estes 
elementos em:
• entrada de dados: são os dados que o algoritmo deverá receber;
• processamento de dados: são as fórmulas e a disposição lógica em que os dados 
de entrada serão organizados para obter-se a solução do problema;
• saída de dados: é a apresentação do objetivo, ou seja, o resultado esperado.
Algoritmos e programação I.indd 10Algoritmos e programação I.indd 10 7/8/2013 16:00:567/8/2013 16:00:56
Process BlackProcess Black
11
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aPor exemplo, se desejamos fazer um algoritmo para fazer a soma de dois números 
quaisquer, podemos neste caso identificar:
• entrada de dados: perguntar ao usuário dois números quaisquer;
• processamento de dados: calcular a soma dos números informados;
• saída de dados: apresentar
o resultado da soma.
Sempre que formos construir um algoritmo, devemos nos concentrar nestes três 
elementos, eles sempre estarão envolvidos. Porém, nem sempre estarão nesta 
ordem, podendo variar de algoritmo para algoritmo. 
1.3 Formas de representação de algoritmos
Existem diversas formas de representarmos os algoritmos. Dentre elas, citamos 
algumas abaixo. 
• Linguagem natural: utiliza uma descrição narrativa para especifi car os passos 
a serem realizados para executar a tarefa. Por não possuir uma estrutura bem 
defi nida, pode dar margem para más interpretações e ambiguidades.
• Português estruturado: utiliza uma linguagem estruturada e se assemelha a um 
programa escrito em linguagem de programação. Também é denominado de 
pseudocódigo e é bastante utilizado como passo inicial antes de descrever um 
programa em uma linguagem de programação. Nesta disciplina, o português 
estruturado será a forma utilizada para representar os algoritmos no decorrer 
dos capítulos.
• Fluxograma: é uma forma universal de representação. Utiliza-se de fi guras 
geométricas para ilustrar os passos a serem seguidos para resolução de um 
problema.
• Diagrama de Chapin: é uma variação do fl uxograma permitindo ter-se uma 
visão hierárquica e estruturada da lógica do algoritmo. Esta representação é 
pouco utilizada nos dias de hoje.
1.3.1 Português estruturado
O português estruturado é um tipo de representação de algoritmo que utiliza 
uma linguagem flexível, intermediária entre a linguagem natural e linguagem de 
programação. Normalmente, é utilizado para organizar o raciocínio lógico antes 
de implementar o mesmo em uma linguagem de programação. Todo algoritmo 
representado em português estruturado deverá ter sua sintaxe pré-definida. O 
exemplo 1.1 propõe um problema que será resolvido utilizando um algoritmo em 
português estruturado. 
Algoritmos e programação I.indd 11Algoritmos e programação I.indd 11 7/8/2013 16:00:567/8/2013 16:00:56
Process BlackProcess Black
12
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Exemplo 1.1. Faça um algoritmo que calcule e escreva a média final de um aluno 
considerando duas notas; emita a mensagem “Aluno aprovado” ou “Aluno 
reprovado”. Observação: um aluno é considerado aprovado se obtiver nota final 
maior ou igual a 6.
algoritmo exemplo_11
variáveis
 nota1, nota2, media: real
início
 escrever (“Informe a 1ª nota do aluno = “)
 ler (nota1)
 escrever (“Informe a 2ª nota do aluno = “)
 ler (nota2)
 media m (nota1 + nota2) / 2 
 se (media >= 6) então 
 escrever (“Média final = “, media, “Aluno aprovado”)
 senão 
 escrever (“Média final = “,media, “Aluno reprovado”)
fim
1.3.2 Fluxograma
O fluxograma, também chamado de diagrama de blocos, é uma representação de 
algoritmo que utiliza símbolos geométricos para representar as ações (comandos 
ou instruções) a serem seguidas. Assim como português estruturado, é utilizado 
para organizar o raciocínio lógico do problema antes de implementá-lo em uma 
linguagem de programação. Os símbolos utilizados para representar estas ações 
são apresentados na Tabela 1.1.
Algoritmos e programação I.indd 12Algoritmos e programação I.indd 12 7/8/2013 16:00:567/8/2013 16:00:56
Process BlackProcess Black
13
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aTabela 1.1 – Símbolos geométricos
Símbolo Nome Descrição
Terminal Indica o início e o fim do fluxo do algoritmo.
Seta de fluxo de dados Indica o sentido do fluxo de dados e faz a conexão dos blocos existentes. 
Entrada de dados Indica que serão recebidas informações através do teclado.
Processamento
Indica a realização de cálculos, 
atribuições ou qualquer manipulação de 
dados. 
Saída de dados Indica que as informações serão exibidas na tela. 
Desvio condicional Indica a tomada de decisão, dividindo o fluxo do algoritmo em dois caminhos. 
Conector Serve para conectar dois fluxos.
Cabe destacar que é possível encontrar formas geométricas diferentes para 
representar determinados comandos e/ou instruções. Entretanto, isso é apenas 
uma convenção ou hábito de cada autor. O algoritmo do exemplo 1.1 representado 
através de um fluxograma pode ser visto a seguir. 
Algoritmos e programação I.indd 13Algoritmos e programação I.indd 13 7/8/2013 16:00:567/8/2013 16:00:56
Process BlackProcess Black
14
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
1.3.3 Diagrama de Chapin
Os diagramas de Chapin foram criados para substituir os diagramas de blocos 
(fluxograma) por um diagrama de quadros. A vantagem de se utilizar este tipo 
de diagrama é a clareza quanto ao fluxo de execução e sua desvantagem é que é 
Algoritmos e programação I.indd 14Algoritmos e programação I.indd 14 7/8/2013 16:00:577/8/2013 16:00:57
Process BlackProcess Black
15
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
amais trabalhoso fazer desenhos do que escrever texto. O algoritimo do exemplo 1.1 
representado através de um diagrama de Chapin pode ser visto a seguir. 
início
ler nota1, nota2
media Å (nota1 + nota2) / 2 
 S N
resultado Å “Aprovado” resultado Å “Reprovado”
 escrever media, resultado
fim
1.3.4 Formalização de um algoritmo
Construir um algoritmo consiste em detalhar os dados que serão processados 
e as instruções que vão operar sobre esses dados. Esta construção, como visto 
anteriormente, pode ser feita por diferentes formas de representações, mas é 
importante formalizarmos a descrição dos algoritmos segundo uma convenção 
pré-definida, para que todas as pessoas envolvidas no processo possam entendê-
la. Para isso, é necessário definir o conjunto de regras que regulam a escrita do 
algoritmo (sintaxe) e o conjunto de regras que definem a interpretação desta 
escrita (semântica). Nos capítulos seguintes, serão definidas a sintaxe e a semântica 
utilizadas nesta disciplina.
1.4 Estrutura básica de um algoritmo
Observe a receita de bolo de chocolate a seguir.
Bolo de chocolate
Ingredientes:
• 3 ovos
• 1 e 1/2 xícara de açúcar
• 2 xícaras farinha de trigo
• 1 xícara de chocolate em pó ou achocolatado
• 1/2 xícara de óleo
• 1 colher de fermento em pó
media >= 6
Algoritmos e programação I.indd 15Algoritmos e programação I.indd 15 7/8/2013 16:00:587/8/2013 16:00:58
Process BlackProcess Black
16
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a • 1 pitada de sal
• 1 xícara de água quente
 Modo de preparo:
1. Bata os ovos com o açúcar, o óleo, o achocolatado e a farinha, depois adicione a água 
quente e por último o fermento em pó. 
2. Asse em forno com temperatura média por 40 minutos, desenforme quente.
Se observarmos com atenção, veremos que esta receita possui uma estrutura 
básica: nome da receita, ingredientes e modo de preparo. Podemos verificar que 
esta estrutura facilita a localização da receita, permite verificar se possuímos todos 
os ingredientes, antes de começar o preparo.
Um algoritmo, representado em português estruturado, possui uma estrutura 
bastante semelhante a uma receita, organizada em três partes: identificação do 
algoritmo, declaração de constantes e/ou variáveis e o corpo do algoritmo. Observe 
o exemplo 1.1, reproduzido novamente a seguir.
Algoritmo exemplo_11 Identificador do algoritmo
variáveis
 nota1, nota2, media: real
Declaração de variáveis 
início
 escrever ("Informe a 1ª nota do aluno = ")
 ler (nota1)
 escrever ("Informe a 2ª nota do aluno = ")
 ler (nota2)
 media m (nota1 + nota2) / 2 
 se (media >= 6) então 
 escrever ("Média final = ", media, "Aluno aprovado")
 senão 
 escrever ("Média
final = ",media, "Aluno reprovado")
fim
Corpo do algoritmo
Esta estrutura facilita a localização do algoritmo, permitindo saber quais variáveis 
e/ou constantes serão usadas e como elas serão manipuladas para obter o resultado 
esperado.
Glossário
• Programa: é uma sequência de instruções que podem ser executadas por 
um computador. É um conjunto de ordens dadas a um computador para a 
Algoritmos e programação I.indd 16Algoritmos e programação I.indd 16 7/8/2013 16:00:587/8/2013 16:00:58
Process BlackProcess Black
17
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
arealização de um determinado processo. É a implementação de um algoritmo 
em uma determinada linguagem de programação.
• Linguagens de programação: são ferramentas (soĞ wares) que permitem o 
desenvolvimento de programas. Possuem um poder de criação ilimitado, 
desde jogos, editores de texto, sistemas empresariais até sistemas operacionais. 
Existem várias linguagens de programação, cada uma com suas características 
próprias. Exemplos: Pascal, C, C++, C#, Java e outras. 
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Atividades
1. Vamos construir alguns algoritmos? Descreva os passos necessários para 
solucionar os seguintes desafi os. 
a. Descreva como você troca uma lâmpada.
b. Um camponês precisa atravessar um rio utilizando um barco com 
capacidade para carregar ele mesmo e mais uma de suas três cargas, 
que são: um lobo, uma ovelha e um maço de pasto. Quais os passos 
que o camponês deve seguir para atravessar o rio sem perder a sua 
carga? Sabendo que o lobo come a ovelha e a ovelha come o pasto, ou 
seja, em momento algum o lobo pode fi car sozinho com a ovelha e a 
ovelha fi car sozinha com o pasto. DICA: procure no Google (www.
google.com.br) as palavras “jogo camponês ovelha pasto” ou “jogo 
pastor ovelha feno” e teste sua solução de maneira online.
Algoritmos e programação I.indd 17Algoritmos e programação I.indd 17 7/8/2013 16:00:587/8/2013 16:00:58
Process BlackProcess Black
18
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
c. Três jesuítas e três canibais precisam atravessar um rio, para isso 
dispõem de um barco com capacidade para duas pessoas. Por medida 
de segurança, em nenhuma das margens do rio, o número de canibais 
pode ser maior que o número de jesuítas. Qual a solução para efetuar 
a travessia de forma segura? DICA: procure no Google (www.google.
com.br) as palavras “jogo jesuítas canibais” e teste sua solução de 
maneira online.
d. A Torre de Hanói consiste em uma base com três pinos, onde em 
um deles, estão dispostos três discos uns sobre os outros, em ordem 
crescente de diâmetro, de cima para baixo. Descreva como passar todos 
os discos de um pino para outro qualquer, usando um dos pinos como 
auxiliar, de maneira que um disco maior nunca fi que em cima de outro 
menor em nenhuma situação. DICA: procure no Google (www.google.
com.br) as palavras “jogo torre de hanói” e teste sua solução de maneira 
online.
e. Pedro possui dois baldes: um com capacidade para comportar 5 litros, 
e outro que comporta 3 litros. Ele não possui outros recipientes e os 
baldes não possuem marcações de volume. Como Pedro, utilizando 
os dois baldes, pode retirar exatamente sete litros de água de uma 
fonte?1
Resposta:
 Encha o balde de 5 litros e despeje a água no balde de 3 litros, enchendo-o. 
Agora, restaram 2 litros no balde de 5 litros. Jogue fora a água do balde de 3 
litros e coloque nele os 2 litros que estavam no balde de 5 litros. A seguir, encha 
o balde de 5 litros novamente e pronto! No balde de 3 litros estão, agora, 2 
litros de água, enquanto o balde de 5 litros está cheio, totalizando 7 litros!
Algoritmos e programação I.indd 18Algoritmos e programação I.indd 18 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
2 CONCEITOS FUNDAMENTAIS
Eduardo Isaia Filho
Neste capítulo, serão apresentados os conceitos de dados, variáveis e constantes; 
os tipos básicos de dados; os operadores aritméticos, relacionais e lógicos. Por fim, 
são propostos alguns exercícios de fixação. 
2.1 Dados
O objetivo da maioria dos algoritmos é manipular dados, transformando os dados 
de entrada em dados de saída (resultados). Um dado é um atributo que descreve 
entidades ou características, por exemplo: o nome de uma pessoa, sua idade, seu 
peso ou o número de páginas de um livro. 
Quando vamos desenvolver um algoritmo, precisamos previamente identificar o 
tipo do dado que está sendo manipulado. Isso é necessário, pois, quando formos 
converter o algoritmo para uma linguagem de programação, os dados serão 
armazenados na memória principal do computador e um espaço de memória 
específico (tamanho) deve ser reservado a cada tipo de dado. Os principais tipos 
de dados são: inteiro, real, caractere, cadeia e lógico.
2.1.1 Tipos básicos de dados
Os tipos de dados podem ser classificados de acordo com o tipo de informação 
contida neles: dados numéricos (inteiros e reais), dados literais (caractere e cadeia) 
e dados lógicos. 
• Inteiro: os dados do tipo inteiro pertencem ao conjunto de números inteiros 
relativos, ou seja, são aqueles que não possuem componentes decimais ou 
fracionários, podendo ser positivos, nulos ou negativos. Exemplos: quantidade 
Algoritmos e programação I.indd 19Algoritmos e programação I.indd 19 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
20
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a de alunos em uma turma (alunos = 24); idade de uma pessoa (anos = 25); o ano 
(ano = 2013); outros.
• Real: os dados do tipo real pertencem ao conjunto dos números reais. Portanto, 
podem ter componentes decimais ou fracionários e ser positivos, nulos ou 
negativos. Exemplos: o salário de uma pessoa (salário = 3.450,34); a temperatura 
(temperatura = 12); a altura de um prédio (altura = 120,50); outros.
• Caractere: os dados do tipo caractere são compostos por um único caractere 
alfanumérico (0..9, A..Z, a..z) ou caractere especial (#, $, %, *, ?, >, ...). Os dados 
do tipo caractere são delimitados por aspas. Exemplos: código de acesso a um 
sistema (código = “#”); resposta a uma pergunta (resposta = “S”); seleção entre 
alternativas (alternativa = “a”); o sexo de uma pessoa (sexo = “M”). 
• Cadeia: os dados do tipo cadeia são formados por um conjunto de caracteres 
alfanuméricos (0..9, A..Z, a..z) e/ou caracteres especiais (#, $, %, *, ?, >, ...). 
Os dados do tipo cadeia são delimitados por aspas. Exemplos: nome de um 
funcionário (nome = “Alberto Malazowski”); endereço de um cliente (rua = “Av. 
Julio de Castilhos, 990”); senha de acesso a um sistema (senha = “9125ax”); 
outros. 
• Lógico: um dado do tipo lógico só pode assumir dois estados: verdadeiro ou 
falso. Exemplos: resposta = verdadeiro (ou, simplesmente resposta = v); teste 
= falso (ou, simplesmente teste = f).
2.2 Variáveis 
Uma variável pode ser definida como um local, na memória principal, utilizado 
para armazenar o conteúdo de um determinado dado, podendo receber muitos 
valores diferentes durante a execução do algoritmo, mas em um dado instante ela 
só pode apresentar um
valor único.
O conceito de variável foi criado para permitir, que através do nome (identificador), 
os algoritmos possam armazenar, localizar e manipular as informações na 
memória dos computadores. São, portanto, formadas por três atributos: um nome 
(identificador), um tipo de dado, e um valor.
Toda variável possui um nome único que a diferencia das demais. A escolha do 
nome de uma variável cabe ao programador, porém algumas regras devem ser 
observadas. São elas:
• devem sempre começar com uma letra; 
• podendo ser seguida de letras e/ou números;
Algoritmos e programação I.indd 20Algoritmos e programação I.indd 20 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
21
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a• não é permitido espaços em branco, caso haja necessidade de separador o 
sublinhado baixo (underscore) pode ser utilizado, exemplo: nome_aluno;
• não é permitido utilizar símbolos, operadores, acentos e caracteres especiais, 
por exemplo: &, %, #, +, /, ?, @;
• não é permitido utilizar uma palavra reservada, ou seja, uma palavra que é 
um comando do algoritmo.
 Exemplos de nomes de variáveis:
• Salario : correto;
• 1ANO : errado, pois não começou com uma letra;
• ANO1 : correto;
• a casa : errado, pois contém o espaço em branco;
• SAL/HORA : errado, pois contém o caracter “/”;
• SAL_HORA : correto;
• _DESCONTO : errado, pois não começou com uma letra.
Uma consideração importante quanto ao nome das variáveis é que este deve ser 
um nome representativo, de forma que ao ler o nome da variável seja possível 
lembrar o que ela armazena.
2.2.1 Sintaxe da declaração de variáveis
Todas as variáveis utilizadas em um algoritmo devem ser declaradas antes de 
serem utilizadas, através da definição de um nome (identificador) e do tipo de 
dado que será armazenado nela. A seguir veja como é a sintaxe da declaração de 
uma variável: 
 variáveis
 <nome da variável ou lista de nomes> : <tipo de dado>
 
Exemplo
variáveis 
nome, endereco: cadeia
idade: inteiro
peso, altura: real 
Algoritmos e programação I.indd 21Algoritmos e programação I.indd 21 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
22
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 2.3 Constantes
Ao contrário das variáveis, o conteúdo armazenado em uma constante não é 
alterado durante a execução de um algoritmo. 
2.3.1 Sintaxe da declaração de constantes
As constantes também são definidas antes de serem utilizadas e seus nomes 
(identificadores) seguem as mesmas regras das variáveis. A seguir veja como é a 
sintaxe da declaração de uma constante.
 constantes
 <nome da constante> = <conteúdo>
Exemplo 
 constantes
 pi = 3.1416
2.4 Expressões
Operadores são elementos fundamentais que, quando relacionados com operandos, 
produzem uma expressão. 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. 
Os operandos dividem-se em aritméticos, relacionais e lógicos. Esta divisão está 
diretamente relacionada com o tipo de expressão onde aparecem os operadores.
2.4.1 Expressões aritméticas
As expressões aritméticas são formadas por variáveis numéricas e operadores 
aritméticos, cujo resultado da avaliação é do tipo numérico (inteiro ou real). Os 
operadores aritméticos e sua ordem de prioridade são apresentados na Tabela 2.1.
Tabela 2.1 – Operadores aritméticos
Operador Operação Prioridade Exemplo
** Exponenciação 1 3 ** 2 = 9
// Radiciação 1 25 // 2 = 5
* Multiplicação 2 7 * 2 = 14
/ Divisão 2 20 / 4 = 5
div Quociente da divisão inteira 2 20 div 6 = 3 
mod Resto da divisão inteira 2 20 mod 6 = 2
+ Adição 3 3 + 8 = 11
- Subtração 3 30 – 12 = 18
Algoritmos e programação I.indd 22Algoritmos e programação I.indd 22 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
23
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aComo pode ser observado, nos algoritmos podemos utilizar três operadores 
relacionados à divisão, são eles: /, div e mod. Vamos entender qual a diferença de 
cada um deles, relembrando alguns conceitos:
 14 4
-12 3,5 m quociente
 20
- 20
 0 m resto da divisão
Observe que a divisão de 14 por 4 é a divisão tradicional, onde fracionamos o 
quociente até obtermos um resultado nulo ou uma dízima periódica. Ao utilizarmos 
os operadores div e mod, estamos fazendo a divisão inteira, ou seja, devemos 
encerrar o processo de divisão quando o quociente necessitar ser fracionado. Veja 
o exemplo da divisão inteira:
 14 4
 - 8 3 m quoiente inteiro (div)
 2 m resto da divisão inteira (mod)
Outros exemplos são apresentados na Tabela 2.2.
Tabela 2.2 – Exemplos de divisão, div e mod
10 / 2 = 5
10 div 2 = 5
10 mod 2 = 0
20 / 3 = 6,666...
20 div 3 = 6
20 mod 3 = 2
105 / 10 = 10,5
105 div 10 = 10
105 mod 10 = 5
32 / 6 = 5, 333...
32 div 6 = 5
32 mod 6 = 2
A prioridade entre os operadores define a ordem em que os mesmos devem ser 
executados dentro de uma mesma expressão. Quando há dois ou mais operadores 
de mesma prioridade em uma expressão, a execução se dá da esquerda para 
direita. Para alterar a ordem em que os operadores são executados, pode-se utilizar 
parênteses, por exemplo: 
(2 + 3) * 2 =
5 * 2 =
10
2 + 3 * 2 = 
2 + 6 = 
8 
Temos que ter um cuidado especial quando convertemos uma expressão matemática 
para utilizá-la em um algoritmo. Considere a expressão a seguir.
3 + 5
2
Algoritmos e programação I.indd 23Algoritmos e programação I.indd 23 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
24
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Podemos observar que o resultado desta expressão é 4, pois primeiro somamos 3 
e 5 e depois dividimos por 2. Quando convertemos a expressão para utilizarmos 
em um algoritmo, temos que ter cuidado com a prioridade dos operadores, um 
programador desatento poderia muito bem, converter a expressão matemática para 
3 + 5 / 2. Observe que agora o resultado é 5,5 diferente da expressão original, pois 
o operador prioritário é a divisão e não a soma, ou seja, primeiro iríamos dividir 
5 por 2, para somente depois somarmos a 3. Quando convertemos uma expressão 
matemática, para utilizarmos nos algoritmos, normalmente, teremos que adicionar 
parênteses para determinar a prioridade de execução. A conversão correta para 
expressão é (3 + 5) / 2.
2.4.2 Expressões lógicas
As expressões lógicas têm como resultado um valor lógico (verdadeiro/V ou 
falso/F). Elas podem ser formadas por operadores relacionais, operadores lógicos 
ou pela combinação de ambos.
2.4.2.1 Operadores relacionais
Estes operadores, listados na Tabela 2.3, são utilizados quando se deseja efetuar 
comparações entre objetos de mesma natureza (variáveis do mesmo tipo de dado). 
O resultado de uma comparação é sempre um valor lógico (verdadeiro ou falso). 
Tabela 2.3 – Operadores relacionais
Operador Comparação Exemplo
= Igual 3 = 2 o falso
< > Diferente 10 <> 20 o verdadeiro
< Menor 4 < 18 o verdadeiro
> Maior 10 > 20 o falso 
<= Menor ou igual 4 <= 7 o verdadeiro
>= Maior um igual 7 >= 7 o verdadeiro
2.4.2.2 Operadores lógicos
Os operadores lógicos ou booleanos também resultam em valores lógicos e, 
normalmente, são usados para combinar expressões relacionais. Os operadores 
lógicos e suas relações de precedência são mostrados na Tabela 2.4.
Algoritmos e programação I.indd 24Algoritmos e programação I.indd 24 7/8/2013 16:00:597/8/2013 16:00:59
Process BlackProcess Black
25
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aTabela 2.4 – Operadores lógicos
Operador Operação Prioridade Exemplo
NÃO Negação 1 não(2>7) o não(F) o V
E Conjunção 2 (2=2)
e (3<7) o (V) e (V) o V
OU Disjunção 3 (2<5) ou (9<20) o(F) ou (V) o V
Se considerarmos duas variáveis, representadas por variável1 e variável2, podemos 
descrever as três operações lógicas a seguir:
• variável1 E variável2: o operador E resulta em verdadeiro somente se ambas 
variáveis forem verdadeiras. Se uma for falsa, ou se ambas forem falsas, a 
operação E também será falsa.
• variável1 OU variável2: o operador OU resulta em verdadeiro se pelo menos 
uma das variáveis for verdadeira. Só resultam em valores falsos se ambas 
variáveis forem falsas. 
• NÃO variável1: o operador NÃO é unário, ou seja, só se aplica a uma variável. 
É avaliado verdadeiro se a variável for falsa; de modo contrário, o operador 
NÃO resultará em falso, se a variável for verdadeira.
A Tabela 2.5, chamada de tabela-verdade, exemplifica o uso dos operadores lógicos, 
considerando duas variáveis lógicas (A e B). Uma vez que uma variável lógica só 
pode assumir dois valores (verdadeiro ou falso), há exatamente quatro combinações 
possíveis entre A e B. As colunas contêm os resultados das operações lógicas sobre 
as combinações de A e B. 
Tabela 2.5 – Tabela-verdade dos operadores lógicos
A B Não A Não B A e B A ou B
V V F F V V
V F F V F V
F V V F F V
F F V V F F
Algoritmos e programação I.indd 25Algoritmos e programação I.indd 25 7/8/2013 16:01:007/8/2013 16:01:00
Process BlackProcess Black
26
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Atividades
1) Marque com um (X) somente os identifi cadores válidos.
a) ( ) nome b) ( ) endereço c) ( ) 3x4
d) ( ) soma e) ( ) salário_líquido f) ( ) a
g) ( ) nomedaempresa h) ( ) ah! i) ( ) salario total
 j) ( ) média k) ( ) x2 l) ( ) data
2) Observe os dados listados a seguir e identifi que o seu tipo, marcando com “I” 
os inteiros, “R” os reais e “C” as cadeias.
a) ( ) nome de uma pessoa b) ( ) o tamanho de uma mesa
c) ( ) preço de um produto d) ( ) o número de cadeiras de uma mesa
e) ( ) um dia do mês f) ( ) o código de um produto
3) Assinale com um (X) a resposta certa. Ao convertermos a expressão 3 yx � para 
utilizarmos em um algoritmo, como fi ca a expressão? 
a) ( ) x//3 + y//3; b) ( ) x + y //3; c) ( ) (x + y) // 3; d) ( ) 3 // x+y.
4) Qual o resultado da expressão 9 + 4 / 2 + 3?
a) 9,5; b) 2,6; c) 14; d) 9,8; e) 9.
Algoritmos e programação I.indd 26Algoritmos e programação I.indd 26 7/8/2013 16:01:007/8/2013 16:01:00
Process BlackProcess Black
27
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a5) Considere as expressões lógicas e assinale (V) quando o resultado for 
“Verdadeiro” e (F) quando o resultado for “Falso”.
 a) ( ) V e F ou V b) ( ) não (V e V) c) ( ) (V ou F ) e V d) ( ) não F e não F
Gabarito:
1. As respostas corretas são: a, d, f, g, k e l.
2. a) C; b) R; c) R; d) I; e) I; f) C
3. b
4. c
5. a) V; b) F; c) V; d) V
Algoritmos e programação I.indd 27Algoritmos e programação I.indd 27 7/8/2013 16:01:017/8/2013 16:01:01
Process BlackProcess Black
28
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
Algoritmos e programação I.indd 28Algoritmos e programação I.indd 28 7/8/2013 16:01:027/8/2013 16:01:02
Process BlackProcess Black
3 INSTRUÇÕES PRIMITIVAS
Vanessa Lindemann
Instruções primitivas são comandos básicos utilizados para efetuar a entrada e a 
saída de dados e sua movimentação na memória. Estes comandos, presentes na 
maioria absoluta dos algoritmos, garantem a comunicação do algoritmo com o 
mundo exterior. Neste capítulo, serão apresentadas as instruções primitivas de 
atribuição, de entrada de dados (comando LER) e de saída de dados (comando 
ESCREVER). 
3.1 Instrução primitiva de atribuição
A sintaxe do comando de atribuição, representado pelo símbolo Å, é apresentada 
a seguir e exemplificada nos Quadros 3.1 e 3.2.
<variável> Å <expressão>
<variável> Å <variável>
<variável> Å <constante>
Seu funcionamento consiste em avaliar a expressão (variável ou constante) que 
está à direita do comando e armazenar o valor resultante desta expressão (variável 
ou constante) na posição de memória correspondente à variável que aparece à 
esquerda do comando. Para isso, é necessário que o tipo de dado resultante da 
expressão (variável ou constante) avaliada e o tipo de dado da variável sejam 
compatíveis. No exemplo media Å 6.8 (lê-se “média recebe seis e oito”), o valor 
6,8 é armazenado na posição de memória reservada à variável media, que deverá 
ser do tipo real. Outros exemplos da instrução primitiva de atribuição podem ser 
observados no Quadro 3.1. 
Algoritmos e programação I.indd 29Algoritmos e programação I.indd 29 7/8/2013 16:01:027/8/2013 16:01:02
Process BlackProcess Black
30
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 3.1 î Exemplos da instrução primitiva de atribuição
Declaração de variáveis Exemplos de comandos de atribuição
x, y: lógico
codigo, qtde: inteiro
desconto, total: real
nome, telefone: cadeia
resposta1: caractere
resposta2: caractere
01 x Å verdadeiro
02 y Å x
03 codigo Å 2089 
04 qtde Å 3
05 total Å qtde * 5
06 desconto Å total * 0.1
07 nome Å "Ana Lu"
08 telefone Å "(99)3333-0123"
09 resposta1 Å "S" 
10 resposta2 Å resposta1 
As variáveis x e y foram declaradas do tipo lógico, então podem armazenar 
os valores lógicos verdadeiro ou falso. No exemplo 01, x recebe o valor lógico 
verdadeiro. No exemplo 02, y recebe o valor armazenado na variável x, ou seja, o 
valor lógico verdadeiro. 
As variáveis codigo e qtde, declaradas como inteiro, só podem armazenar valores 
do tipo inteiro, como ilustram os exemplos 03 e 04 do Quadro 3.1. No caso de uma 
variável do tipo real, esta poderá armazenar tanto valores reais (como ilustra o 
exemplo 06), quanto valores inteiros. Esta situação pode ser observada no exemplo 
05, onde a variável total que é do tipo real, recebe o resultado da expressão 
qtde*5 que, neste exemplo, resulta em 15.
Os últimos exemplos do Quadro 3.1 ilustram a atribuição de valores a variáveis 
declaradas como literais. É importante observar que quando as variáveis forem 
do tipo cadeia ou caractere, a expressão a ser atribuída à variável deve estar entre 
aspas, como nos exemplos 07, 08 e 09. No exemplo 10, a variável resposta2 recebe 
o valor armazenado na variável resposta1, ou seja, um S. 
Retomando a questão da compatibilidade de tipo, destaca-se que: (a) o resultado 
de uma expressão com operadores de divisão e/ou radiciação sempre deverá ser 
armazenado em uma variável do tipo real, como ilustram os exemplos 03, 04 e 05 
do Quadro 3.2; (b) os operadores mod e div só podem ser utilizados com operandos 
do tipo inteiro, conforme exemplos 06 e 07 do Quadro 3.2; (c) o resultado de uma 
expressão com operadores mod e/ou div deve ser armazenado em uma variável do 
tipo inteiro ƺ situações também observáveis nos exemplos 06 e 07 do Quadro 3.2. 
Algoritmos e programação I.indd 30Algoritmos e programação I.indd 30 7/8/2013 16:01:027/8/2013
16:01:02
Process BlackProcess Black
31
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 3.2 î Exemplos da instrução primitiva de atribuição
Declaração de variáveis Exemplos de comandos de atribuição
op1, op2: inteiro
r1, r2, r3: real
r4, r5: inteiro
01 op1 Å 10 
02 op2 Å 2
03 r1 Å op1 / op2 
04 r2 Å 18 / 4
05 r3 Å 25 // 2
06 r4 Å 8 mod 3
07 r5 Å op1 div 3 
Nos exemplos 01 e 02 do Quadro 3.2, as variáveis op1 e op2 recebem, 
respectivamente, 10 e 2. Em seguida, a variável r1 recebe o resultado da divisão de 
op1 por op2 que, neste caso, é 5. Como foi explicado anteriormente, independente 
do resultado da expressão ser inteiro ou não, a variável r1 foi declarada do tipo real 
e irá armazenar este resultado como real. O mesmo ocorre nos exemplos 04 e 05, em 
que as variáveis r2 e r3 armazenam, respectivamente, os valores 4,5 (resultado de 
uma divisão) e 5 (resultado de uma radiciação). O Quadro 3.3 ilustra os resultados 
dos exemplos 06 e 07, em que as variáveis r4 e r5 recebem, respectivamente, 2 
(resto da divisão) e 3 (quociente inteiro). 
Quadro 3.3 î Exemplo dos operadores mod e div
r4 Å 8 mod 3
 8 3 
 - 6 2
 2 ĸ resto da divisão
r5 Å op1 div 3
 10 3 
 - 9 3
 1 ĸ quociente inteiro
(a) Exemplo 06 - Quadro 3.2 (b) Exemplo 07 - Quadro 3.2
Por fim, vale lembrar que uma sequência de atribuições modifica o conteúdo da 
variável armazenada na memória, como ilustra o exemplo do Quadro 3.4. 
Quadro 3.4 î Exemplo de uma sequência de atribuições
Comandos de atribuição Memória
 01 x Å 10
 02 x Å x + 1
 03 x Å 20
x
10
11
20
Algoritmos e programação I.indd 31Algoritmos e programação I.indd 31 7/8/2013 16:01:027/8/2013 16:01:02
Process BlackProcess Black
32
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a No exemplo 01 do Quadro 3.4 a variável x é inicializada com o valor 10 e, 
consequentemente, a representação da variável x na memória armazenava 10; em 
seguida, é atribuído à variável x o valor resultante da expressão x + 1, que é 11, 
substituindo o valor anterior na memória; finalmente, no exemplo 03, a variável 
x recebe o valor 20, que substituiu o valor anterior na memória como ilustra o 
Quadro 3.4. 
O Quadro 3.5 apresenta um algoritmo que exemplifica o uso da instrução 
primitiva de atribuição. Este algoritmo tem por objetivo calcular a média final 
de um aluno, considerando duas notas. Para isso, foram realizadas as seguintes 
atribuições: a variável nota1 recebe 7, a variável nota2 recebe 9 e o resultado 
da expressão que calcula a média, (nota1+nota2)/2, é armazenado na 
variável media. 
Quadro 3.5 î Exemplo da aplicação do comando de atribuição
Exemplo 3.1 - Calcula a média de um aluno, considerando duas notas. 
01 algoritmo exemplo31
02 variáveis
03 nota1, nota2, media: real
04 início
05 nota1 Å 7
06 nota2 Å 9
07 media Å (nota1 + nota2) / 2 
08 fim
A solução do exemplo 3.1 apresenta duas limitações significativas: (a) a média do 
aluno é calculada e armazenada na memória, porém não é exibida para o usuário 
do programa; (b) se o programa for executado mais de uma vez, o resultado será 
sempre o mesmo, pois os valores armazenados nas variáveis nota1 e nota2 
permanecem inalterados. Estas limitações serão resolvidas com o uso das instruções 
primitivas de saída e de entrada, respectivamente, conforme descrevem as seções 
3.2 e 3.3. 
3.2 Instrução primitiva de saída
A instrução primitiva de saída de dados tem por objetivo prover a interação entre o 
programa e o usuário (ou outros dispositivos), emitindo mensagens e/ou exibindo 
valores armazenados em variáveis na memória do computador. 
A sintaxe do comando de saída de dados é apresentada a seguir e exemplificada 
no Quadro 3.6. Como pode ser observado, o argumento da instrução primitiva 
Algoritmos e programação I.indd 32Algoritmos e programação I.indd 32 7/8/2013 16:01:027/8/2013 16:01:02
Process BlackProcess Black
33
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
ade saída pode ser uma única variável, uma lista de variáveis, um literal ou uma 
mistura de ambos.
escrever(<variável>)
escrever(<lista de variáveis>) 
escrever(<literal>)
escrever(<literal>,<variável>)
Quadro 3.6 î Exemplos da sintaxe do comando de saída
Variáveis Exemplos de comandos de saída
media: real
nome: cadeia
01 escrever(media)
02 escrever("Digite o nome do aluno: ")
03 escrever("Média final = ",media)
04 escrever(nome," obteve média final = ",media) 
No exemplo 01 do Quadro 3.6, o comando de saída exibirá apenas o valor 
armazenado na variável media (considerando a variável media do exemplo 3.1, 
o valor exibido seria 8). No segundo exemplo, o comando de saída contém apenas 
um literal, que será reproduzido no dispositivo de saída. O exemplo 03 contém um 
literal (“Média final = “) e uma variável (media), separados por vírgula, resultando 
em Média final = 8. Supondo que a variável nome armazene Joana e a variável media 
armazene 8, a saída do exemplo 04 seria Joana obteve média final = 8. 
A aplicação do comando de saída pode ser observada no exemplo 3.2, que reescreve 
a solução do exemplo 3.1 resolvendo uma das limitações citadas anteriormente. 
Nesta solução, descrita no Quadro 3.7, a média do aluno é calculada e armazenada 
na memória (linha 07) e, por fim, exibida ao usuário (linha 08). 
Quadro 3.7 î Exemplo da aplicação de comandos de atribuição e saída de dados
Exemplo 3.2 - Calcula a média de um aluno, considerando duas notas. 
01 algoritmo exemplo32
02 variáveis
03 nota1, nota2, media: real
04 início
05 nota1 Å 7
06 nota2 Å 9
07 media Å (nota1 + nota2) / 2
08 escrever ("Média do aluno = ", media) 
09 fim
Algoritmos e programação I.indd 33Algoritmos e programação I.indd 33 7/8/2013 16:01:027/8/2013 16:01:02
Process BlackProcess Black
34
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 3.3 Instrução primitiva de entrada
A instrução primitiva de entrada permite que dados fornecidos pelo usuário via 
teclado (ou por outros dispositivos) sejam armazenados em variáveis na memória 
do computador. 
A sintaxe do comando de entrada de dados é exibida a seguir e exemplificada no 
Quadro 3.8. 
ler(<variável>)
ler(<lista de variáveis>)
Quadro 3.8 î Exemplos da sintaxe do comando de entrada
Variáveis Exemplos de comandos de saída
nota1: real
nota2: real
nome: cadeia
01 ler(nome,nota1,nota2)
02 escrever("Digite o nome do aluno: ")
 ler(nome)
 escrever("Digite a primeira nota do aluno: ")
 ler(nota1)
 escrever("Digite a segunda nota do aluno: ")
 ler(nota2) 
No primeiro exemplo do Quadro 3.8, as três variáveis são lidas em um único 
comando de entrada, sem nenhuma informação prévia ao usuário sobre o que ele 
deverá digitar. Ao contrário, o exemplo 02 lê uma variável de cada vez e, antes 
de cada comando de entrada, emite uma mensagem ao usuário indicando o que 
deve ser informado ao programa. Esta solução facilita a interação do usuário com 
o programa, garantindo que as informações sejam fornecidas na ordem correta. 
Retomando o exemplo que calcula a média do aluno, proposto na seção 3.1, o 
Quadro 3.9 apresenta a solução ideal para o problema, incluindo o comando de 
entrada para resolver a segunda limitação mencionada anteriormente, com relação 
às variáveis nota1 e nota2 que permaneciam inalteradas, resultando sempre o 
mesmo valor para média. Este algoritmo inicia solicitando que o usuário digite a 
primeira nota do aluno (linha 05) e, em seguida, lê o valor digitado e armazena na 
variável nota1 (linha 06). O mesmo acontece com a segunda nota (linhas 07 e 08). 
A média do aluno é calculada e armazenada na variável media (linha 09) e, por 
fim,
exibida ao usuário (linha 10). 
Algoritmos e programação I.indd 34Algoritmos e programação I.indd 34 7/8/2013 16:01:037/8/2013 16:01:03
Process BlackProcess Black
35
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 3.9 î Exemplo da aplicação de comandos de atribuição, entrada e saída 
Exemplo 3.3 - Calcula a média de um aluno, considerando duas notas. 
01 algoritmo exemplo33
02 variáveis
03 nota1, nota2, media: real
04 início
05 escrever("Digite a primeira nota: ")
06 ler(nota1)
07 escrever("Digite a segunda nota: ")
08 ler(nota2)
09 media ĸ (nota1 + nota2) / 2
10 escrever ("Média do aluno = ", media) 
11 fim
Um programador deve se preocupar em facilitar a interação do usuário com o 
programa. Então, é importante utilizar o comando de saída antes do comando 
de entrada, para indicar o que o usuário deve digitar (como nas linhas 05 e 07 
do exemplo 3.3). Outro detalhe importante a ser observado é a apresentação dos 
resultados que deve conter, além do resultado em si, mensagens explicando seu 
significado (como acontece na linha 10 do exemplo 3.3). 
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Algoritmos e programação I.indd 35Algoritmos e programação I.indd 35 7/8/2013 16:01:037/8/2013 16:01:03
Process BlackProcess Black
36
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Atividades 
1) Assinale (V) para as assertivas Verdadeiras e (F) para as Falsas.
(a) ( ) Instruções primitivas são comandos básicos utilizados para 
efetuar a entrada e a saída de dados e sua movimentação na 
memória, presentes apenas em alguns algoritmos.
(b) ( ) São instruções primitivas: o comando de atribuição, o comando 
de entrada de dados e o comando de saída de dados.
(c) ( ) O funcionamento do comando de atribuição consiste em avaliar 
a expressão, variável ou constante que está à esquerda do 
comando e armazenar o valor resultante na posição de memória 
correspondente à variável que aparece à direita do comando.
(d) ( ) A instrução primitiva de saída de dados tem por objetivo 
prover a interação entre o programa e o usuário (ou outros 
dispositivos). 
(e) ( ) A instrução primitiva de entrada permite que dados fornecidos 
pelo usuário via teclado (ou por outros dispositivos) sejam 
armazenados em variáveis na memória do computador. 
 
2) Sobre a instrução primitiva de atribuição...
(I) O resultado de uma operação de divisão sempre deve ser armazenado 
em uma variável declarada do tipo real, pois mesmo que o resultado 
desta operação seja um valor inteiro (exemplo: 10 / 5, cujo resultado 
será 2), este será armazenado como real.
(II) Os operandos de uma expressão com operadores mod e/ou div podem 
ser do tipo real, mas o resultado da expressão deve ser armazenado 
em uma variável do tipo inteiro.
(III) No comando de atribuição, o literal atribuído a uma variável do tipo 
cadeia ou caractere deve estar entre aspas conforme o exemplo: nome 
Å “Luciene”. 
Quais assertivas são VERDADEIRAS?
(a) Apenas I e II
(b) Apenas II.
(c) Apenas I e III.
(d) I, II e III.
(e) Nenhuma das respostas anteriores.
Algoritmos e programação I.indd 36Algoritmos e programação I.indd 36 7/8/2013 16:01:037/8/2013 16:01:03
Process BlackProcess Black
37
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a3) Considerando a declaração de variáveis a seguir, assinale os comandos de 
atribuição considerados INVÁLIDOS. 
variáveis
 nome, aluno: cadeia
 resp: caractere
 a, b, c: inteiro
 total, preco, resto: real
 teste, fl ag: lógico
(a) ( ) resp Å "sim" (f) ( ) total Å resto mod 5
(b) ( ) a Å b / 5 (g) ( ) a Å b + c
(c) ( ) teste Å "verdadeiro" (h) ( ) preco Å qtde * 5.00
(d) ( ) nome Å "Roberto" (i) ( ) fl ag Å teste
(e) ( ) b Å b + 1 (j) ( ) preco Å total - c
4) Assinale a opção em que uma ou mais das instruções primitivas está(ão) 
INCORRETA(s), considerando a declaração de variáveis a seguir.
variáveis
 nome: cadeia
 idade: inteiro
 peso, altura, imc: real
(a) escrever(“Informe o nome, o peso e a altura do paciente: “)
ler(nome, peso, altura)
imc Å peso / (altura * altura)
escrever(“IMC do paciente “,nome,” = “, imc)
(b) idade Å 10
nome Å “Solano Só”
escrever(nome,” tem “, idade, “ anos”)
(c) escrever(Informe o nome do paciente: )
ler(nome)
escrever(Informe a idade do paciente: )
ler(idade)
(d) ler(nome, peso, altura)
imc Å peso / (altura * altura)
escrever(imc)
(e) Nenhuma das respostas anteriores.
Algoritmos e programação I.indd 37Algoritmos e programação I.indd 37 7/8/2013 16:01:037/8/2013 16:01:03
Process BlackProcess Black
38
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 5) Considerando os comandos de atribuição a seguir, marque a opção que 
contenha a declaração de variáveis CORRETA. 
a Å 10 
b Å 2 
c Å a mod b
teste Å "S" 
desconto Å 500 * 0.1
x Å 50
y Å 10
z Å x / y
(a) variáveis
 a, b, x, y: inteiro
 c, desconto, z: real
teste: caractere
(b) variáveis
 teste: caractere 
 a, b, c, x, y: inteiro
 desconto, z: real
(c) variáveis
 teste: cadeia 
 a, b, c, x, y: inteiro
 desconto, z: real
(d) variáveis
 teste: caractere 
 a, b, x, y: inteiro
 c, desconto, z: real
(e) Nenhuma das respostas anteriores.
Respostas
 1) a = F; b = V; c = F; d = V; e = V.
 2) c.
 3) a, b, c, f, h.
 4) c.
 5) b
Algoritmos e programação I.indd 38Algoritmos e programação I.indd 38 7/8/2013 16:01:047/8/2013 16:01:04
Process BlackProcess Black
4 ESTRUTURA SEQUENCIAL
Vanessa Lindemann
Ao criar um algoritmo, tem-se como objetivo a solução de um determinado 
problema. Para que este problema seja resolvido, os conceitos básicos e as instruções 
primitivas estudados nos capítulos anteriores, devem estar organizados de forma a 
representar um conjunto de ações, que seguirá um fluxo de execução determinado 
por três estruturas básicas de controle: sequencial, condicional e repetitiva. 
Este capítulo é dedicado à estrutura sequencial, que contém um conjunto de 
instruções que serão executadas de forma linear, de cima para baixo, da esquerda 
para a direita, sem nenhum desvio entre as diretivas de início e fim do algoritmo. 
As estruturas de controle condicional e repetitiva serão estudadas nos capítulos 
subsequentes. 
4.1 Estrutura básica de um algoritmo sequencial
A estrutura básica de um algoritmo sequencial é apresentada no Quadro 4.1. Na 
linha 01, tem-se a identificação do algoritmo, seguida da declaração de variáveis 
(linhas 02 e 03) e, por fim, entre as diretivas de início e fim encontra-se o corpo do 
algoritmo (linhas 04 a 08). 
Quadro 4.1 î Estrutura básica de um algoritmo sequencial 
01 algoritmo <nome>
02 variáveis
03 <lista de variáveis>: <tipo>
04 início
05 <instrução 1>
06 <instrução 2>
07 <instrução n>
08 fim
Algoritmos e programação I.indd 39Algoritmos e programação I.indd 39 7/8/2013 16:01:047/8/2013 16:01:04
Process BlackProcess Black
40
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Como pode ser observado na estrutura apresentada no Quadro 4.1, o fluxo de 
execução de um algoritmo sequencial é linear. 
4.2 Exemplo de um algoritmo com estrutura sequencial 
O algoritmo apresentado no capítulo 3, que calcula a média de um aluno a partir 
de duas notas fornecidas pelo usuário, é um exemplo da aplicação da estrutura 
sequencial. Este exemplo, escrito em português estruturado, foi reproduzido 
novamente no Quadro 4.2. 
Quadro 4.2 î Exemplo de algoritmo sequencial em português estruturado 
Exemplo 3.3. Calcula a média de um aluno, considerando duas notas. 
01 algoritmo exemplo33
02 variáveis
03 nota1, nota2, media: real
04 início
05 escrever("Digite a primeira nota: ")
06 ler(nota1)
07 escrever("Digite a segunda nota: ")
08 ler(nota2)
09 media Å (nota1 + nota2) / 2
10 escrever ("Média do aluno = ", media) 
11 fi m
As instruções que compõem o corpo do algoritmo serão executadas uma após a 
outra, na mesma ordem em que foram escritas, sem qualquer tipo de desvio. Através 
da instrução primitiva de saída na linha 05, o usuário receberá uma mensagem 
solicitando que a primeira nota do aluno seja digitada. O valor digitado pelo 
usuário será lido e armazenado na variável nota1 (linha 06). Os mesmos passos 
são repetidos para a segunda nota (linhas 07 e 08), que é lida e armazenada na 
variável nota2. Em seguida, a variável media recebe a média do aluno, calculada 
na linha 09 a partir da expressão (nota1+nota2)/2. 
A solução do algoritmo, apresentada no Quadro 4.2, foi escrita em português 
estruturado, mas também é possível utilizar outras formas de representação, como 
ilustra o fluxograma da Figura 4.1. O fluxograma de um algoritmo sequencial 
permite, a partir do símbolo de início, a execução das instruções contidas nos 
símbolos subsequentes sem nenhum desvio, até alcançar o símbolo de fim. 
 
Algoritmos e programação I.indd 40Algoritmos e programação I.indd 40 7/8/2013 16:01:047/8/2013 16:01:04
Process BlackProcess Black
41
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aFigura 4.1 î Exemplo de algoritmo sequencial em fluxograma
Algoritmos e programação I.indd 41Algoritmos e programação I.indd 41 7/8/2013 16:01:047/8/2013 16:01:04
Process BlackProcess Black
42
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 4.3 Construção de algoritmos sequenciais
O primeiro passo, para chegar à solução de um problema, é identificar no seu 
enunciado quais são os dados de entrada e de saída e, a partir daí, definir o 
processamento necessário para gerar o resultado esperado. 
No exemplo apresentado na seção anterior, os dados de entrada são as notas do 
aluno e a saída esperada é a sua média. Para chegar a esse resultado, foi realizado o 
cálculo da média aritmética entre as duas notas fornecidas pelo usuário, conforme 
pode ser observado no esquema da Figura 4.2.
Figura 4.2 î Elementos básicos para construção do algoritmo de cálculo da média
Entrada Processamento Saída
Notas do aluno
nota1 nota2 o Calcular a médiamedia Å(nota1+nota2)/2 o
Média do aluno
media
A prévia identificação dos elementos básicos, ilustrados na Figura 4.2, é importante 
para a construção da solução do problema. Outros exemplos são apresentados 
a seguir com o objetivo de ilustrar passo a passo como construir soluções para 
algoritmos sequenciais. A partir do enunciado de cada problema são identificados os 
elementos básicos para a construção do algoritmo (entrada / processamento / saída) 
e, em seguida, apresenta-se a solução do problema em português estruturado. 
Exemplo 4.1
Descrição do problema: construa um algoritmo que: (a) leia o nome de um 
funcionário, a quantidade de horas por ele trabalhadas e o valor que ele recebe por 
hora; (b) calcule o salário bruto, o valor do INSS (8% sobre o salário bruto) e o salário 
líquido do funcionário; (c) escreva o nome do funcionário e os valores calculados.
A partir deste enunciado, monta-se o esquema da Figura 4.3 que contém os 
elementos básicos para a construção da solução. 
Figura 4.3 î Elementos básicos para construção do algoritmo do exemplo 4.1
Entrada Processamento Saída
nome
ht
vh o
Calcular salário bruto
sbÅht*vh
Calcular INSS
inssÅsb*0.08
Calcular salário líquido
slÅsb-inss
o
nome
sb
inss
sl
Algoritmos e programação I.indd 42Algoritmos e programação I.indd 42 7/8/2013 16:01:047/8/2013 16:01:04
Process BlackProcess Black
43
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aForam identificados, a partir do enunciado do problema (exemplo 4.1), três dados de 
entrada: nome do funcionário, horas trabalhadas e valor da hora (representados na 
Figura 4.3 pelas variáveis nome,ht e vh, respectivamente). Como saída, espera-se: 
nome do funcionário, salário bruto, inss e salário líquido (o nome do funcionário 
será informado pelo usuário e os outros dados serão calculados). No processamento, 
é necessário definir como, a partir dos dados de entrada, gerar o resultado esperado. 
Neste exemplo, foram criadas as variáveis sb, inss e sl para armazenar os 
valores calculados para o salário bruto, o INSS e o salário líquido. O salário bruto 
é calculado multiplicando a quantidade de horas trabalhadas pelo valor da hora 
(ht*vh), o valor do INSS representa 8% do salário bruto (sb*0.08) e, por fim, o 
salário líquido é o salário bruto menos o valor do INSS (sb-inss).
Com o esquema da Figura 4.3, portanto, é possível construir a solução para o 
problema, descrita em português estruturado no Quadro 4.3. 
Quadro 4.3 î Solução do exemplo 4.1 em português estruturado 
Exemplo 4.1 - Calcula o salário de um funcionário. 
01 algoritmo exemplo41
02 variáveis
03 nome: cadeia
04 ht: inteiro
05 vh,sb,inss,sl: real
06 início
07 escrever("Nome do funcionário: ")
08 ler(nome)
09 escrever("Quantidade de horas trabalhadas: ")
10 ler(ht)
11 escrever("Valor da hora: ")
12 ler(vh)
13 sb Å ht * vh
14 inss Å sb * 0.08
15 sl Å sb - inss
16 escrever ("Funcionário: ", nome)
17 escrever ("Salário bruto: R$", sb) 
18 escrever ("INSS: R$", inss) 
19 escrever ("Salário líquido: R$", sl) 
20 fim
O algoritmo inicia com a definição de um identificador (linha 01), que deve seguir 
as mesmas regras usadas para definir nomes de variáveis - como não é permitido o 
uso de espaço em branco e caracteres especiais, o exemplo 4.1 é identificado como 
exemplo41. Entre as linhas 02 e 05, consta a declaração de variáveis: o nome do 
funcionário é do tipo cadeia, a quantidade de horas trabalhadas foi declarada do 
Algoritmos e programação I.indd 43Algoritmos e programação I.indd 43 7/8/2013 16:01:057/8/2013 16:01:05
Process BlackProcess Black
44
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a tipo inteiro e as demais variáveis são do tipo real (valor da hora, salário bruto, inss 
e salário líquido). O corpo do algoritmo está entre as linhas 06 e 20, onde estão 
organizados os elementos básicos de entrada/processamento/saída do esquema 
apresentado na Figura 4.3. Os comandos que representam a entrada de dados 
estão entre as linhas 07 e 12 - antes de cada instrução primitiva de entrada (linhas 
08, 10 e 12), e será emitida uma mensagem para o usuário, indicando os dados a 
serem digitados (linhas 07, 09 e 11). Os cálculos do processamento aparecem entre 
as linhas 13 e 15, cujos resultados serão escritos entre as linhas 16 e 19 - comandos 
que representam a saída de dados. 
Exemplo 4.2
Descrição do problema: sabe-se que na cidade X o índice de natalidade anual é 
30% maior do que na cidade Y. Construa um algoritmo que, a partir do índice de 
natalidade anual da cidade Y, calcule e escreva
o valor estimado da natalidade 
anual na cidade X.
O esquema da Figura 4.4 contém os elementos básicos para a construção da solução 
deste problema. 
Figura 4.4 î Elementos básicos para construção do algoritmo do exemplo 4.2
Entrada Processamento Saída
Índice de 
natalidade anual 
da cidade Y
y
o
Calcular o índice de 
natalidade da cidade X, 
que é 30% superior ao da 
cidade Y
x Å y*1.3
o
Índice de 
natalidade anual 
da cidade X
x
A entrada é o índice de natalidade da cidade Y (representada pela variável y). 
O objetivo do algoritmo é calcular e escrever o índice de natalidade da cidade X 
(representada pela variável x), que é 30% superior ao da cidade Y. A solução para 
o problema está descrita em português estruturado no Quadro 4.4.
Algoritmos e programação I.indd 44Algoritmos e programação I.indd 44 7/8/2013 16:01:057/8/2013 16:01:05
Process BlackProcess Black
45
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 4.4 î Solução do exemplo 4.2 em português estruturado 
Exemplo 4.2 - Calcula o índice de natalidade de uma cidade. 
01 algoritmo exemplo42
02 variáveis
03 x, y: real
04 início
05 escrever("Índice de natalidade da cidade Y: ")
06 ler(y)
07 x Å y * 1.3
08 escrever ("Índice de natalidade da cidade X: ", x)
09 fim
Exemplo 4.3
Descrição do problema: faça um algoritmo que converta uma temperatura de graus 
Centígrados para graus Fahrenheit. A fórmula de conversão é F=(9*C+160)/5, onde 
F é a temperatura em Fahrenheit e C é a temperatura em Centígrados. 
Os dados de entrada e saída, bem como o processamento necessário para resolver 
o problema, podem ser observados na Figura 4.5. A partir destes dados, chega-se à 
solução para o problema, apresentada em português estruturado no Quadro 4.5.
Figura 4.5 î Elementos básicos para construção do algoritmo do exemplo 4.3
Entrada Processamento Saída
Temperatura em 
graus Centígrados
C o
Converter a temperatura 
de graus Centígrados para 
Fahrenheit
F Å(9*C+160)/5
o
Temperatura em 
graus Fahrenheit
F
Quadro 4.5 î Solução do exemplo 4.3 em português estruturado 
Exemplo 4.3 - Conversão de graus Centígrados para graus Fahrenheit. 
01 algoritmo exemplo43
02 variáveis
03 C, F: real
04 início
05 escrever("Temperatura em graus Centígrados: ")
06 ler(C)
07 F Å(9*C+160)/5
08 escrever ("Temperatura em graus Fahrenheit: ", F)
09 fim
Algoritmos e programação I.indd 45Algoritmos e programação I.indd 45 7/8/2013 16:01:057/8/2013 16:01:05
Process BlackProcess Black
46
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 4.4 Teste de mesa de algoritmos com estrutura sequencial 
O teste de mesa tem por objetivo detectar, caso existam, erros semânticos na 
solução do algoritmo (ou seja, erros de lógica). Para realizar o teste de mesa, as 
variáveis utilizadas no algoritmo devem ser listadas, uma simulação da execução do 
algoritmo é realizada e todos os valores assumidos pelas variáveis são registrados. 
No final, compara-se a resposta obtida com a resposta esperada. Caso não haja 
coincidência entre estas respostas, detectou-se um erro de lógica. 
Os exemplos descritos a seguir apresentam o algoritmo e seu teste de mesa. 
Exemplo 4.4
Descrição do problema: faça um algoritmo para calcular a área de um triângulo.
Figura 4.6 î Elementos básicos para construção do algoritmo do exemplo 4.4
Entrada Processamento Saída
Base e altura 
b h o
Calcular a área do triângulo
area Å (b*h)/2 o
Área do triângulo
area
Mesmo que não esteja explícito na descrição do problema, os dados de entrada podem 
ser identificados a partir da fórmula usada para calcular a área de um triângulo. 
Assim, como ilustra a Figura 4.6, os dados necessários para calcular esta área são a 
base e a altura do triângulo. No processamento, simplesmente, aplica-se a fórmula 
e, por fim, o resultado deverá ser exibido ao usuário. O algoritmo que resolve este 
problema é descrito no Quadro 4.6 e seu teste de mesa é explicado na sequência. 
Quadro 4.6 î Solução do exemplo 4.4 em português estruturado 
Exemplo 4.4 - Cálculo da área de um triângulo. 
01 algoritmo exemplo44
02 variáveis
03 b, h, area: real
04 início
05 escrever("Base: ")
06 ler(b)
07 escrever("Altura: ")
08 ler(h)
09 area Å(b*h)/2
10 escrever ("Área = ", area)
11 fim
Algoritmos e programação I.indd 46Algoritmos e programação I.indd 46 7/8/2013 16:01:057/8/2013 16:01:05
Process BlackProcess Black
47
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
linha b h area
 06 12
Para testar a solução apresentada, é preciso definir valores para os dados de entrada. 
Neste caso, a base e a altura do triângulo (no teste apresentado a seguir definiu-se 
b = 12 e h = 5, que resultará em uma área de 30). Em seguida, é necessário montar a 
tabela onde devem constar todas as variáveis utilizadas na solução e o registro dos 
valores assumidos por elas na simulação da execução do algoritmo. Esta etapa do 
teste pode ser observada no Quadro 4.7. À esquerda, aparecem os valores definidos 
como dados de entrada; no centro, a tabela do teste de mesa que será preenchida 
durante a simulação de execução do algoritmo; e à direita, um espaço onde será 
registrada a saída do algoritmo. 
Quadro 4.7 – Teste de mesa do exemplo 4.4 î etapa 1
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
b = 12 
h = 5
 
Feito isto, a simulação de execução deve ser iniciada, passando linha a linha do 
algoritmo e registrando os valores assumidos pelas variáveis. Na linha 05 do 
algoritmo (Quadro 4.6), primeira instrução a ser executada, será emitida uma 
mensagem ao usuário para que ele informe a base do triângulo. Esta instrução não 
altera o valor de nenhuma das variáveis, portanto, não gera registro na tabela do 
teste de mesa. Na linha 06 (Quadro 4.6), o valor digitado pelo usuário será lido e 
armazenado na variável b, gerando um registro no teste de mesa, conforme ilustra 
o Quadro 4.8. Este registro contém o número da linha da instrução executada no 
algoritmo e o valor de entrada da variável b, definido como 12 neste teste. 
Quadro 4.8 – Teste de mesa do exemplo 4.4 î etapa 2, passo 1
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
b = 12 variáveis 
h = 5
linha b h area
variáveis
Algoritmos e programação I.indd 47Algoritmos e programação I.indd 47 7/8/2013 16:01:067/8/2013 16:01:06
Process BlackProcess Black
48
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Na linha 07 (Quadro 4.6), uma mensagem será emitida ao usuário solicitando que 
ele digite a altura do triângulo, valor que será lido e armazenado na variável h 
(linha 08 - Quadro 4.6), gerando um novo registro na tabela do teste de mesa, que 
pode ser observado no Quadro 4.9. 
Quadro 4.9 – Teste de mesa do exemplo 4.4 î etapa 2, passo 2
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
b = 12
h = 5
A área do triângulo é calculada na linha 09 (Quadro 4.6). Considerando os valores 
armazenados nas variáveis b e h, tem-se (12*5)/2, que resulta em 30. Este valor 
é armazenado na variável area, devendo, portanto, ser registrado na tabela do 
teste de mesa. 
Quadro 4.10
– Teste de mesa do exemplo 4.4 î etapa 2, passo 3
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
b = 12
h = 5 
Por fim, na linha 10 (Quadro 4.6), consta a instrução primitiva de saída que irá 
exibir ao usuário o valor da área do triângulo, calculado no algoritmo. O Quadro 
4.11 apresenta, à direita, a saída do algoritmo. 
linha b h area
 06 12
 08 5
variáveis
linha b h area
 06 12
 08 5
 09 30
variáveis
Algoritmos e programação I.indd 48Algoritmos e programação I.indd 48 7/8/2013 16:01:067/8/2013 16:01:06
Process BlackProcess Black
49
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 4.11 – Teste de mesa do exemplo 4.4 î etapa 2, passo 4
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
b = 12
h = 5 Área = 30
Encerrada a simulação de execução, verifica-se que a resposta obtida coincide com 
a resposta esperada (área = 30). Portanto, o algoritmo está correto. 
Exemplo 4.5
Descrição do problema: escreva um algoritmo para calcular a quantidade de 
combustível necessária para um automóvel percorrer determinada distância. 
Considerar um consumo médio de um litro de combustível para cada 12 km 
rodados. 
Para calcular a quantidade de combustível necessária para um automóvel percorrer 
uma distância qualquer, é necessário saber a distância a ser percorrida e o consumo 
médio do veículo. No enunciado do problema, consta apenas o consumo médio do 
veículo. Portanto, a distância a ser percorrida deverá ser informada pelo usuário. 
A Figura 4.7 apresenta os elementos básicos para a construção deste algoritmo.
Figura 4.7 î Elementos básicos para construção do algoritmo do exemplo 4.5
Entrada Processamento Saída
Distância a ser 
percorrida 
distancia
o
Calcular a quantidade de 
combustível
litros Å distancia/12
o
Quantidade de 
combustível
litros
A partir destes dados, constrói-se o algoritmo com a solução para o problema 
(Quadro 4.12) e, em seguida, realiza-se o teste de mesa (Quadros 4.13 e 4.14). 
linha b h area
 06 12
 08 5
 09 30
variáveis
Algoritmos e programação I.indd 49Algoritmos e programação I.indd 49 7/8/2013 16:01:067/8/2013 16:01:06
Process BlackProcess Black
50
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 4.12 î Solução do exemplo 4.5 em português estruturado 
Exemplo 4.4 - Cálculo da área de um triângulo. 
01 algoritmo exemplo45
02 variáveis
03 distancia, litros: real
04 início
05 escrever("Informe a distância a ser percorrida: ")
06 ler(distancia)
07 litros Å distancia/12
08 escrever ("Serão necessários ",litros," de combustível.")
09 fim
Para testar a solução apresentada, definiu-se que a distância a ser percorrida é de 
200 km. Assim, o valor esperado como resultado é de 16,7 litros de combustível 
(200/12=16,7). O Quadro 4.13 apresenta a primeira etapa do teste de mesa, que 
consiste em montar o esquema para registrar os valores assumidos pelas variáveis 
durante a simulação da execução do algoritmo. 
Quadro 4.13 – Teste de mesa do exemplo 4.5 î etapa 1
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
distancia = 200
A simulação de execução é iniciada na linha 05 (Quadro 4.12), que exibirá uma 
mensagem ao usuário, para que ele digite a distância a ser percorrida com o veículo. 
Na sequência (linha 06 - Quadro 4.12), este valor será lido e armazenado na variável 
distancia, gerando um registro na tabela do teste de mesa, conforme pode ser 
observado no Quadro 4.14. 
linha
 distância litros
variáveis
Algoritmos e programação I.indd 50Algoritmos e programação I.indd 50 7/8/2013 16:01:067/8/2013 16:01:06
Process BlackProcess Black
51
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 4.14 – Teste de mesa do exemplo 4.5 î etapa 2, passo 1
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
distancia = 200
Na linha 07 (Quadro 4.12), a quantidade de litros necessária para percorrer a 
distância informada pelo usuário é calculada e o resultado é armazenado na variável 
litros. O registro desta execução aparece na tabela do teste de mesa do Quadro 
4.15, onde também consta a saída de dados executada na linha 08 (Quadro 4.12), 
considerando o resultado obtido. 
Quadro 4.15 – Teste de mesa do exemplo 4.5 î etapa 2, passo 2
Exemplo 4.4 - Cálculo da área de um triângulo. 
Entrada Teste de mesa Saída
distancia = 200 Serão necessários 16,7
 litros de combustível.
Encerrada a simulação de execução do algoritmo, verifica-se que a resposta obtida 
coincide com a resposta esperada (16,7 litros). Portanto, o algoritmo está correto. 
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: algoritmos, 
Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
linha
 distância litros
 06 200
variáveis
linha
 distância litros
 06 200
 07 16,7
variáveis
Algoritmos e programação I.indd 51Algoritmos e programação I.indd 51 7/8/2013 16:01:067/8/2013 16:01:06
Process BlackProcess Black
52
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Atividades 
 Para cada um dos exercícios a seguir, monte o esquema com os elementos 
básicos (entrada / processamento / saída), construa o algoritmo com a solução 
para o problema e, por fi m, realize o teste de mesa, para assegurar que a resposta 
esteja correta. 
(1) O custo fi nal de um carro novo para o consumidor é a soma do 
custo de fábrica, dos impostos e da porcentagem do distribuidor. 
Supondo que os impostos totalizam 45% sobre o custo de fábrica e a 
porcentagem do distribuidor seja de 20% sobre o valor total, escreva 
um algoritmo que leia o custo de fábrica de um carro, calcule e escreva 
o custo fi nal ao consumidor.
(2) Sabe-se que, para iluminar de maneira correta os cômodos de uma 
casa, para cada m2, deve-se usar 18W de potência. Faça um algoritmo 
que receba as duas dimensões de um cômodo (em metros), calcule
e 
apresente a sua área (em m2) e a potência de iluminação que deverá 
ser utilizada.
(3) Uma empresa que promove espetáculos teatrais precisa de um 
programa para defi nir o valor mínimo para o convite, considerando 
o custo total do espetáculo e o número de lugares disponíveis para 
o público no local da apresentação. 
(4) Sabe-se que
1 pé = 12 polegadas;
1 jarda = 3 pés;
1 milha = 1760 jardas.
Faça um algoritmo que receba uma medida em pés, faça as conversões 
conforme a descrição acima e mostre os resultados em polegadas, 
jardas e milhas.
(5) Considerando uma aplicação de P reais à taxa de juros i constante 
por um período de N meses, calcule e escreva qual será o montante 
M após o término da aplicação, sendo M = P * (1 + i) N.
Algoritmos e programação I.indd 52Algoritmos e programação I.indd 52 7/8/2013 16:01:077/8/2013 16:01:07
Process BlackProcess Black
5 ESTRUTURA DE CONTROLE CONDICIONAL: SE
Vanessa Lindemann
Como foi explicado anteriormente, os algoritmos seguem um fluxo de execução 
determinado por três estruturas básicas de controle: sequencial (tema do capítulo 
4), condicional e repetitiva. 
A estrutura condicional é utilizada para desviar o fluxo de execução do algoritmo 
para diferentes partes da solução. Ela divide-se em estrutura SE e estrutura 
ESCOLHA - a primeira delas abordada neste capítulo. A estrutura SE é mais flexível, 
podendo utilizar na sua condição todos os operadores relacionais (<, >, <=, >=, =, <>) 
e, quando forem necessárias, mais de uma condição com os operadores lógicos (E 
e OU) entre elas. Esta estrutura também é classificada como estrutura condicional 
SE simples, composta ou encadeada, como descrevem as próximas seções. 
5.1 Estrutura condicional SE simples
A sintaxe da estrutura condicional SE simples é apresentada a seguir. 
se(<condição ou lista de condições>)então
 <instrução ou bloco de instruções>
A condição é testada e resultará verdadeiro ou falso. Quando resultar verdadeiro, a 
instrução da cláusula então é executada. Esta estrutura pode conter mais de uma 
condição com operadores lógicos entre elas e, também, pode conter um bloco de 
instruções a ser executado, ao invés de uma instrução única. Vale lembrar que um 
bloco é composto por duas ou mais instruções, delimitado pelas diretivas de início e 
fim. O Quadro 5.1 apresenta três exemplos da estrutura condicional SE simples. 
Algoritmos e programação I.indd 53Algoritmos e programação I.indd 53 7/8/2013 16:01:077/8/2013 16:01:07
Process BlackProcess Black
54
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 5.1 î Exemplos da sintaxe da estrutura condicional SE simples
Com instrução única Com bloco de instruções Mais de uma condição e bloco de 
instruções
se(a>b)então
 escrever(a)
se(a>b)então
início 
 a Åa-b
 escrever(a)
fim
se(a>b)e(a<>0)e(b<>0)então
início 
 a Åa/b
 escrever(a)
fim 
No primeiro exemplo do Quadro 5.1, a estrutura condicional SE possui apenas 
uma condição (a>b) e, quando esta resultar verdadeiro, uma única instrução a ser 
executada (escrever(a)). O segundo exemplo também testa uma única condição. 
Entretanto, quando esta resultar verdadeiro, um bloco de instruções será executado. 
E, por fim, o terceiro exemplo apresenta uma situação em que três condições 
deverão ser verdadeiras para que o bloco de comandos seja executado. 
Para exemplificar a aplicação desta estrutura condicional, propõe-se a ampliação 
do exemplo que calcula a média de um aluno, cuja solução foi apresentada nos 
capítulos anteriores. Além de calcular e exibir a média do aluno, o algoritmo deverá 
emitir a mensagem “Aluno aprovado” sempre que a média for igual ou superior 
a 6.0 (seis). A solução para este problema, denominado exemplo 5.1, pode ser 
observada no Quadro 5.2. 
Quadro 5.2 î Exemplo de algoritmo com estrutura condicional SE simples 
Exemplo 5.1. Calcula a média de um aluno e emite mensagem “Aluno aprovado”. 
01 algoritmo exemplo51
02 variáveis
03 nota1, nota2, media: real
04 início
05 escrever("Digite a primeira nota: ")
06 ler(nota1)
07 escrever("Digite a segunda nota: ")
08 ler(nota2)
09 media Å (nota1 + nota2) / 2
10 escrever ("Média do aluno = ", media)
11 se(media>=6)então
12 escrever("Aluno aprovado!")
13 fim
As instruções das linhas 11 e 12 foram acrescentadas à solução inicial e, sempre 
que a condição (media>=6) for verdadeira, a mensagem Aluno aprovado! será 
exibida ao usuário. 
Algoritmos e programação I.indd 54Algoritmos e programação I.indd 54 7/8/2013 16:01:077/8/2013 16:01:07
Process BlackProcess Black
55
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aNa solução apresentada, entretanto, quando o aluno obtiver média inferior a 
6.0 (seis), nenhuma mensagem será exibida ao usuário informando sobre sua 
reprovação. Esta limitação pode ser resolvida utilizando a estrutura condicional 
SE composta, descrita na próxima seção. 
5.2 Estrutura condicional SE composta
A sintaxe da estrutura condicional SE composta pode ser observada a seguir. 
se(<condição ou lista de condições>)então
 <instrução ou bloco de instruções>
senão
 <instrução ou bloco de instruções>
Quando a condição avaliada resultar verdadeiro, a instrução da cláusula então 
será executada; caso contrário, quando resultar falso, é a instrução da cláusula 
senão que será executada. 
Com esta estrutura é possível acrescentar à solução do exemplo anterior, a emissão 
da mensagem “Aluno reprovado.” quando a média for menor que 6.0 (seis). A 
solução para este problema, denominado exemplo 5.2, pode ser observada no 
Quadro 5.3. 
Quadro 5.3 î Exemplo de algoritmo com estrutura condicional SE composta 
Exemplo 5.2. Calcula a média de um aluno e emite mensagem “Aluno aprovado” ou 
“Aluno reprovado”.
01 algoritmo exemplo52
02 variáveis
03 nota1, nota2, media: real
04 início
05 escrever("Digite a primeira nota: ")
06 ler(nota1)
07 escrever("Digite a segunda nota: ")
08 ler(nota2)
09 media Å (nota1 + nota2) / 2
10 escrever("Média do aluno = ", media)
11 se(media>=6)então
12 escrever("Aluno aprovado!")
13 senão
14 escrever("Aluno reprovado!")
15 fim
Algoritmos e programação I.indd 55Algoritmos e programação I.indd 55 7/8/2013 16:01:077/8/2013 16:01:07
Process BlackProcess Black
56
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a As instruções das linhas 13 e 14 foram acrescentadas à solução anterior. Desta forma, 
quando a condição (media>=6) for verdadeira, a mensagem Aluno aprovado! 
será exibida; e quando a condição resultar falso, o algoritmo emitirá a mensagem 
Aluno reprovado. 
Na sequência, mais um problema será resolvido para exemplificar a aplicação da 
estrutura SE composta e destacar a necessidade da estrutura SE encadeada. 
Exemplo 5.3
Descrição do problema: escreva um algoritmo que verifique se um valor qualquer 
digitado pelo usuário é positivo ou negativo. 
Figura 5.1 î Elementos básicos para construção do algoritmo do exemplo 5.3
Entrada Processamento Saída
valor
o
Comparar o valor com zero para 
verificar se é positivo ou negativo
se(valor<0)então
 escrever("Negativo")
senão
 escrever("Positivo")
o
Imprimir uma 
das mensagens:
 
Negativo
ou 
Positivo
Quadro 5.4 î Solução do exemplo 5.3 
Exemplo 5.3 - Verifica se um valor é negativo ou positivo. 
01 algoritmo exemplo53
02 variáveis
03 valor: real
04 início
05 escrever("Informe um valor qualquer: ")
06 ler(valor)
07 se(valor<0)então
08 escrever("Negativo")
09 senão
10 escrever("Positivo")
11 fim
Antes de iniciar o teste de mesa, vale lembrar que a escolha dos dados de testes é 
muito importante na simulação. Os
dados escolhidos devem garantir a execução 
Algoritmos e programação I.indd 56Algoritmos e programação I.indd 56 7/8/2013 16:01:077/8/2013 16:01:07
Process BlackProcess Black
57
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
ade todas as instruções do algoritmo, testando todas as possibilidades de saída. 
Neste exemplo, duas possibilidades serão testadas: um valor negativo e um valor 
positivo. 
No primeiro teste realizado, definiu-se como dado de entrada ƺ80. Assim, o 
resultado esperado é “Negativo”. O Quadro 5.5 apresenta a primeira etapa do teste 
de mesa, que consiste em montar o esquema para registrar os valores assumidos 
pelas variáveis durante a simulação da execução do algoritmo. 
Quadro 5.5 – Teste de mesa do exemplo 5.3
Exemplo 5.3 - Verifica se um valor é negativo ou positivo.
Entrada Teste de mesa Saída 
valor = ƺ80
A simulação de execução é iniciada na linha 05 (Quadro 5.4), que exibirá uma 
mensagem ao usuário solicitando que ele digite um valor qualquer. Na sequência 
(linha 06 ƺ Quadro 5.4), este valor será lido e armazenado na variável valor, 
gerando um registro na tabela do teste de mesa, conforme pode ser observado 
no Quadro 5.6. 
Quadro 5.6 – Teste de mesa do exemplo 5.3 î com valor negativo
Exemplo 5.3 - Verifica se um valor é negativo ou positivo.
Entrada Teste de mesa Saída 
valor = ƺ80 Negativo
 
Na linha 07 (Quadro 5.4), a condição (valor<0) é testada. Como ƺ80 é menor do 
que zero, esse teste resulta verdadeiro e, consequentemente, a instrução da cláusula 
então será executada, emitindo a mensagem “Negativo”. A saída gerada, portanto, 
coincide com a resposta esperada. 
Ao testar um valor positivo como 22, por exemplo, a condição da linha 07 (Quadro 
5.4) não será satisfeita, resultando falso. Neste caso, a instrução da cláusula senão 
será executada, emitindo a mensagem “Positivo”. Neste caso, o resultado obtido 
linha
 valor
 
variáveis
linha
 valor
 06 - 80
variáveis
Algoritmos e programação I.indd 57Algoritmos e programação I.indd 57 7/8/2013 16:01:087/8/2013 16:01:08
Process BlackProcess Black
58
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a também coincide com o resultado esperado. Os dados deste teste podem ser 
observados no Quadro 5.7.
Quadro 5.7 – Teste de mesa do exemplo 5.3 î com valor positivo
Exemplo 5.3 - Verifica se um valor é negativo ou positivo.
Entrada Teste de mesa Saída 
valor = 22 Positivo
Os testes de mesa realizados demonstram que os resultados obtidos através da 
simulação de execução do algoritmo, com valores negativos e positivos, coincidem 
com os resultados esperados. Mas o que aconteceria se o valor digitado pelo usuário 
fosse um 0 (zero)? Neste caso, o algoritmo emitiria a mensagem “Positivo”, que 
não condiz com o resultado esperado já que o zero é neutro. Para corrigir este 
problema, será necessário usar a estrutura condicional SE encadeada, descrita na 
próxima seção.
5.3 Estrutura condicional SE encadeada
A aplicação da estrutura condicional SE encadeada, cuja sintaxe é apresentada 
a seguir, pode ser observada no Quadro 5.8 que reescreve a solução do exemplo 
anterior e nos exemplos apresentados na sequência. 
 se(<condição ou lista de condições>)então
 <instrução ou bloco de instruções>
 senão
 se(<condição ou lista de condições>)então
 <instrução ou bloco de instruções>
 senão
 <instrução ou bloco de instruções> 
A solução do exemplo anterior, que verifica se um valor é positivo ou negativo, 
foi reescrita no Quadro 5.8, utilizando a estrutura SE encadeada (linhas 07 a 13). 
As modificações realizadas aparecem entre as linhas 10 e 13, onde mais um teste 
foi incluído para garantir que quando o dado de entrada for 0 (zero), o algoritmo 
emita uma mensagem “Zero é neutro”. 
linha
 valor
 06 22
variáveis
Algoritmos e programação I.indd 58Algoritmos e programação I.indd 58 7/8/2013 16:01:087/8/2013 16:01:08
Process BlackProcess Black
59
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 5.8 î Solução do exemplo 5.3 
Exemplo 5.3 - Verifica se um valor é negativo ou positivo. 
01 algoritmo exemplo53
02 variáveis
03 valor: real
04 início
05 escrever("Informe um valor qualquer: ")
06 ler(valor)
07 se(valor<0)então
08 escrever("Negativo")
09 senão
10 se(valor>0)então
11 escrever("Positivo")
12 senão
13 escrever("Zero é neutro")
14 fim
Para testar todas as possibilidades de saída desta solução, o teste de mesa deve ser 
realizado considerando três valores: um positivo, um negativo e o zero.
Exemplo 5.4
Descrição do problema: escreva um algoritmo para encontrar o maior entre dois 
valores quaisquer digitados pelo usuário. 
Figura 5.2 î Elementos básicos para construção do algoritmo do exemplo 5.3
Entrada Processamento Saída
valor1
valor2 o
Comparar os valores para 
encontrar o maior entre eles o
maior
ou mensagem: 
valores iguais
O algoritmo do Quadro 5.9 foi construído a partir dos dados do esquema da Figura 
5.2. Em seguida, apresenta-se o teste de mesa realizado (Quadros 5.5 e 5.6). 
Algoritmos e programação I.indd 59Algoritmos e programação I.indd 59 7/8/2013 16:01:087/8/2013 16:01:08
Process BlackProcess Black
60
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 5.9 î Solução do exemplo 5.4 
Exemplo 5.4 - Encontra o maior entre dois valores quaisquer. 
01 algoritmo exemplo54
02 variáveis
03 valor1,valor2:real
04 início
05 escrever("Informe o primeiro valor: ")
06 ler(valor1)
07 escrever("Informe o segundo valor: ")
08 ler(valor2)
09 se(valor1>valor2)então
10 escrever("Maior = ", valor1)
11 senão
12 se(valor2>valor1)então
13 escrever("Maior = ", valor2)
14 senão
15 escrever("Valores iguais!")
16 fim
Neste exemplo, três possibilidades devem ser testadas: valor1 maior; valor2 
maior; valor1 e valor2 iguais. 
No teste realizado, descrito a seguir, definiu-se como dados de entrada 8 e 5. 
Assim, o resultado esperado é “Maior = 8”. O Quadro 5.10 apresenta a primeira 
etapa do teste de mesa, que consiste em montar o esquema para registrar os valores 
assumidos pelas variáveis durante a simulação da execução do algoritmo. 
Quadro 5.10 – Teste de mesa do exemplo 5.4 î etapa 1
Exemplo 5.4 - Encontra o maior entre dois valores quaisquer.
Entrada Teste de mesa Saída 
valor1 = 8
valor2 = 5
A simulação de execução é iniciada na linha 05 (Quadro 5.9), que exibirá uma 
mensagem ao usuário solicitando que ele digite o primeiro valor. Na sequência 
(linha 06 ƺ Quadro 5.9), este valor será lido e armazenado na variável valor1, 
gerando um registro na tabela do teste de mesa, conforme pode ser observado no 
Quadro 5.11. 
linha
 valor1 valor2
variáveis
Algoritmos e programação I.indd 60Algoritmos e programação I.indd 60 7/8/2013 16:01:087/8/2013 16:01:08
Process BlackProcess Black
61
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro
5.11 – Teste de mesa do exemplo 5.4 î etapa 2, passo1
Exemplo 5.4 - Encontra o maior entre dois valores quaisquer.
Entrada Teste de mesa Saída 
valor1 = 8
valor2 = 5
A execução da linha 07 (Quadro 5.9) exibe uma mensagem solicitando que o 
usuário digite o segundo valor, que é lido e armazenado na variável valor2 
(linha 08 ƺ Quadro 5.9). O registro desta execução aparece na tabela do teste de 
mesa do Quadro 5.12. 
Quadro 5.12 – Teste de mesa do exemplo 5.4 î etapa 2, passo2
Exemplo 5.4 - Encontra o maior entre dois valores quaisquer.
Entrada Teste de mesa Saída 
valor1 = 8 Maior = 8
valor2 = 5
Na linha 09 (Quadro 5.9) acontece a comparação entre os dois valores armazenados 
na memória, 8 e 5. A condição testada verifica se o primeiro valor é maior que o 
segundo. Neste caso, a condição testada é 8>5, que resulta em verdadeiro e permite 
a execução da instrução da cláusula então. A saída gerada, portanto, é “Maior = 
8”, que coincide com a resposta esperada. 
Exemplo 5.5
Descrição do problema: tendo como dados de entrada a altura e o gênero de uma 
pessoa, escreva um algoritmo para calcular seu peso ideal, utilizando as seguintes 
fórmulas: para homens (72,7 x altura)ƺ58; para mulheres (62,1 x altura)ƺ44.7.
 
linha
 valor1 valor2
 06 8 
variáveis
 
linha
 valor1 valor2
 06 8
 08 5
variáveis
Algoritmos e programação I.indd 61Algoritmos e programação I.indd 61 7/8/2013 16:01:087/8/2013 16:01:08
Process BlackProcess Black
62
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 5.13 î Solução do exemplo 5.5 
Exemplo 5.5 - Calcula o peso ideal de uma pessoa. 
01 algoritmo exemplo55
02 variáveis
03 genero: caractere
04 altura, peso_ideal: real
05 início
06 escrever("Qual o seu gênero(M ou F)? ")
07 ler(genero)
08 escrever("Qual a sua altura? ")
09 ler(altura)
10 se(genero="M")então
11 peso_ideal Å (72.7*altura)-58
12 senão
13 se(genero="F")então
14 peso_ideal Å (62.1*altura)-44.7
15 senão
16 início
17 peso_ideal Å 0
18 escrever("Gênero inválido.")
19 fim
20 escrever("Peso ideal = ", peso_ideal)
21 fim
A solução deste exemplo será usada para relembrar alguns fundamentos já 
estudados: (a) a variável genero foi declara do tipo caractere (linha 03), por isso, 
ao compará-la com M ou com F, estes devem estar entre aspas, como pode ser 
observado nas linhas 10 e 13; (b) a cláusula senão da linha 15 possui um bloco de 
instruções a ser executado, delimitado pelas diretivas de início (linha 16) e fim (linha 
19); (c) o texto do algoritmo está indentado, facilitando a sua leitura e compreensão 
ƺ a instrução primitiva de saída da linha 20 está alinhada às instruções anteriores à 
estrutura SE, ou seja, ela não faz parte desta estrutura e será executada sempre.
Exemplo 5.6
Descrição do problema: leia um valor inteiro e verifique se ele é par ou ímpar.
Algoritmos e programação I.indd 62Algoritmos e programação I.indd 62 7/8/2013 16:01:097/8/2013 16:01:09
Process BlackProcess Black
63
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 5.14 î Solução do exemplo 5.6 
Exemplo 5.6 - Verifica se um valor é par ou ímpar. 
01 algoritmo exemplo56
02 variáveis
03 valor: inteiro
04 início
05 escrever("Digite um valor inteiro: ")
06 ler(valor)
07 se(valor mod 2 = 0)então
08 escrever(valor, " é par.")
09 senão
10 escrever(valor, " é ímpar.")
11 fim
Neste caso, a variável valor deve ser do tipo inteiro para ser utilizada com o 
operador mod, que retorna o resto de uma divisão.
Exemplo 5.7
Descrição do problema: um banco concederá um crédito especial aos seus clientes, 
variável conforme o saldo médio no último ano. Construa um algoritmo que leia 
o saldo médio de um cliente, calcule e escreva o valor do crédito de acordo com 
a tabela a seguir.
Saldo médio Crédito
Até R$ 500,00 sem crédito
Entre R$ 501,00 e 1.000,00 20% sobre o valor do saldo médio
Entre R$ 1.000,00 e 3.000,00 30% sobre o valor do saldo médio
Acima de R$ 3.000,00 40% sobre o valor do saldo médio
Algoritmos e programação I.indd 63Algoritmos e programação I.indd 63 7/8/2013 16:01:097/8/2013 16:01:09
Process BlackProcess Black
64
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 5.15 î Solução do exemplo 5.7 
Exemplo 5.7 - Calcula o valor de crédito disponível para um cliente. 
01 algoritmo exemplo57
02 variáveis
03 saldo_medio, credito: real
04 início
05 escrever("Digite o saldo médio do cliente no último ano: ")
06 ler(saldo_medio)
07 se(saldo_medio<=500)então
08 credito Å 0
09 senão
10 se(saldo_medio>500)e(saldo_medio<=1000)então
11 credito Å saldo_medio*0.2
12 senão
13 se(saldo_medio>1000)e(saldo_medio<=3000)então
14 credito Å saldo_medio*0.3
15 senão
16 credito Å saldo_medio*0.4
17 escrever ("O cliente tem R$", credito," de crédito.")
18 fim
Neste exemplo, as estruturas SE das linhas 10 e 13 possuem duas condições com o 
operador lógico E entre elas. Desta forma, para que a instrução da cláusula então 
seja executada, as duas condições devem resultar verdadeiro. 
Exemplo 5.8
Descrição do problema: faça um algoritmo que execute as operações básicas de uma 
calculadora. Leia dois valores numéricos e um símbolo; caso o símbolo seja um dos 
relacionados a seguir efetue a operação correspondente com os valores digitados 
pelo usuário; caso contrário, digite a mensagem “Operador inválido!”. Símbolos: 
+ soma, - subtração, * multiplicação, / divisão. Atenção para a divisão por 0! 
Algoritmos e programação I.indd 64Algoritmos e programação I.indd 64 7/8/2013 16:01:097/8/2013 16:01:09
Process BlackProcess Black
65
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 5.16 î Solução do exemplo 5.8 
Exemplo 5.8 - Executa as operações básicas de uma calculadora. 
01 algoritmo exemplo58
02 variáveis
03 valor1, valor2: real
04 op: caractere
05 início
06 escrever("Valor 1: ")
07 ler(valor1)
08 escrever("Operador (+ - * /): ")
09 ler(op)
10 escrever("Valor 2: ")
11 ler(valor2)
12 se(op="+")então
13 escrever("Resultado = ", valor1+valor2)
14 senão
15 se(op="-")então
16 escrever("Resultado = ", valor1-valor2)
17 senão
18 se(op="*")então
19 escrever("Resultado = ", valor1*valor2)
20 senão
21 se(op="/")então
22 se(valor2<>0)então
23 escrever("Resultado = ", valor1/valor2)
24 senão
25 escrever("Não é possível dividir por 0.")
26 senão
27 escrever("Operador inválido!")
28 fim
A solução apresentada neste exemplo possui várias estruturas SE encadeadas, onde 
a variável op foi comparada a quatro operadores diferentes (linhas 12, 15, 18 e 21). 
Nesta situação, quando a variável é do tipo inteiro lógico, ou caractere e precisa ser 
comparada com vários valores, também é possível resolver o problema utilizando 
a estrutura condicional ESCOLHA, tema do próximo capítulo. 
5.4 Formatação da solução do algoritmo
Como pode ser observado nos exemplos apresentados até agora, as soluções têm 
seu texto indentado (indentar significa
inserir determinado espaço entre a margem 
da página e o início do texto de um parágrafo). Recomenda-se o uso de indentação 
no texto do algoritmo para facilitar a sua leitura. O Quadro 5.17 apresenta o mesmo 
trecho de um algoritmo sem e com indentação, ilustrando o quanto a segunda 
opção deixa o algoritmo mais legível. 
Algoritmos e programação I.indd 65Algoritmos e programação I.indd 65 7/8/2013 16:01:097/8/2013 16:01:09
Process BlackProcess Black
66
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 5.17 î Formatação do texto do algoritmo
Sem indentação Com indentação
se(valor1>valor2)então 
escrever(valor1)
senão
se(valor2>valor1)então
escrever(valor2)
senão
escrever("Valores iguais!")
se(valor1>valor2)então 
 escrever(valor1)
senão
 se(valor2>valor1)então
 escrever(valor2)
 senão
 escrever("Valores iguais!")
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Atividades 
Parte I - Questões objetivas e testes de mesa
1) Após executar o teste a seguir:
x Å 0
se (a <= b) e (c > b) então 
 x Å 5
senão 
 x Å 10
 x estará armazenando 10 se:
 (a) a = b < c;
 (b) a > b <= c;
 (c) a <= b < c;
 (d) a < b < c;
 (e) Nenhuma das alternativas anteriores.
Algoritmos e programação I.indd 66Algoritmos e programação I.indd 66 7/8/2013 16:01:097/8/2013 16:01:09
Process BlackProcess Black
67
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a2) Após executar o teste a seguir:
w Å 10
se (g <= m) ou (h < m) então 
 w Å w * 5
senão 
 w Å w / 5
 W estará armazenando 2 se:
 (a) h <= m < g;
 (b) h = m < g;
 (c) g < m < h;
 (d) h < m <= g;
 (e) Nenhuma das alternativas anteriores.
3) Considerando o algoritmo apresentado a seguir...
algoritmo teste_de_mesa 
variáveis 
 x, y, z: lógico
início
 ler(x,y,z)
 se(x=V)então 
 se(y=V)então
 início
 comando 1
 se(z=F)então 
 comando 2
 senão 
 comando 3
 comando 4 
 fi m
 senão 
 comando 5
 comando 6
 fim 
Algoritmos e programação I.indd 67Algoritmos e programação I.indd 67 7/8/2013 16:01:107/8/2013 16:01:10
Process BlackProcess Black
68
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a (a) Se x = V, y = F e z = V, quais os comandos serão executados?
 (b) Se x = V, y = V e z = V, quais os comandos serão executados?
 (c) Quais os valores de x, y e z para que somente o comando 5 seja 
executado?
 (d) Quais os valores de x, y e z para que somente o comando 6 seja 
executado?
 (e) Nenhuma das alternativas anteriores.
 
4) Indique a saída dos trechos de algoritmo apresentados a seguir, 
considerando 
 A = 20, B = 5, C = 5 e D = 5.
(a) se NÃO(D > 5) então
 XÅ(A+B)*D
senão
 XÅ(A–B)/C
escreva X
Saída: 
(b) se(A>2)E(B<7)então
 XÅ(A+2)*(B–2)
senão
 XÅ(A+B)/D*(C+D)
escreva X
Saída:
(c) se(A=2)OU(B>7)então
 XÅ(A+2)*(B–2)
senão
 XÅ(A+B)/D*(C+D)
escreva X
Saída:
(d) se NÃO(A>3)E NÃO(B<7)então
 XÅA+B
senão
 XÅA/B
escreva X
Saída:
Algoritmos e programação I.indd 68Algoritmos e programação I.indd 68 7/8/2013 16:01:107/8/2013 16:01:10
Process BlackProcess Black
69
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a5) O algoritmo apresentado a seguir calcula a quantidade de latas de tinta 
necessárias e o custo para pintar tanques cilíndricos de combustível. Os dados 
de entrada são a altura (h) e o raio (r) do cilindro. A lata de tinta custa R$ 24,00, 
cada lata contém 5 litros e cada litro pinta 3 metros quadrados. 
 algoritmo exercicio5
 variáveis 
 h, r, c, qtde, area, litro: real
 início 
 ler (h, r) 
 area Å (3.14*r**2)+(2*3.14*r*h)
 litro Å area/3
 qtde Å litro/5
 c Å qtde*24
 escrever ("Custo = R$ ", c)
 escrever ("Quantidade de latas de tinta = ", qtde)
 fi m
 Qual a saída do algoritmo, considerando h = 6 e r = 2? Considere duas casas 
decimais para fazer os cálculos.
Parte II - Resolução de problemas
Para cada um dos exercícios a seguir, monte o esquema com os elementos básicos 
(entrada / processamento / saída), construa o algoritmo com a solução para o 
problema e, por fim, realize o teste de mesa para assegurar que a resposta esteja 
correta. 
1) Construa um algoritmo que verifi que se o nome e a senha informados pelo 
usuário são válidos considerando a tabela a seguir. Emita uma das mensagens 
“Acesso liberado” ou “Acesso negado”. 
Usuário Senha
analuisa 990123
luciano 714460
josue 134895
Algoritmos e programação I.indd 69Algoritmos e programação I.indd 69 7/8/2013 16:01:107/8/2013 16:01:10
Process BlackProcess Black
70
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 2) A empresa “1001 Utilidades” precisa de um algoritmo para calcular o salário de 
seus funcionários. O salário bruto de cada funcionário é calculado com base 
no nº de horas por ele trabalhadas no mês e o valor que ele recebe por hora. 
O salário líquido deve considerar a comissão de 2% sobre o total das vendas 
realizadas pelo funcionário no mês, o bônus por tempo de serviço (conforme a 
tabela abaixo) e, fi nalmente, o desconto de INSS (8% sobre o total a receber). 
Para a empresa, é importante ter os seguintes valores disponíveis em R$: 
salário fi xo, total de adicionais (comissão + bônus), desconto INSS e salário 
líquido. 
Tempo de serviço Bônus
Entre 2 e 4 anos 2%
Entre 5 e 10 anos 5%
Maior que 10 anos 10%
3) Faça um algoritmo que, tendo como dados de entrada um ponto qualquer, 
determine e escreva o seu quadrante. 
2 1 
3 4
X
Y
Algoritmos e programação I.indd 70Algoritmos e programação I.indd 70 7/8/2013 16:01:107/8/2013 16:01:10
Process BlackProcess Black
71
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a4) João Papo-de-Pescador, homem de bem, comprou um microcomputador 
para controlar o rendimento diário de seu trabalho. Toda vez que ele volta de 
um dia de pescaria e traz um peso de peixes maior que o estabelecido pelo 
regulamento de pesca do estado Rio Grande do Sul (100 quilos) deve pagar 
uma multa por quilo excedente, que varia de acordo com a tabela abaixo.
Peso em excesso (E) Valor da multa p/ quilo excedente
1 <= E < 28 R$ 2,50
28 <= E < 50 R$ 7,80
E >= 50 R$ 13,00
 
 Faça um algoritmo que leia a variável P (peso de peixes) e verifi que se há 
excesso. Se houver, armazene o excesso de peso na variável E e o valor da multa 
que João deverá pagar na variável M, caso contrário tais variáveis deverão 
receber 0 (zero). Apresente o peso em excesso e o valor da multa.
5) Faça um algoritmo que leia três valores (A, B e C) e verifi que se eles formam 
ou não um triângulo. Se for um triângulo, indique de que tipo é: equilátero, 
escaleno ou isósceles. 
 Triângulo: forma geométrica composta por três lados, sendo que cada lado 
é menor que a soma dos outros dois lados (isto é uma regra, ou seja, uma 
condição). Logo, é triângulo quando A<
B+C, B<A+C e C<A+B.
 Isósceles: dois lados iguais (A=B) ou (A=C) ou (B=C).
 Escaleno: todos os lados diferentes (A<>B) e (B<>C).
 Equilátero: todos os lados iguais (A=B) e (B=C).
Respostas dos exercícios da Parte I
 1 - b
 2 - b 
 3 (a) Comandos 5 e 6; 
 3 (b) Comandos 1, 3, 4 e 6; 
 3 (c) x = V, y = F, z = não é testado; 
 3 (d) Impossível executar apenas o comando 6. 
 
Algoritmos e programação I.indd 71Algoritmos e programação I.indd 71 7/8/2013 16:01:107/8/2013 16:01:10
Process BlackProcess Black
72
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 4 (a) 3
 4 (b) 66
 4 (c) 50
 4 (d) 4
 
 5 - Custo = R$ 140,64
 Quantidade de latas de tinta = 5,86
Algoritmos e programação I.indd 72Algoritmos e programação I.indd 72 7/8/2013 16:01:117/8/2013 16:01:11
Process BlackProcess Black
6 ESTRUTURA DE CONTROLE CONDICIONAL: ESCOLHA
Vanessa Lindemann
O capítulo anterior apresentou a estrutura condicional SE, que avalia uma expressão 
lógica que resulta verdadeiro ou falso. Se o resultado desta expressão for verdadeiro, 
as instruções da cláusula então são executadas. Caso contrário, o fluxo é desviado 
para executar as instruções da cláusula senão. Tem-se, portanto, dois caminhos 
possíveis a serem seguidos. Em situações de igualdade para uma mesma variável, 
em que é necessário comparar a variável com vários valores, utiliza-se a estrutura 
condicional SE encandeada (como ilustrou o exemplo 5.8). Neste caso, tem-se uma 
seleção de múltipla escolha. 
O uso da estrutura condicional ESCOLHA, tema deste capítulo, pode simplificar 
bastante a “cascata” de estruturas SE, necessária em situações de seleção de múltipla 
escolha. A estrutura ESCOLHA pode ser utilizada, portanto, em situações de 
igualdade para uma mesma variável, desde que esta variável seja do tipo inteiro, 
caractere ou lógico. 
A sintaxe da estrutura condicional ESCOLHA é apresentada a seguir.
 escolha(<variável>)
 caso <1>: <instrução ou bloco de instruções>
 caso <2>: <instrução ou bloco de instruções>
 caso <n>: <instrução ou bloco de instruções>
 senão
 <instrução ou bloco de instruções>
 fim
Algoritmos e programação I.indd 73Algoritmos e programação I.indd 73 7/8/2013 16:01:117/8/2013 16:01:11
Process BlackProcess Black
74
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Se a variável avaliada tiver um dos valores listados nas opções, a instrução (ou 
bloco de instruções) correspondente ao caso será executada. Quando a variável 
for diferente de todas as opções listadas, a instrução (ou bloco de instruções) da 
cláusula senão será executada. A cláusula senão é opcional nesta estrutura. 
Para demonstrar a aplicação da estrutura condicional ESCOLHA, a solução do 
exemplo 5.8 (descrita no capítulo 5), que executa as operações básicas de uma 
calculadora, foi reescrita no Quadro 6.1 substituindo a estrutura SE encadeada 
pela estrutura ESCOLHA. 
Quadro 6.1 î Solução do exemplo 5.8 com estrutura ESCOLHA
Exemplo 5.8 - Executa as operações básicas de uma calculadora. 
01 algoritmo exemplo58
02 variáveis
03 valor1, valor2: real
04 op: caractere
05 início
06 escrever("Valor 1: ")
07 ler(valor1)
08 escrever("Operador (+ - * /): ")
09 ler(op)
10 escrever("Valor 2: ")
11 ler(valor2)
12 escolha(op)
13 caso "+": escrever("Resultado = ", valor1+valor2)
14 caso "-": escrever("Resultado = ", valor1-valor2)
15 caso "*": escrever("Resultado = ", valor1*valor2)
16 caso "/": se(valor2<>0)então
17 escrever("Resultado = ", valor1/valor2)
18 senão
19 escrever("Não é possível dividir por 0.")
20 senão
21 escrever("Operador inválido!")
22 fim
23 fim
Comparando esta solução à apresentada no capítulo 5, que utilizou estrutura 
SE encadeada, é possível observar o quanto a estrutura condicional ESCOLHA 
simplifica a leitura e a compreensão do algoritmo. 
Na sequência, são apresentados mais alguns exemplos para demonstrar a aplicação 
da estrutura condicional ESCOLHA.
Algoritmos e programação I.indd 74Algoritmos e programação I.indd 74 7/8/2013 16:01:117/8/2013 16:01:11
Process BlackProcess Black
75
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aExemplo 6.1
Descrição do problema: faça um algoritmo que leia um valor inteiro entre 0 e 10 
e escreva o valor por extenso.
Quadro 6.2 î Solução do exemplo 6.1 
Exemplo 6.1 - Escreve um valor entre 0 e 10 por extenso. 
01 algoritmo exemplo61
02 variáveis
03 valor: inteiro
04 início
05 escrever("Digite um valor entre 0 e 10: ")
06 ler(valor)
07 escolha(valor)
08 caso 0: escrever("Zero")
09 caso 1: escrever("Um")
10 caso 2: escrever("Dois")
11 caso 3: escrever("Três")
12 caso 4: escrever("Quatro")
13 caso 5: escrever("Cinco")
14 caso 6: escrever("Seis")
15 caso 7: escrever("Sete")
16 caso 8: escrever("Oito")
17 caso 9: escrever("Nove")
18 caso 10: escrever("Dez")
19 senão
20 escrever("Valor inválido!")
21 fim 
22 fim
Exemplo 6.2
Descrição do problema: faça um algoritmo que leia um código (COD) e duas 
variáveis (X e Y). Quando o código for A: teste e informe se X é par ou ímpar; B: 
teste e informe qual o menor valor (X ou Y); C: verifique e informe se os valores 
são múltiplos.
Algoritmos e programação I.indd 75Algoritmos e programação I.indd 75 7/8/2013 16:01:117/8/2013 16:01:11
Process BlackProcess Black
76
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 6.3 î Solução do exemplo 6.2 
Exemplo 6.2 - Executa instruções conforme um código (A, B ou C). 
01 algoritmo exemplo62
02 variáveis
03 codigo: caractere x, y: inteiro 
04 início
05 escrever("Qual o código (A, B ou C)? ") ler(codigo) 
06 escrever("Qual o valor de x? ") ler(x)
07 escrever("Qual o valor de y? ") ler(y)
08 escolha(codigo)
09 caso "A": se(x mod 2 = 0)então
10 escrever(x, " é par.")
11 senão
12 escrever(x, " é ímpar.")
13 caso "B": se(x<y)então
14 escrever("x=",x," é menor do que y=",y)
15 senão
16 se(x>y)então
17 escrever("y=",y," é menor do que x=",x)
18 senão
19 escrever(x," e ",y," são iguais")
20 caso "C": se(x mod y = 0)ou(y mod x = 0)então
21 escrever(x," e ",y," são múltiplos)
22 senão
23 escrever(x," e ",y," não são múltiplos)
24 senão
25 escrever("Código inválido! Digite A, B ou C.")
26 fim 
27 fim
Como foi explicado anteriormente, o algoritmo é executado de cima para baixo e 
da esquerda para a direita, então é possível escrever mais de uma instrução por 
linha como ilustram as linhas 03, 05, 06 e 07. 
Exemplo 6.3
Descrição do problema: considerando o cardápio de uma lanchonete, apresentado 
a seguir, construa um algoritmo que calcule e informe o valor a ser pago por um 
Algoritmos e programação I.indd 76Algoritmos e programação I.indd 76 7/8/2013 16:01:117/8/2013 16:01:11
Process BlackProcess Black
77
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
adeterminado cliente. O algoritmo deve ler o código do produto e a quantidade 
adquirida, calcular e escrever o total a pagar. 
Código Descrição Preço
001 Cachorro-quente 8,00
002 Torrada 6,00
003 Xis 12,00
004 Refrigerante 3,00
005 Suco 3,00
006 Água mineral 2,00
Quadro 6.4 î Solução do exemplo 6.3 
Exemplo 6.3 - Calcula o total a pagar em uma lanchonete. 
01 algoritmo
exemplo63
02 variáveis
03 codigo, qtde: inteiro 
04 início
05 escrever("Digite o código do produto: ") 
06 ler(codigo)
07 escrever("Digite a quantidade: ")
06 ler(qtde)
08 escolha(codigo)
09 caso 001: escrever("Total a pagar = R$",qtde*8)
09 caso 002: escrever("Total a pagar = R$",qtde*6)
09 caso 003: escrever("Total a pagar = R$",qtde*12)
09 caso 004: escrever("Total a pagar = R$",qtde*3)
09 caso 005: escrever("Total a pagar = R$",qtde*3)
09 caso 006: escrever("Total a pagar = R$",qtde*2)
24 senão
25 escrever("Código inválido!")
26 fim 
27 fim
A solução apresentada está correta. Entretanto, possui limitações, pois só é possível 
registrar a compra de um produto a cada execução do algoritmo. Para resolver 
este problema, permitindo o registro de vários produtos em uma mesma compra, 
é necessário utilizar as estruturas de repetição, tema dos próximos capítulos. 
Algoritmos e programação I.indd 77Algoritmos e programação I.indd 77 7/8/2013 16:01:117/8/2013 16:01:11
Process BlackProcess Black
78
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Atividades 
Para cada um dos exercícios a seguir, monte o esquema com os elementos básicos 
(entrada / processamento / saída), construa o algoritmo com a solução para o problema 
e, por fim, realize o teste de mesa para assegurar que a resposta esteja correta. 
1) Construa um algoritmo que leia o código de um produto e imprima sua descrição 
e seu preço, conforme a tabela a seguir. O algoritmo deverá emitir uma mensagem 
de alerta, caso o código do produto digitado não esteja cadastrado.
Código Descrição Preço
1485 Camiseta 35,00
2395 Camisa 70,40
3400 Calça 120,00
4197 Jaqueta 190,00
5266 Moletom 90,00
2 ) Uma empresa concederá um aumento de salário aos seus funcionários, variáveis 
de acordo com o cargo, conforme a tabela abaixo. Escreva um algoritmo que leia o 
salário e o código do cargo de um funcionário, calcule o valor do novo salário. Se 
o cargo do funcionário não estiver na tabela, ele deverá receber 40% de aumento. 
Imprima a descrição do cargo, o salário antigo, o novo salário e a diferença.
Código Cargo % de aumento
101 Gerente 10%
102 Engenheiro 20%
103 Técnico 30%
Algoritmos e programação I.indd 78Algoritmos e programação I.indd 78 7/8/2013 16:01:127/8/2013 16:01:12
Process BlackProcess Black
79
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a3) Escrever um algoritmo que leia os seguintes dados:
 - o código do estado de origem da carga de um caminhão (conforme a Tabela 1);
 - o peso da carga do caminhão em toneladas;
 - o código da carga (conforme a Tabela 2).
 Com base nestas informações, o algoritmo deve calcular e escrever: 
 - o peso da carga convertido em quilos;
 - o preço da carga do caminhão;
 - o valor do imposto, considerando o preço da carga e o estado de origem;
 - o valor total transportado pelo caminhão (valor da carga + imposto). 
 Tabela 1 Tabela 2
Código do Estado Imposto Código da Carga Preço por quilo
1 35% 10 50,00
2 25% 20 100,00
3 15% 30 200,00
4 5%
5 isento
4) Escreva um algoritmo que calcule o que deve ser pago por um produto, 
considerando como dados de entrada o preço normal de etiqueta e a escolha 
da condição de pagamento. Utilize os códigos da tabela a seguir para efetuar 
o cálculo do valor a ser pago dependendo da condição de pagamento.
Código Condição de pagamento
1 A vista, em dinheiro ou cheque, recebe 10% de desconto
2 A vista, no cartão de crédito, recebe 5% de desconto
3 Em 2 vezes, preço normal de etiqueta, sem juros
4 Em 3 vezes, preço de etiqueta mais juros de 10%
5) Faça um algoritmo que leia um número entre 1 e 7 e informe o dia da semana 
correspondente, sendo domingo o número 1. Caso o número não corresponda 
a um dia da semana, o algoritmo deverá emitir mensagem de erro.
Algoritmos e programação I.indd 79Algoritmos e programação I.indd 79 7/8/2013 16:01:127/8/2013 16:01:12
Process BlackProcess Black
80
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
Algoritmos e programação I.indd 80Algoritmos e programação I.indd 80 7/8/2013 16:01:127/8/2013 16:01:12
Process BlackProcess Black
7 ESTRUTURA DE CONTROLE DE REPETIÇÃO: ENQUANTO
Vanessa Lindemann
Este capítulo dá continuidade à discussão a respeito de estruturas de controle 
do fluxo de execução dos algoritmos. Enquanto as estruturas condicionais, 
estudadas nos capítulos anteriores, têm como objetivo escolher entre diferentes 
fluxos de execução, a partir da avaliação de uma expressão, as estruturas de 
repetição possibilitam que uma ou mais instruções sejam executadas mais de 
uma vez no algoritmo, enquanto uma condição de interrupção for satisfeita. 
Como foi destacado no último exemplo do capítulo anterior (exemplo 6.3), em 
determinadas situações, é necessário que um conjunto de instruções possa ser 
repetido várias vezes. O exemplo mencionado deveria calcular o total gasto 
por um cliente em uma lanchonete. Entretanto, na solução apresentada, só é 
possível registrar a compra de um tipo de produto cada vez que o algoritmo é 
executado. Não é possível, por exemplo, registrar a compra de uma torrada e 
um refrigerante. Para resolver essa limitação, faz-se necessário o uso de uma das 
estruturas de controle de repetição, como pode ser observado mais adiante. 
As estruturas de controle de repetição dividem-se em ENQUANTO, REPITA 
e PARA. Elas diferenciam-se em relação ao momento em que a condição de 
interrupção será avaliada, que pode ser antes ou depois da primeira iteração. 
Outro fator a ser considerado na escolha da estrutura de repetição a ser 
usada refere-se ao conhecimento prévio sobre o número de iterações a serem 
realizadas. 
A estrutura de controle de repetição ENQUANTO é o objeto de estudo do presente 
capítulo, as outras duas estruturas serão abordadas nos capítulos subsequentes. A 
estrutura ENQUANTO permite executar uma ou mais instruções repetidamente 
Algoritmos e programação I.indd 81Algoritmos e programação I.indd 81 7/8/2013 16:01:127/8/2013 16:01:12
Process BlackProcess Black
82
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a enquanto sua condição de interrupção resultar verdadeiro. A sintaxe da estrutura 
de repetição ENQUANTO é apresentada a seguir.
 enquanto(<condição>)faça
 <instrução ou bloco de instruções>
Como pode ser observado, a condição de interrupção é verificada antes da execução 
da instrução ou bloco de instruções a ser repetido. Se o resultado desta condição 
for verdadeiro, a instrução ou bloco de instruções é executado e, logo após esta 
iteração, o fluxo de execução retorna para o início da estrutura ENQUANTO e a 
condição é avaliada novamente. Este processo é repetido até que a condição de 
interrupção resulte falso. Neste caso, o fluxo de execução do algoritmo continuará 
a partir da instrução imediatamente após à estrutura ENQUANTO. Vale destacar 
que, como a condição de interrupção é avaliada no início da estrutura
de controle, 
quando esta resultar falso na primeira vez em que for verificada, a instrução ou 
bloco de instruções da estrutura não será executado nenhuma vez. 
Para exemplificar a aplicação da estrutura ENQUANTO, o problema descrito 
no exemplo 6.3 será resolvido novamente a seguir ƺ neste capítulo denominado 
exemplo 7.1. 
 
Exemplo 7.1
Descrição do problema: considerando o cardápio de uma lanchonete, apresentado 
a seguir, construa um algoritmo que calcule e informe o valor a ser pago por um 
determinado cliente. O algoritmo deve ler o código do produto e a quantidade 
adquirida, calcular e escrever o total a pagar. 
Código Descrição Preço
001 Cachorro-quente 8,00
002 Torrada 6,00
003 Xis 12,00
004 Refrigerante 3,00
005 Suco 3,00
006 Água mineral 2,00
Algoritmos e programação I.indd 82Algoritmos e programação I.indd 82 7/8/2013 16:01:127/8/2013 16:01:12
Process BlackProcess Black
83
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 7.1 î Solução do exemplo 7.1 
Exemplo 7.1 - Calcula o total a ser pago por um cliente em uma lanchonete. 
01 algoritmo exemplo71
02 variáveis
03 codigo, qtde: inteiro 
04 total: real
05 resp: caractere 
06 início
07 total Å 0
08 resp Å "S"
09 enquanto(resp="S")faça
10 início 
11 escrever("Digite o código do produto: ") 
12 ler(codigo)
13 escrever("Digite a quantidade adquirida: ")
14 ler(qtde)
15 escolha(codigo)
16 caso 001: total Å total + (qtde*8.00)
17 caso 002: total Å total + (qtde*6.00)
18 caso 003: total Å total + (qtde*12.00)
19 caso 004: total Å total + (qtde*3.00)
20 caso 005: total Å total + (qtde*3.00)
21 caso 006: total Å total + (qtde*2.00)
22 senão
23 escrever("Código inválido!")
24 fim 
25 escrever("Continuar o registro de produtos? S/N ")
26 ler(resp)
27 fim
28 escrever("Total a pagar = R$",total)
29 fim
Antes de iniciar a solução do algoritmo, é necessário ler com atenção o seu 
enunciado para identificar os dados de entrada e saída e definir como processá-
los para resolver o problema. Neste caso, por exemplo, a partir da descrição 
do problema não é possível saber previamente o número de iterações a serem 
realizadas. Um cliente pode comprar dois itens diferentes (torrada + refrigerante), 
outro cliente pode comprar quatro itens (torrada + refrigerante + xis + suco). Diante 
deste contexto, após cada iteração, o usuário irá informar se deseja continuar o 
registro de produtos ou totalizar a compra. A resposta do usuário é testada na 
condição de interrupção (linha 09), de forma que enquanto sua resposta for S 
(sim), o bloco de instruções (entre as linhas 10 e 27) que permite o registro de 
Algoritmos e programação I.indd 83Algoritmos e programação I.indd 83 7/8/2013 16:01:127/8/2013 16:01:12
Process BlackProcess Black
84
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a uma compra será repetido. Quando o usuário responder N (não), a condição de 
interrupção não será satisfeita e o fluxo de execução continuará a partir da instrução 
imediatamente após o bloco da estrutura ENQUANTO, ou seja, na linha 28, que 
exibirá uma mensagem ao usuário com o valor total a ser pago. 
Considerando que as estruturas de controle de repetição permitirão a criação 
de algoritmos mais complexos, para os quais a necessidade de testes se faz mais 
presente, propõe-se a realização do teste de mesa deste algoritmo, cujo resultado 
pode ser observado no Quadro 7.2. Para simular a execução deste algoritmo foi 
considerada a compra dos seguintes produtos: duas torradas, um xis e três sucos 
- dados de entrada, listados à esquerda no Quadro 7.2. 
Quadro 7.2 – Teste de mesa do exemplo 7.1
Exemplo 5.4 - Encontra o maior entre dois valores quaisquer.
Entrada Teste de mesa Saída 
2 torradas Total a pagar = R$ 33,00
1 xis
3 sucos
A simulação de execução é iniciada na linha 07 (Quadro 7.1), onde a variável 
total é inicializada com 0 (zero), gerando o primeiro registro na tabela do teste 
de mesa (Quadro 7.2). Na sequência (linha 08), a variável resp é inicializada com o 
caractere S. Esta variável irá armazenar a resposta do usuário referente a continuar 
linha
variável
resp cod qtde total
07 0
08 S
12 002
14 2
17 12.00
26 S
12 003
14 1
18 24.00
26 S
12 005
14 3
20 33.00
26 N
Algoritmos e programação I.indd 84Algoritmos e programação I.indd 84 7/8/2013 16:01:137/8/2013 16:01:13
Process BlackProcess Black
85
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aou não o registro de produtos (linha 26) que, consequentemente, será a condição 
de interrupção da estrutura ENQUANTO (linha 09). Entretanto, na primeira 
verificação da condição de interrupção (linha 09), o usuário ainda não respondeu 
se deseja continuar ou não e, por isso, a variável resp está vazia. Para que o bloco 
de instruções da estrutura seja executado, a condição de interrupção da estrutura 
deverá resultar verdadeiro, ou seja, a variável resp deve ser inicializada com S. 
A condição de interrupção da linha 09 (Quadro 7.1) é avaliada e resulta verdadeiro 
porque, neste momento, a variável resp está armazenando S, como pode ser 
observado na segunda linha da tabela do teste de mesa, no Quadro 7.2. Na 
sequência, o usuário irá informar o código do produto escolhido pelo cliente 
(valor lido na linha 12 do Quadro 7.1 e armazenado na variável codigo) e a 
quantidade adquirida (valor lido na linha 14 do Quadro 7.1 e armazenado na 
variável qtde). A estrutura de seleção ESCOLHA é usada para desviar o fluxo 
de execução para o caso 002, que representa a torrada comprada pelo cliente. 
Neste momento, na linha 17 (Quadro 7.1), total m total + (qtde*6.00), 
ou seja, a variável total recebe o que ela já tinha armazenado (zero), mais o valor 
resultante de (qtde*6.00) (ou seja, 2 torradas x 6,00 = 12,00), funcionando 
como um acumulador (as variáveis usadas com a função de acumular valores 
sempre devem ser inicializadas). 
A execução terá continuidade na linha 25 (Quadro 7.1), na instrução imediatamente 
após a estrutura ESCOLHA, quando o usuário será questionado se deseja continuar 
o registro de produtos. Considerando os dados de entrada escolhidos para esta 
simulação, a resposta do usuário deverá ser S pois ainda faltam registrar dois tipos 
de produtos: xis e suco. Esta resposta é lida na linha 26 (Quadro 7.1) e armazenada 
na variável resp, como pode ser observado no primeiro registro da linha 26 na 
tabela do teste de mesa (Quadro 7.2). Encerra-se, portanto, a primeira iteração 
desta simulação. 
Ao encontrar o final do bloco de instruções da estrutura ENQUANTO (linha 
27 ƺ Quadro 7.1), o fluxo de execução retorna para a linha 09, onde sua condição 
de interrupção é testada novamente. Como a variável resp está armazenando S 
neste momento, a condição resultará verdadeiro e, consequentemente, o bloco de 
instruções da estrutura ENQUANTO será executado novamente ƺ nesta segunda 
iteração será registrada a compra do produto de código 003 (xis). Uma terceira 
iteração será executada para registrar a compra do produto de código 005 (suco). 
Depois de registrar os sucos, o usuário deverá responder que não quer continuar 
registrando produtos e a variável resp estará armazenando N, como mostra 
a última linha da tabela do teste de mesa (Quadro 7.2). Logo, a condição de 
interrupção não será satisfeita, ou seja, resp não é mais igual a S. O total a pagar 
(R$ 33,00) é exibido ao usuário através da instrução da linha 28 (Quadro 7.1) e a 
simulação do algoritmo é
encerrada (linha 29 ƺ Quadro 7.1). 
Algoritmos e programação I.indd 85Algoritmos e programação I.indd 85 7/8/2013 16:01:137/8/2013 16:01:13
Process BlackProcess Black
86
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Na sequência, outros exemplos da aplicação da estrutura de controle ENQUANTO 
são apresentados. Serão encontradas, a partir da descrição dos problemas, três 
situações diferentes em relação ao número de iterações a serem executadas: situação 
01, quando o número de iterações é conhecido; situação 02, quando o número 
de iterações não é conhecido, mas a descrição do problema define a condição de 
interrupção; situação 03, quando nem o número de iterações, nem a condição de 
interrupção são conhecidos. 
Na construção de algoritmos não existe “receita de bolo” para resolver um 
problema. Um mesmo problema pode ser resolvido de n formas diferentes e todas 
as soluções estarem igualmente corretas. Entretanto, considerando as três situações 
descritas acima, referentes ao número de iterações e à condição de interrupção 
estarem ou não previamente definidos no enunciado do problema, algumas dicas 
podem auxiliar na resolução dos problemas. Visando contribuir neste sentido, as 
soluções apresentadas a seguir são classificadas conforme as situações descritas e 
as instruções do algoritmo referentes a elas aparecem em negrito. 
Exemplo 7.2 
Descrição do problema: construa um algoritmo que leia 10 valores do tipo inteiro, 
calcule e escreva a média dos valores lidos. 
Este é um exemplo da primeira situação, ou seja, o número de iterações está 
especificado na descrição do problema ƺ o bloco de instruções da estrutura de 
repetição deverá ser executado 10 vezes. Nesta situação, cria-se uma variável 
do tipo contador para controlar o fluxo da estrutura de repetição. Esta variável, 
denominada cont, deverá: (a) ser inicializada no início do algoritmo (cont m 0); 
(b) ser validada na condição de interrupção para que sejam executadas 10 iterações 
(cont <10); (c) para cada valor lido, contar um (cont m cont + 1). Estas 
instruções aparecem em negrito na solução em português estruturado apresentada 
no Quadro 7.3. Na sequência, a Figura 7.1 ilustra esta mesma solução representada 
em fluxograma. 
Algoritmos e programação I.indd 86Algoritmos e programação I.indd 86 7/8/2013 16:01:137/8/2013 16:01:13
Process BlackProcess Black
87
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
SITUAÇÃO 01
N° de iterações determinado.
Quadro 7.3 î Solução do exemplo 7.2
Exemplo 7.1 - Calcula a média de 10 valores lidos. 
01 algoritmo exemplo72
02 variáveis 
03 valor, soma, cont: inteiro
04 media: real 
05 início 
06 cont m 0
07 soma m 0
08 enquanto(cont<10)faça
09 início 
10 escrever(“Digite um valor: “)
11 ler(valor)
12 cont m cont + 1
13 soma m soma + valor
14 fim
15 media m soma / 10
16 escrever(“Média = “, media)
17 fim
Figura 7.1 î Solução do exemplo 7.2 representada em fluxograma
Algoritmos e programação I.indd 87Algoritmos e programação I.indd 87 7/8/2013 16:01:137/8/2013 16:01:13
Process BlackProcess Black
88
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a A Situação 02, em que o número de iterações não é conhecido mas a descrição do 
problema define a condição de interrupção, pode ser observada no Quadro 7.4. 
Neste exemplo, a entrada de dados deverá ser encerrada quando o usuário digitar 
0 (zero). Portanto, a condição de interrupção irá testar a variável de entrada. A 
variável valor é lida no início do algoritmo (linha 09 ƺ Quadro 7.4) e avaliada na 
condição da linha 10 ƺ Quadro 7.4. Se a condição resultar verdadeiro, o bloco de 
instruções da estrutura ENQUANTO será executado. Este bloco possui um contador 
e um acumulador (linhas 12 e 13 ƺ Quadro 7.4), que serão usados para calcular a 
média no final do algoritmo (linha 17 ƺ Quadro 7.4), além da instrução primitiva 
de entrada (linha 15 ƺ Quadro 7.4) que irá ler um valor para cada nova iteração. 
 Exemplo 7.3
Descrição do problema: construa um algoritmo que leia vários valores do tipo 
inteiro (0 encerra a entrada de dados), calcule e escreva a média dos valores 
lidos. 
Quadro 7.4 î Solução do exemplo 7.3
Exemplo 7.3 - Calcula a média de vários valores lidos. 
01 algoritmo exemplo73
02 variáveis 
03 valor, soma, cont: inteiro
04 media: real 
05 início 
06 cont m 0
07 soma m 0
08 escrever("Digite um valor: ")
09 ler(valor)
10 enquanto(valor<>0)faça
11 início 
12 cont m cont + 1
13 soma m soma + valor
14 escrever("Digite um valor: ")
15 ler(valor)
16 fim
17 media m soma / cont
18 escrever("Média = ", media)
19 fim
SITUAÇÃO 02
N° de iterações determinado, com 
condição de interrupção definida.
Algoritmos e programação I.indd 88Algoritmos e programação I.indd 88 7/8/2013 16:01:147/8/2013 16:01:14
Process BlackProcess Black
89
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aO Quadro 7.5 ilustra a Situação 03, quando nem o número de iterações, nem a 
condição de interrupção, são conhecidos. Como foi visto no exemplo 7.1, nestes 
casos, é necessário criar uma variável auxiliar para controlar o fluxo de execução 
ƺ nos exemplos deste capítulo usou-se a variável resp para tal função.
Exemplo 7.4
Descrição do problema: construa um algoritmo que leia vários valores do tipo 
inteiro, calcule e escreva a média dos valores lidos. 
Quadro 7.5 î Solução do exemplo 7.4
Exemplo 7.4 - Calcula a média de vários valores lidos. 
01 algoritmo exemplo74
02 variáveis 
03 valor, soma, cont: inteiro
04 media: real 
05 resp: caractere 
06 início 
07 cont m 0
08 soma m 0
09 resp m "S"
10 enquanto(resp="S")faça
11 início 
12 escrever("Digite um valor: ")
13 ler(valor)
14 cont m cont + 1
15 soma m soma + valor
16 escrever("Continuar? S/N ")
17 ler(resp)
18 fim
19 media m soma / cont
20 escrever("Média = ", media)
21 fim
SITUAÇÃO 03
N° de iterações indeterminado, sem 
condição de interrupção definida.
Algoritmos e programação I.indd 89Algoritmos e programação I.indd 89 7/8/2013 16:01:147/8/2013 16:01:14
Process BlackProcess Black
90
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Exemplo 7.5 
Descrição do problema: construa um algoritmo que leia 10 valores do tipo inteiro 
e verifique quantos são múltiplos de três. 
Quadro 7.6 î Solução do exemplo 7.5
Exemplo 7.5 - Verifica quantos valores são múltiplos de três. 
01 algoritmo exemplo75
02 variáveis 
03 valor, cont, mult: inteiro 
04 início 
05 cont m 0
06 mult m 0
07 enquanto(cont<10)faça
08 início 
09 cont m cont + 1
10 escrever("Digite o ",cont,"° valor: ")
11 ler(valor)
12 Se(valor mod 3 = 0) então
13 mult m mult + 1
14 fim
15 escrever(mult, " valores são múltiplos de 3.")
16 fim
Exemplo 7.6
Descrição do problema: escreva um algoritmo que leia um número não 
determinado de valores (qualquer valor negativo encerra a entrada de dados), 
encontre e escreva o menor entre eles. 
Quadro 7.7 î Solução do exemplo 7.6
Exemplo 7.6 - Encontra o menor entre os valores digitados pelo usuário. 
01 algoritmo exemplo76
02 variáveis 
03 valor, menor: real 
04 início 
05 escrever("Digite um valor: ")
06 ler(valor)
07 menor m valor
08 enquanto(valor>=0)faça
09 início 
10 se(valor<menor)então
11 menor m valor
12 escrever("Digite um valor: ")
13 ler(valor)
14 fim
15 escrever("Menor valor = ", menor)
16
fim
SITUAÇÃO 01
N° de iterações determinado.
SITUAÇÃO 02
N° de iterações indeterminado, com 
condição de interrupção definida.
Algoritmos e programação I.indd 90Algoritmos e programação I.indd 90 7/8/2013 16:01:147/8/2013 16:01:14
Process BlackProcess Black
91
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aExemplo 7.7
Descrição do problema: uma empresa deseja aumentar o preço de seus produtos 
em 20%. Faça um algoritmo que leia o código e o preço atual de cada produto 
da empresa, calcule e escreva o preço novo; calcule e escreva a média dos preços 
com o aumento. 
Quadro 7.8 î Solução do exemplo 7.7
Exemplo 7.7 - Calcula o preço novo dos produtos e a média destes valores. 
01 algoritmo exemplo77
02 variáveis 
03 cod, cont: inteiro
04 preco,preconovo,soma,media:real 
05 resp: caractere 
06 início 
07 cont m 0
08 soma m 0
09 resp m "S"
10 enquanto(resp="S")faça
11 início 
12 escrever("Digite o código e o preço atual: ")
13 ler(cod, preco)
14 preconovo m preco * 1.2
15 escrever("Preço com 20% de aumento = R$ ",preconovo)
16 soma m soma + preconovo
17 cont m cont + 1
18 escrever("Continuar? S/N ")
19 ler(resp)
20 fim
21 media m soma / cont
22 escrever("Média dos preços com aumento = ", media)
23 fim
Exemplo 7.8
Descrição do problema: escreva um algoritmo para calcular a média final de cada 
um dos alunos de uma turma de Algoritmos, considerando 03 notas: trabalho A 
com peso 3, trabalho B com peso 2 e a prova com peso 5. Além disso, é importante 
saber a média geral da turma. 
SITUAÇÃO 03
N° de iterações indeterminado, sem 
condição de interrupção definida.
Algoritmos e programação I.indd 91Algoritmos e programação I.indd 91 7/8/2013 16:01:147/8/2013 16:01:14
Process BlackProcess Black
92
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 7.9 î Solução do exemplo 7.8
Exemplo 7.8 - Calcula a nota final dos alunos de uma turma e a média geral da turma. 
01 algoritmo exemplo78
02 variáveis 
03 cont: inteiro
04 n1, n2, n3, soma, media: real 
05 resp: caractere 
06 início 
07 cont m 0
08 soma m 0
09 resp m "S"
10 enquanto(resp="S")faça
11 início 
12 escrever("Digite as três notas do aluno: ")
13 ler(n1, n2, n3)
14 media m (n1*3 + n2*2 + n3*5)/10
15 escrever("Média do aluno = ",media)
16 soma m soma + media
17 cont m cont + 1
18 escrever("Continuar? S/N ")
19 ler(resp)
20 fim
21 media m soma / cont
22 escrever("Média geral da turma = ", media)
23 fim
Exemplo 7.9
Descrição do problema: Chico tem 1,5m e cresce 2cm por ano, enquanto Zé tem 
1,1m e cresce 3cm ao ano. Construa um algoritmo que calcule e mostre quantos 
anos serão necessários para que Zé seja maior que Chico. 
SITUAÇÃO 03
N° de iterações indeterminado, sem 
condição de interrupção definida.
Algoritmos e programação I.indd 92Algoritmos e programação I.indd 92 7/8/2013 16:01:147/8/2013 16:01:14
Process BlackProcess Black
93
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 7.10 î Solução do exemplo 7.9
Exemplo 7.9 - Calcula quantos anos são necessários para que Zé seja maior que 
Chico. 
01 algoritmo exemplo79
02 variáveis 
03 cont: inteiro
04 chico, ze: real 
06 início 
07 cont m 0
08 chico m 1.5
08 ze m 1.1
10 enquanto(ze<chico)faça
11 início 
12 chico m chico + 0.02
13 ze m ze + 0.03
14 cont m cont + 1
20 fim
22 escrever("São necessários", cont," anos para Zé > Chico.")
23 fim
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Algoritmos e programação I.indd 93Algoritmos e programação I.indd 93 7/8/2013 16:01:157/8/2013 16:01:15
Process BlackProcess Black
94
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Atividades 
Parte I - Questões objetivas 
1) O algoritmo a seguir imprime os números pares entre 1 e 20.
( ) Certo 
( ) Errado 
algoritmo exerc1
variáveis 
 i,x,y: inteiro
início
 i m 10 x m 20 y m 1
 se(i>=y)então
 início 
 i m y 
 y m x
 fim
 enquanto(i<y)faça
 início
 i m i + 1
 escrever(i)
 i m i + 1
 fim
fim
2) Simulando a execução do algoritmo a seguir, 
algoritmo exerc2
variáveis 
 a: inteiro
início
 ler(a)
 enquanto(a<=100)faça
 início
 se(a > -10)então
 escrever(a)
 ler(a)
 fim
fim
Algoritmos e programação I.indd 94Algoritmos e programação I.indd 94 7/8/2013 16:01:157/8/2013 16:01:15
Process BlackProcess Black
95
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a tendo como dados de entrada 2, 9, 47, -7, -11, -49, 47, 30, 100, -100, -120, -47, 14, 
114, 13, quantos números serão impressos? 
(a) 8;
(b) 9;
(c) 7;
(d) 15;
(e) 6.
3) Qual a saída do algoritmo a seguir, se as entradas forem 1 e 9 e, depois, 5 e 3? 
algoritmo exerc3
variáveis 
 i,v1,v2: inteiro
início
 ler(v1,v2)
 se(v1>v2)então
 escrever(“O primeiro valor deve ser menor que o 
segundo.”)
 senão 
 início
 i m v1
 enquanto(i<=v2)faça
 início
 se(i mod 2 <> 0)então
 escrever(i,”, “)
 i m i + 1
 fim
 fim
fim
Algoritmos e programação I.indd 95Algoritmos e programação I.indd 95 7/8/2013 16:01:157/8/2013 16:01:15
Process BlackProcess Black
96
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a (a) 1, 3, 5, 7, 9,
 O primeiro valor deve ser menor que o segundo.
 (b) 1, 3, 5, 7, 9
 O primeiro valor deve ser menor que o segundo.
 (c) 1, 3, 5, 7, 9,
 3, 5 
 (d) 2, 4, 6, 8,
 O primeiro valor deve ser menor que o segundo. 
 (e) 1, 3, 5, 7, 9,
 4,
4) Quantos valores serão lidos no algoritmo a seguir?
algoritmo exerc4
variáveis 
 valor: inteiro
início
 valor m 0
 enquanto(valor<>0)faça
 início
 escrever(“Digite um valor inteiro: “)
 ler(valor)
 fim
fim
 (a) Tantos quantos forem digitados.
 (b) Tantos quantos forem digitados, até ser digitado 0 (zero).
 (c) Tantos quantos forem digitados, até ser digitado um valor negativo.
 (d) Tantos quantos forem digitados, até ser digitado um valor que não é 
inteiro. 
 (e) Nenhum.
Algoritmos e programação I.indd 96Algoritmos e programação I.indd 96 7/8/2013 16:01:157/8/2013 16:01:15
Process BlackProcess Black
97
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a5) Considerando que X e Y são números inteiros positivos, assinale a alternativa 
CORRETA que descreve a tarefa executada pelo algoritmo abaixo. 
algoritmo exerc5
variáveis 
x,y,z,w: inteiro
início
escrever(“Digite os valores de x e y: “)
ler(x,y)
z m�1
enquanto(z*y<=x)faça
z m�z+1
z m�z-1
w m�x-z*y
escrever(z,w)
fim
 (a) Exibe, respectivamente, o quociente e o resto da variável x pela variável y.
 (b) Exibe, respectivamente, os dois primeiros números primos menores
que x e y.
 (c) Exibe, respectivamente, o resto e o quociente da variável x pela variável y.
 (d) Exibe, respectivamente, o valor correspondente às variáveis y e x. 
 (e) Exibe, respectivamente, o valor correspondente às variáveis x e y.
Parte II - Resolução de problemas
 Para cada um dos exercícios a seguir, construa o algoritmo com a solução 
para o problema e realize o teste-de-mesa para assegurar que a resposta esteja 
correta.
(1) Escreva um algoritmo que leia vários valores, conte e informe quantos 
são positivos e quantos são negativos. A entrada de dados deve encerrar 
quando o usuário digitar 0 (zero). 
(2) Escreva um algoritmo que leia 20 valores, encontre e escreva o maior 
entre eles. 
Algoritmos e programação I.indd 97Algoritmos e programação I.indd 97 7/8/2013 16:01:157/8/2013 16:01:15
Process BlackProcess Black
98
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a (3) Escreva um algoritmo que calcule a média dos números pares digitados 
pelo usuário. A entrada de dados deve encerrar quando o usuário 
digitar um valor menor ou igual a 0 (zero).
(4) Faça um algoritmo que lei um valor inteiro e positivo, calcule e escreva 
o seu fatorial. 
 Exemplos: !4 = 1 x 2 x 3 x 4 = 24 
 !5 = 1 x 2 x 3 x 4 x 5 = 120 
 Por defi nição, !0 = 1
(5) Em uma eleição presidencial existem 4 candidatos. Os votos são 
informados através de códigos, que obedecem a seguinte regra: 1, 2, 3, 
4 = voto para os respectivos candidatos; 5 = voto nulo; 6 = voto branco. 
Elabore um algoritmo que leia o voto de cada um dos eleitores, calcule 
e escreva: total de votos para cada candidato; total de votos nulos; total 
de votos em branco. Como fi nalizador do conjunto de dados tem-se o 
valor 0 (zero).
Respostas dos exercícios da Parte I
 1 - Certo
 2 - a
 3 - a
 4 - e
 5 - a
Algoritmos e programação I.indd 98Algoritmos e programação I.indd 98 7/8/2013 16:01:167/8/2013 16:01:16
Process BlackProcess Black
8 ESTRUTURA DE CONTROLE DE REPETIÇÃO: REPITA
Vanessa Lindemann
Ao contrário da estrutura ENQUANTO, estudada no capítulo anterior, a condição 
de interrupção da estrutura REPITA é verificada no final de cada iteração, como 
pode ser observado na sua sintaxe, apresentada a seguir. 
 repita
 <instrução ou bloco de instruções>
 até(<condição>)
Uma ou mais instruções serão executadas repetidamente até que sua condição 
resulte verdadeiro. Como a condição só é avaliada no final de cada iteração, a 
instrução ou bloco de instruções a ser repetido será executado pelo menos uma vez, 
independente do valor inicial da condição de interrupção. Depois de cada iteração, 
se o resultado da condição for falso, o fluxo de execução retorna para o início da 
estrutura REPITA. Este processo é repetido até que a condição de interrupção resulte 
verdadeiro. Neste caso, o fluxo de execução do algoritmo continuará a partir da 
instrução imediatamente após à estrutura REPITA. 
Como a estrutura de repetição REPITA é delimitada pela diretiva ATÉ, as diretivas 
de início e fim não são utilizadas para delimitar seu bloco de instruções como nas 
estruturas estudadas nos capítulos anteriores. 
Para exemplificar a aplicação da estrutura REPITA, são apresentados na sequência 
seis exemplos. Os três primeiros têm o mesmo objetivo, calcular e escrever o 
percentual de valores negativos digitados pelo usuário. Entretanto, cada um 
representa uma situação diferente em relação ao número de iterações ou à condição 
de interrupção ser ou não previamente conhecido. 
Algoritmos e programação I.indd 99Algoritmos e programação I.indd 99 7/8/2013 16:01:167/8/2013 16:01:16
Process BlackProcess Black
100
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a No exemplo 8.1, a descrição do problema indica que deverão ser lidos 25 valores, 
ou seja, o número de iterações é previamente conhecido ƺ cenário denominado 
Situação 01. No exemplo 8.2, não é possível prever quantos valores serão digitados, 
mas a condição de interrupção está definida (o valor zero deverá encerrar a entrada 
de dados) ƺ cenário denominado Situação 02. Por fim, a descrição do problema do 
exemplo 8.3 não contempla nenhuma destas informações, ou seja, não é possível 
prever o número de iterações necessárias, nem a condição para encerrar o laço de 
repetição ƺ cenário denominado Situação 03. 
Como no capítulo anterior, os problemas são classificados em uma destas situações 
e as instruções referentes a como prover o fluxo de repetição em tal situação 
aparecem em negrito.
Exemplo 8.1 
Descrição do problema: construa um algoritmo que leia 25 valores, calcule e escreva 
o percentual de valores negativos. 
Quadro 8.1 î Solução do exemplo 8.1
Exemplo 8.1 - Calcula o percentual de valores negativos. 
01 algoritmo exemplo81
02 variáveis 
03 cont, negativo: inteiro
04 valor, perc: real 
05 início 
06 cont m 0
07 negativo m 0
08 repita 
09 escrever("Digite um valor: ")
10 ler(valor)
11 cont m cont + 1
12 se(valor < 0)então
13 negativo m negativo + 1
14 até(cont=25)
15 perc m (negativo*100)/25
16 escrever("% de negativos = ",perc)
17 fim
SITUAÇÃO 01
N° de iterações determinado.
Algoritmos e programação I.indd 100Algoritmos e programação I.indd 100 7/8/2013 16:01:167/8/2013 16:01:16
Process BlackProcess Black
101
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aExemplo 8.2
Descrição do problema: construa um algoritmo que leia vários valores do tipo 
inteiro (0 encerra a entrada de dados), calcule e escreva o percentual de valores 
negativos. 
Quadro 8.2 î Solução do exemplo 8.2
Exemplo 8.2 - Calcula o percentual de valores negativos.
01 algoritmo exemplo82
02 variáveis 
03 cont, negativo: inteiro
04 valor, perc: real 
05 início 
06 cont m 0
07 negativo m 0
08 repita 
09 escrever("Digite um valor: ")
10 ler(valor)
11 cont m cont + 1
12 se(valor < 0)então
13 negativo m negativo + 1
14 até(valor=0)
15 perc m (negativo*100)/cont
16 escrever("% de negativos = ",perc)
17 fim
SITUAÇÃO 02
N° de iterações indeterminado, com 
condição de interrupção definida.
Algoritmos e programação I.indd 101Algoritmos e programação I.indd 101 7/8/2013 16:01:167/8/2013 16:01:16
Process BlackProcess Black
102
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Exemplo 8.3
Descrição do problema: construa um algoritmo que leia vários valores do tipo 
inteiro, calcule e escreva o percentual de valores negativos. 
Quadro 8.3 î Solução do exemplo 8.3
Exemplo 8.3 - Calcula o percentual de valores negativos.
01 algoritmo exemplo83
02 variáveis 
03 cont, negativo: inteiro
04 valor, perc: real 
05 resp: caractere
06 início 
07 cont m 0
08 negativo m 0
09 repita 
10 escrever("Digite um valor: ")
11 ler(valor)
12 cont m cont + 1
13 se(valor < 0)então
14 negativo m negativo + 1
15 escrever("Continuar? S/N ")
16 ler(resp)
17 até(resp="N")
18 perc m (negativo*100)/cont
19 escrever("% de negativos = ",perc)
20 fim
SITUAÇÃO 03
N° de iterações indeterminado, sem 
condição de interrupção definida.
Algoritmos e programação I.indd 102Algoritmos e programação I.indd 102 7/8/2013 16:01:167/8/2013 16:01:16
Process BlackProcess Black
103
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aExemplo 8.4 
Descrição do problema: uma pesquisa realizada em um clube coletou informações 
sobre as características físicas de 40 atletas, quais sejam: gênero (F- feminino, M - 
masculino), idade, peso e altura. Escreva um algoritmo para identificar: a maior
idade entre os atletas; a porcentagem de mulheres e de homens; o nº de homens 
com menos de 1,70m; o peso médio das mulheres. 
Quadro 8.4 î Solução do exemplo 8.4
Exemplo 8.4 - Pesquisa sobre as características físicas de atletas. 
01 algoritmo exemplo84
02 variáveis 
03 genero: caractere 
04 peso, altura, soma, media: real 
05 cont, idade, maior, fem, masc, alt: inteiro
06 início 
07 cont m 0 
08 maior m 0 fem m 0 masc m 0 soma m 0 alt m 0
09 repita 
10 escrever("Digite gênero, idade, peso e altura: ")
11 ler(genero, idade, peso, altura)
12 se(idade>maior)então
13 maior m idade
14 se(genero="F")então
15 início 
16 fem m fem + 1
17 soma m soma + peso
18 fim 
19 senão
20 se(genero="M")então
21 início 
22 masc m masc + 1
23 se(altura<1.70)então
24 alt m alt + 1
25 fim 
26 cont m cont + 1
27 até(cont=40)
28 fem m (fem*100)/40
29 masc m (masc*100)/40
30 media m soma/fem
31 escrever("Maior idade = ", maior)
32 escrever(fem,"% são mulheres e ", masc, "% homens")
33 escrever("Peso médio das mulheres = ", media)
34 escrever(alt, " homens medem menos que 1,70m")
35 fim
SITUAÇÃO 01
N° de iterações determinado.
Algoritmos e programação I.indd 103Algoritmos e programação I.indd 103 7/8/2013 16:01:167/8/2013 16:01:16
Process BlackProcess Black
104
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Exemplo 8.5
Descrição do problema: construa um algoritmo que repita a leitura de uma senha 
até que ela seja válida. Para cada senha incorreta escrever a mensagem “SENHA 
INVÁLIDA”. Quando a senha for informada corretamente deve ser impressa a 
mensagem “ACESSO PERMITIDO” e o algoritmo encerrado. Considere que a 
senha correta é a76dk09. 
Quadro 8.5 î Solução do exemplo 8.5
Exemplo 8.5 - Valida senha.
01 algoritmo exemplo85
02 variáveis 
03 senha: cadeia
05 início 
08 repita 
09 escrever("Digite a senha: ")
10 ler(senha)
12 se(senha<>"a76dk09")então
13 escrever("Senha inválida")
14 até(senha="a76dk09")
16 escrever("Acesso permitido")
17 fim
SITUAÇÃO 02
N° de iterações indeterminado, com 
condição de interrupção definida.
Algoritmos e programação I.indd 104Algoritmos e programação I.indd 104 7/8/2013 16:01:177/8/2013 16:01:17
Process BlackProcess Black
105
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aExemplo 8.6
Descrição do problema: realizou-se uma pesquisa com professores de uma 
universidade. Foram coletados os seguintes dados de cada professor: idade, tempo 
de serviço na universidade (em anos) e quantidade de disciplinas que ministra. 
Faça um programa que, a partir desses dados, calcule e informe: o percentual de 
professores com idade entre 30 e 50 anos, a quantidade de professores com mais 
de 10 anos de serviço e a média de disciplinas ministrada por professor. 
Quadro 8.6 î Solução do exemplo 8.6
Exemplo 8.6 - Pesquisa com professores de uma universidade.
01 algoritmo exemplo86
02 variáveis 
03 resp: caractere 
04 perc, media: real 
05 idade, ts, disc, qtde, cont, soma: inteiro
06 início 
07 perc m 0 qtde m 0 soma m 0 cont m 0 
08 repita 
09 escrever("Digite idade: ")
10 ler(idade)
11 escrever("Digite tempo de serviço: ")
12 ler(ts)
13 escrever("Digite qtde de disciplinas que ministra: ")
14 ler(disc)
15 se(idade>=30)e(idade<=50)então
16 perc m perc + 1
17 se(ts>10)então
18 qtde m qtde + 1
19 soma m soma + disc
20 cont m cont + 1
21 escrever("Continuar? S/N ")
22 ler(resp)
23 até(resp="N")
24 perc m (perc*100)/cont
25 media m soma/cont
26 escrever(perc,"% dos professores têm entre 30 e 50 anos")
27 escrever(qtde," prof. com tempo de serviço superior a 10")
28 escrever("Média de disciplinas por professor = , media")
29 fim
SITUAÇÃO 03
N° de iterações indeterminado, sem 
condição de interrupção definida.
Algoritmos e programação I.indd 105Algoritmos e programação I.indd 105 7/8/2013 16:01:177/8/2013 16:01:17
Process BlackProcess Black
106
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Atividades 
Parte I - Questões objetivas 
1) O algoritmo a seguir imprime a sequência de pares entre 1 e 100.
( ) Certo 
( ) Errado 
algoritmo exerc1
variáveis 
 n: inteiro
início
 n m 1 
 repita 
 escrever(i)
 i m i + 2
 até(i=100)
fim
2) Simulando a execução do algoritmo a seguir, 
algoritmo exerc2
variáveis 
 a: inteiro
início
 repita
 ler(a)
 se(a > -10)então
 escrever(a)
 até(a>100)
fim
Algoritmos e programação I.indd 106Algoritmos e programação I.indd 106 7/8/2013 16:01:177/8/2013 16:01:17
Process BlackProcess Black
107
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a tendo como dados de entrada 2, 9, 47, -7, -11, -49, 47, 30, 100, -100, -120, -47, 14, 
114, 13, quantos números serão impressos? 
(a) 8
(b) 9
(c) 7
(d) 15 
(e) 6
3) O algoritmo a seguir tem como objetivo calcular a média dos valores lidos. 
Entretanto, isto não acontece corretamente devido a um erro. 
01 algoritmo exerc3
02 variáveis 
03 n,s,m: real
04 i: inteiro
05 início
06 s m 0
07 i m 0
08 repita 
09 ler(n)
10 s m s + n
11 i m i + 1
12 até(i=10)
13 m m s/2
14 escrever(m)
15 fim
 O erro está na linha:
(a) 3
(b) 10
(c) 13
(d) 9 
(e) 12
Algoritmos e programação I.indd 107Algoritmos e programação I.indd 107 7/8/2013 16:01:177/8/2013 16:01:17
Process BlackProcess Black
108
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 4) Quantos valores serão lidos no algoritmo a seguir?
algoritmo exerc4
variáveis 
 valor: inteiro
início
 valor m 0
 repita
 escrever(“Digite um valor inteiro: “)
 ler(valor)
 até(valor=0)
fim
 (a) Tantos quantos forem digitados.
 (b) Tantos quantos forem digitados, até ser digitado 0 (zero).
 (c) Tantos quantos forem digitados, até ser digitado um valor negativo.
 (d) Tantos quantos forem digitados, até ser digitado um valor que não é 
inteiro. 
 (e) Nenhum.
5) Assinale a assertiva INCORRETA.
(a) Estruturas de repetição são necessárias para repetir uma instrução (ou 
bloco de instruções), que represente um comportamento padrão, várias 
vezes.
(b) Utilizando a estrutura de repetição REPITA, escreve-se uma instrução 
uma única vez e ela pode ser executada várias vezes.
(c) Na estrutura REPITA o fluxo de repetição é controlado por um 
contador.
(d) É imprescindível que haja uma instrução dentro do bloco de instruções 
da estrutura REPITA que permita alterar o valor lógico da condição. 
(e) A diferença entre as estruturas
ENQUANTO e REPITA é que na segunda 
as instruções são executadas no mínimo uma vez porque sua condição 
só é verifi cada ao fi nal de cada iteração.
Algoritmos e programação I.indd 108Algoritmos e programação I.indd 108 7/8/2013 16:01:177/8/2013 16:01:17
Process BlackProcess Black
109
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aParte II - Resolução de problemas
 Para cada um dos exercícios a seguir, construa o algoritmo com a solução 
para o problema e realize o teste de mesa para assegurar que a resposta esteja 
correta. 
(1) Escreva um algoritmo que leia uma série não determinada de dois 
valores. O primeiro valor é um código que signifi ca: (1) débito, (2) 
crédito e (0) fi m. O segundo valor é uma quantia numérica real. O 
programa deve calcular o total de débito e crédito e, ao fi nal, mostrar 
o saldo (crédito – débito). 
(2) Durante uma pesquisa realizada entre os habitantes de uma região, 
foram coletados os seguintes dados: idade, gênero e salário. Faça um 
algoritmo que calcule e informe: a média salarial do grupo; a maior 
idade do grupo; quantidade de mulheres com salário superior a R$ 
5.000,00.
(3) Um hotel cobra R$ 360,00 a diária e mais uma taxa de serviços. A taxa 
é de: R$ 5,50 por diária, se o número de diárias for maior que 15; R$ 
6,00 por diária, se o número de diárias for igual a 15; R$ 8,00 por diária, 
se o número de diárias for menor que 15. Construa um algoritmo que 
imprima o nome e a conta (total das diárias, total da taxa e total a pagar) 
de cada um dos clientes com reserva no hotel.
(4) Em um laboratório, usam-se dois tipos de cobaias: ratos e coelhos. O 
código para ratos é 1, e para coelhos é 2. Foram feitas 30 experiências 
que usaram essas cobaias. Faça um algoritmo que leia, para cada uma 
das experiências, o código e a quantidade de cobaias utilizadas. Deseja-
se saber: o total de cobaias utilizadas e o percentual de cada tipo de 
cobaia. 
(5) Elabore um algoritmo que repita a leitura de uma data até que ela 
seja válida. Para cada data incorreta escrever a mensagem “DATA 
INVÁLIDA”. Quando a data for informada corretamente deve ser 
impressa a mensagem “ACESSO DATA VÁLIDA” e o algoritmo 
encerrado. Para resolver este problema, use três variáveis para 
representar a data: dia, mês e ano; não esqueça de considerar ano 
bissexto, quando o mês de fevereiro tem 29 dias.
 
Algoritmos e programação I.indd 109Algoritmos e programação I.indd 109 7/8/2013 16:01:187/8/2013 16:01:18
Process BlackProcess Black
110
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Respostas dos exercícios da Parte I
 1 - Errado
 2 - b
 3 - c
 4 - b
 5 - c
Algoritmos e programação I.indd 110Algoritmos e programação I.indd 110 7/8/2013 16:01:187/8/2013 16:01:18
Process BlackProcess Black
9 ESTRUTURA DE CONTROLE DE REPETIÇÃO: PARA
Vanessa Lindemann
A estrutura de repetição PARA, diferente das outras duas já estudadas, é controlada 
por uma variável de controle, como pode ser observado na sintaxe apresentada 
a seguir. 
 para <v> de <vi> até <vf> passo <p> faça
 <instrução ou bloco de instruções>
Onde:
• v representa a variável de controle;
• vi indica o valor inicial da variável de controle;
• vf indica o valor fi nal da variável de controle;
• p defi ne o incremento ou decremento da variável de controle.
A variável de controle assumirá, a cada iteração, um dos valores da faixa que inicia 
com o valor vi e encerra no valor vf. O p corresponde ao incremento ou decremento 
dado à variável de controle. O padrão é incrementar 1 a cada iteração, caso em que 
a diretiva passo p pode ser omitida. 
Nos capítulos anteriores, foram identificados três cenários onde são utilizadas as 
estruturas de repetição: Situação 01, quando o número de iterações é previamente 
conhecido; Situação 02, quando o número de iterações é indeterminado, mas tem-
se uma condição de interrupção definida; Situação 03, quando nem o número de 
iterações, nem a condição de interrupção são previamente conhecidos - caso em 
que é necessário usar uma variável auxiliar na condição de parada do laço de 
repetição. Em português estruturado, a estrutura PARA só pode ser usada para 
Algoritmos e programação I.indd 111Algoritmos e programação I.indd 111 7/8/2013 16:01:187/8/2013 16:01:18
Process BlackProcess Black
112
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a resolver problemas em que o número de iterações é conhecido, ou seja, na Situação 
01. Algumas linguagens de programação, entretanto, possibilitam a implementação 
das outras situações.
Na Situação 01, o processo de repetição é denominado “laço contado” e, como 
foi visto nos capítulos anteriores, este pode ser resolvido utilizando as estruturas 
ENQUANTO e REPITA. Para isso, utiliza-se uma variável do tipo contador, que 
tem seu conteúdo alterado a cada iteração como ilustram os trechos de algoritmos 
apresentados no Quadro 9.1. 
Quadro 9.1 î Laço contado utilizando ENQUANTO e REPITA
ENQUANTO REPITA
01 cont m 0
02 enquanto(cont<25)faça
03 início
04 <demais instruções>
05 cont m cont + 1
06 fim
01 cont m 0
02 repita 
03 <demais instruções>
04 cont m� cont + 1
05 até(cont=25)
Como pode ser observado, nos dois exemplos do Quadro 9.1 a variável cont 
é inicializada (linha 01), incrementada (linha 05 no exemplo com a estrutura 
ENQUANTO e linha 04 com a estrutura REPITA) e testada para controlar o final 
do laço de repetição (linha 02 na estrutura ENQUANTO, linha 05 na estrutura 
REPITA). A estrutura PARA é a mais adequada para esta situação, pois há uma 
economia de instruções, a própria estrutura se encarrega de inicializar, incrementar 
e encerrar a variável de controle, como ilustra o Quadro 9.2. Estes três processos 
ocorrem na linha 01. 
Quadro 9.2 î Laço contado utilizando PARA
PARA
01 para cont de 1 até 25 faça
02 início
03 <instruções>
04 fim
O valor inicial da variável de controle é definido como 1; em seguida, verifica-
se se a condição de interrupção foi atingida (ou seja, se a variável de controle já 
chegou ao seu limite final que, neste caso, é 25): se a condição de interrupção foi 
Algoritmos e programação I.indd 112Algoritmos e programação I.indd 112 7/8/2013 16:01:187/8/2013 16:01:18
Process BlackProcess Black
113
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aatingida, a repetição se encerra e o algoritmo continuará sua execução na instrução 
imediatamente seguinte à estrutura PARA; se a condição de interrupção não foi 
atingida, o bloco de instruções da estrutura será executado e a variável de controle 
é incrementada. Este processo será repetido até que a variável de controle atinja o 
valor definido como limite final (25). 
Para exemplificar a aplicação da estrutura de repetição PARA, os quadros a 
seguir apresentam a solução de cinco problemas que utilizam esta estrutura na 
sua solução. 
Exemplo 9.1 
Descrição do problema: construa um algoritmo que leia 10 valores, um de cada 
vez, conte e escreva quantos estão no intervalo [10,20] e quantos estão fora deste 
intervalo. 
Quadro 9.3 î Solução do exemplo 9.1
Exemplo 9.1 - Verifica quantos valores pertencem a um intervalo. 
01 algoritmo exemplo91
02 variáveis 
03 valor, cont, dentro, fora: inteiro
04 início 
05 dentro m 0 fora m 0
06 para cont de 1 até 10 faça 
07 início 
08 escrever("Digite um valor: ")
09 ler(valor)
10 se(valor>=10)e(valor<=20)então
11 dentro m dentro + 1
12 senão
13 fora m fora + 1
14 fim 
15 escrever(dentro, " números dentro do intervalo")
16 escrever(fora, " números fora do intervalo")
17 fim
Exemplo 9.2 
Descrição do problema:
construa um algoritmo que escreva os números pares 
entre 1 e 100. 
SITUAÇÃO 01
N° de iterações determinado.
Algoritmos e programação I.indd 113Algoritmos e programação I.indd 113 7/8/2013 16:01:187/8/2013 16:01:18
Process BlackProcess Black
114
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 9.4 î Solução do exemplo 9.2
Exemplo 9.2 - Soma os número ímpares de um intervalo. 
01 algoritmo exemplo92
02 variáveis 
03 cont: inteiro
04 início 
05 para cont de 2 até 100 passo 2 faça 
06 escrever(cont)
07 fim
Exemplo 9.3 
Descrição do problema: construa um algoritmo que escreva a soma dos números 
ímpares entre dois valores quaisquer informados pelo usuário. 
Quadro 9.5 î Solução do exemplo 9.3
Exemplo 9.3 - Soma os número ímpares de um intervalo. 
01 algoritmo exemplo93
02 variáveis 
03 cont, vi, vf, soma: inteiro
04 início 
05 soma m 0 
06 escrever("Digite o valor inicial: ")
07 ler(vi) 
08 escrever("Digite o valor final: ")
09 ler(vf) 
10 para cont de vi até vf faça 
11 início 
12 se(cont mod 2 = 1)então
13 soma m soma + cont
14 fim 
15 escrever("Soma dos ímpares do intervalo = ", soma)
16 fim
Exemplo 9.4 
Descrição do problema: construa um algoritmo que leia um valor inteiro, entre 1 
e 10, e escreva a sua tabuada. 
SITUAÇÃO 01
N° de iterações determinado.
SITUAÇÃO 01
N° de iterações determinado.
Algoritmos e programação I.indd 114Algoritmos e programação I.indd 114 7/8/2013 16:01:187/8/2013 16:01:18
Process BlackProcess Black
115
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aExemplo: 5
 1 x 5 = 5
 2 x 5 = 10
 3 x 5 = 15
 4 x 5 = 20
 5 x 5 = 25
 6 x 5 = 30
 ...
 10 x 5 = 50
Quadro 9.6 î Solução do exemplo 9.4
Exemplo 9.4 - Escreve a tabuada de um valor. 
01 algoritmo exemplo94
02 variáveis 
03 valor, cont: inteiro
04 início 
05 escrever("Digite um valor inteiro entre 1 e 10: ")
06 ler(valor)
07 se(valor>=1)e(valor<=10)então 
08 para cont de 1 até 10 faça 
09 escrever(cont,"x",valor,"=",cont*valor)
10 senão
11 escrever("Valor inválido. Digite valore entre 1 e 10.") 
12 fim
Exemplo 9.5 
Descrição do problema: em uma pesquisa realizada com 1000 habitantes de 
uma região, foram coletados os seguintes dados: idade, gênero e salário. Faça 
um algoritmo que calcule e informe: a idade média do grupo, o percentual de 
mulheres e de homens e, também, a quantidade de pessoas com salário superior 
a R$ 5.000,00. 
SITUAÇÃO 01
N° de iterações determinado.
Algoritmos e programação I.indd 115Algoritmos e programação I.indd 115 7/8/2013 16:01:197/8/2013 16:01:19
Process BlackProcess Black
116
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 9.7 î Solução do exemplo 9.5
Exemplo 9.5 - Soma os número ímpares de um intervalo. 
01 algoritmo exemplo95
02 variáveis 
03 cont, idade, soma, pessoa: inteiro
04 salario, media, fem, masc: real
05 genero: caractere
06 início 
07 soma m 0 fem m 0 masc m 0 pessoa m 0 
08 para cont de 1 até 1000 faça 
09 início 
10 escrever("Digite idade, gênero (M ou F) e salário: ")
11 ler(idade, genero, salario) 
12 soma m soma + idade
13 se(genero="F")então
14 fem m fem + 1
15 senão
16 se(genero="M")então
17 masc m masc + 1
18 se(salario>5000)então
19 pessoa m pessoa + 1
20 fim 
21 media m soma/1000
22 fem m (fem *100)/1000
23 masc m (masc *100)/1000
24 escrever("Idade média = ", media)
25 escrever("Feminino = ", fem,"%")
26 escrever("Masculo = ", masc,"%")
27 escrever(pessoa, " pessoas possuem salário > 5.000,00")
28 fim
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
SITUAÇÃO 01
N° de iterações determinado.
Algoritmos e programação I.indd 116Algoritmos e programação I.indd 116 7/8/2013 16:01:197/8/2013 16:01:19
Process BlackProcess Black
117
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aAtividades 
Parte I - Questões objetivas 
1) Considerando o algoritmo a seguir,
algoritmo exerc1
variáveis 
 num, cont, aux, e: inteiro
início
 aux m 1 e m 1
 repita 
 escrever("Digite um número inteiro positivo: ")
 ler(num)
 até(num>0)
 para cont de 1 até num faça
 início
 aux m aux * cont
 e m e + aux
 fim
 escrever(e)
fim
 qual a saída se a entrada for 3 e depois 5?
 (a) 3 e 5;
 (b) 10 e 154;
 (c) 9 e 153;
 (d) 11 e 155; 
 (e) 4 e 34.
2) Considerando o algoritmo a seguir,
algoritmo exerc2
variáveis 
 v1, v2, s, x: inteiro
início
 s m 0
 ler(v1, v2)
 para x de v1 até v2 faça
 s m s + 2
 escrever(s)
fim
Algoritmos e programação I.indd 117Algoritmos e programação I.indd 117 7/8/2013 16:01:197/8/2013 16:01:19
Process BlackProcess Black
118
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a qual a saída, tendo como entrada 3 e 8?
 (a) 7;
 (b) 8;
 (c) 6;
 (d) 10; 
 (e) 12.
3) O algoritmo a seguir...
algoritmo exerc3
variáveis 
 i: inteiro
início
 para i de 100 até 1 passo -2 faça
 escrever(i)
fim
 (a) imprime os números de 1 a 100 em ordem decrescente;
 (b) imprime os números pares entre 100 e 1 em ordem crescente;
 (c) imprime os números ímpares entre 1 e 100 em ordem crescente;
 (d) imprime os números entre 1 e 100; 
 (e) imprime os números pares entre 1 e 100 em ordem decrescente.
4) Considerando o trecho de algoritmo a seguir,
k m 0
escrever(“Digite o valor de n: “)
ler(n)
para z de 1 até n faça
 para i de 1 até n faça
 para j de i até n faça 
 k m k + 1
 pode-se afi rmar que o valor de k para qualquer valor de n, ao fi nal da execução será:
 (a) n3 ;
 (b) n2 ;
Algoritmos e programação I.indd 118Algoritmos e programação I.indd 118 7/8/2013 16:01:197/8/2013 16:01:19
Process BlackProcess Black
119
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a (c) n2 + log n; 
 (d) n2(n+1)/2; 
 (e) (n3-n)/3.
5) No fi nal da execução do trecho de algoritmo a seguir,
k m 0
para i de 1 até n faça
 para j de i até n faça 
 k m k + 1
 quanto vale k?
 (a) n3 ;
 (b) (n2–n)/2;
 (c) n(n+1)/2;
 (d) n-1;
 (e) n.
Parte II - Resolução de problemas
 Para cada um dos exercícios a seguir, construa o algoritmo com a solução 
para o problema e realize o teste-de-mesa para assegurar que a resposta esteja 
correta. 
1) Escrever um algoritmo que gere números entre 1000 e 1999 e escreva 
aqueles que divididos por 11 dão resto 5.
2) Foi feita uma pesquisa em 20 cidades brasileiras para coletar dados 
sobre os acidentes de trânsito ocorridos no ano de 2012. Em cada 
cidade, foram obtidos os seguintes dados referentes a 2012: código da 
cidade, número de veículos de passeio, número de acidentes de trânsito 
com vítimas e número de acidentes de trânsito sem vítimas. Deseja-se 
saber:
(a) o total de acidentes de trânsito nas 20 cidades que participaram da 
pesquisa; 
Algoritmos e programação I.indd 119Algoritmos e programação I.indd 119 7/8/2013 16:01:197/8/2013 16:01:19
Process BlackProcess Black
120
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a (b) o maior e o menor número de acidentes de trânsito com vítimas e 
a que cidades pertencem; 
 (c) o percentual de acidentes de trânsito sem vítimas em cada uma das 
20 cidades que participaram da pesquisa; 
 (d) a média de veículos nas 20 cidades juntas.
3) Faça um algoritmo que leia um valor inteiro e positivo, calcule e escreva 
o seu fatorial. 
 Exemplos: !4 = 1 x 2 x 3 x 4 = 24 
 !5 = 1 x 2 x 3 x 4 x 5 = 120 
 Por defi nição, !0 = 1
4) Elabore um algoritmo que leia um valor inteiro, verifi que e informe se 
ele é primo. 
5) Faça um algoritmo para calcular e escrever o valor de R.
 R = 5 x 610 + 
6 x 5
9 + 
5 x 6
8 + 
6 x 5
7 + 
...
... + 
5 x 6
2 + 
6 x 5
1
Respostas dos exercícios da Parte I
 1 - b
 2 - e
 3 - e
 4 - e
 5 - b
Algoritmos e programação I.indd 120Algoritmos e programação I.indd 120 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
10 INTRODUÇÃO À LINGUAGEM C
Vanessa Lindemann
A linguagem C, criada por Dennis Ritchie na década de 70, resultou de um processo 
evolutivo de linguagens e, durante alguns anos, teve seu padrão baseado na versão 
5 do sistema operacional UNIX. Com a popularização dos microcomputadores, 
várias versões de C foram criadas, gerando muitas discrepâncias entre elas. Para 
resolver essa situação, em 1983, o ANSI (American National Standards Institute) 
estabeleceu um comitê para definir um padrão que guiasse todas as implementações 
da linguagem C. 
A popularização da linguagem C deve-se a vários fatores, dentre os quais 
destacam-se: (a) o poderoso conjunto de operadores e tipos de dados disponíveis; 
(b) a portabilidade, podendo ser usada em máquinas de portes e de sistemas 
operacionais diferentes; (c) as características de linguagens de alto nível 
(comandos com sintaxe próxima à linguagem humana e tipos de dados inteiro, 
real e caractere) como, por exemplo, as linguagens Pascal, Delphi e Visual Basic, 
aliadas às características de linguagens de baixo nível (também conhecidas como 
linguagem de máquina, manipulam bits, bytes e endereços) como a linguagem 
Assembler, por exemplo.
C é uma linguagem de propósitos gerais, estruturada e compilada (o compilador 
lê o código-fonte do programa inteiro e converte-o em um código executável). 
Ela é utilizada para a construção de sistemas operacionais (UNIX e LINUX, por 
exemplo), compiladores, interpretadores, editores de textos, planilhas eletrônicas, 
aplicativos para dispositivos móveis, etc. 
Algoritmos e programação I.indd 121Algoritmos e programação I.indd 121 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
122
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Um programa em linguagem C consiste em uma ou mais funções. A função 
principal, denominada main, indica onde o programa inicia. A estrutura básica 
de um programa em C é apresentada a seguir. 
#inlcude <nome da biblioteca>
void main( ) {
 // bloco de comandos
}
Bibliotecas são arquivos contendo várias funções que podem ser incorporadas aos 
programas escritos em C. A diretiva #include faz com que as funções inseridas na 
biblioteca especificada possam ser utilizadas no programa. As bibliotecas stdio.h 
e conio.h permitem a utilização de diversos comandos de entrada e saída e de 
funções de tela, respectivamente. São exemplos de funções de tela, os comandos 
usados para limpar a tela, posicionar o cursor em uma determinada posição na 
tela, trocar a cor da fonte e/ou do fundo. 
Os parênteses ao lado da palavra main indicam que ela é uma função, o tipo void 
indica que ela não retornará nenhum valor, enquanto as chaves delimitam o seu 
início e o seu fim. O bloco de comandos que estiver entre as chaves é executado 
sequencialmente quando a função for chamada. 
É importante salientar que a linguagem C é case sensitive, ou seja, é sensível a letras 
maiúsculas e minúsculas (por exemplo, a é diferente de A) e todos os programas 
devem, obrigatoriamente, ser escritos em letras minúsculas. Outro detalhe 
importante é que cada comando é finalizado com um ponto-e-vírgula. 
As seções a seguir são dedicadas à apresentação de conceitos e definições 
importantes e necessárias para o início da programação em linguagem C. 
10.1 Identificadores
Em linguagem C, os nomes utilizados para referenciar variáveis, constantes e 
funções definidas pelo usuário são chamados de identificadores. 
A criação de um identificador deve seguir as seguintes regras: podem ser formados 
por letras, números e sublinhado; devem iniciar com uma letra; letras minúsculas 
e maiúsculas são consideradas caracteres distintos; não podem ser palavras 
reservadas; podem conter qualquer tamanho, porém apenas os 32 primeiros 
caracteres são significativos. 
Além disso, é importante criar identificadores considerando a sua aplicação 
para facilitar a leitura do código-fonte e, consequentemente, o trabalho do 
programador. A quantidade de horas trabalhadas por uma pessoa durante uma 
Algoritmos e programação I.indd 122Algoritmos e programação I.indd 122 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
123
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
asemana de trabalho pode ser armazenada em uma variável chamada qtde_horas; 
enquanto uma função que irá verificar se uma data é válida ou não pode ter como 
indentificador valida_data.
10.2 Tipos de dados 
Os tipos de dados mais utilizados em linguagem C são: int (número inteiro), 
float (número real) e char (caractere). A linguagem C não possui tipo de dado 
lógico (que pode assumir verdadeiro ou falso), pois considera qualquer valor 
diferente de 0 (zero) como verdadeiro; e também não possui um tipo especial para 
armazenar cadeias de caracteres (string), estas são armazenadas em um vetor de 
caracteres. A Tabela 10.1 apresenta a lista de tipos básicos utilizados em C. 
Tabela 10.1 î Tipos de dados mais utilizados em Linguagem C
Tipo Faixa de valores Tamanho (aproximado)
char -127 a 127 8 bits
int -32.767 a 32.767 16 bits
float 3.4 E-38 a 3.4 E+38 32 bits
double 1.7 E-308 a 1.7 E+308 64 bits
void sem valor 0
A faixa de valores apresentada está de acordo com o padrão ANSI e é considerada 
a faixa mínima. Dependendo do processador e do compilador C que estiver sendo 
utilizado, o tamanho e a faixa de valores podem variar. 
10.3 Modeladores
É possível forçar que o resultado de uma expressão seja de um tipo específico 
usando o conceito de modelador. A forma geral de um modelador é 
(tipo)expressão 
onde tipo é um dos tipos padrão da linguagem C. 
Sendo r uma variável declarada do tipo float, as expressões a seguir resultam 
em valores diferentes. 
r=9/2; // essa expressão resulta 4
r=(float)9/2; // com o uso do modelador, resulta 4.5
Algoritmos e programação I.indd 123Algoritmos e programação I.indd 123 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
124
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 10.4 Declaração, inicialização e escopo de variáveis
Variável é uma posição de memória, identificada por um nome (identificador), 
usada para armazenar um dado de um determinado tipo por vez. As variáveis 
são declaradas após a especificação de seus tipos, como pode ser observado nos 
exemplos a seguir. 
float total;
int idade, cont;
char resposta;
A primeira linha da declaração de variáveis do exemplo cria uma variável chamada 
total, que pode armazenar valores do tipo real; na segunda linha, são
criadas 
duas variáveis para armazenar valores do tipo inteiro, idade e cont; por último, 
resposta é criada para armazenar caracteres (um por vez). Cada variável 
armazenará um único valor por vez. 
As variáveis podem ser inicializadas no momento da sua declaração, colocando o 
sinal de atribuição seguido da informação desejada, como no exemplo apresentado 
a seguir, em que cont é inicializada com 0 e resposta com S. É importante 
destacar que os dados atribuídos a variáveis do tipo caractere são envolvidos por 
apóstrofes. 
int cont=0;
char resposta=’S’;
O local em que as variáveis são declaradas definem o seu escopo, que pode ser 
global ou local. As variáveis de escopo global, denominadas variáveis globais, são 
declaradas fora de qualquer função, inicializadas automaticamente com 0 (zero) 
e podem ser usadas em qualquer ponto do programa. As variáveis locais são 
declaradas dentro de uma função, não são inicializadas automaticamente e valem 
enquanto esta função estiver ativa. As variáveis de escopo local têm preferência 
em relação às de escopo global. 
10.5 Definição de constantes 
Uma constante irá representar um valor fixo, previamente definido pelo 
programador e inalterável no programa. Uma das formas de definir constantes 
em C é através da diretiva #define, seguida do nome da constante e do valor que 
esta representará no programa. No exemplo a seguir, apresenta-se a declaração 
da constante pi cujo valor é definido como 3.141516. Observe que na definição de 
uma constante não se usa o ponto-e-vírgula no final. 
#define pi 3.141516
Desta forma, o programador usará pi no programa ao invés de usar 3.141516. 
Algoritmos e programação I.indd 124Algoritmos e programação I.indd 124 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
125
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a10.6 Códigos de formato 
Os códigos de formato, apresentados na Tabela 10.2, são constantes que definem 
o formato dos dados a serem lidos e exibidos na tela. 
Tabela 10.2 î Códigos de formatação
Código Formato
%c Caractere
%i Inteiro
%l Inteiro longo
%d Inteiro em formato decimal
%ld Decimal longo
%u Decimal sem sinal
%f Ponto flutuante em formato decimal
%lf Ponto flutuante longo (double)
%s Cadeia de caracteres (string)
%e Valor em notação científica
%o Valor em notação octaldecimal
%x Valor em notação hexadecimal
%p Ponteiro
%% Símbolo %
Eles são usados em funções de entrada e de saída de dados (descritas na seção 10.11). 
A função de entrada scanf, por exemplo, possui dois parâmetros: o código de 
formato e uma variável. Neste caso, o valor digitado pelo usuário será armazenado 
na variável denominada peso, declarada e formatada como float. 
scanf(“%f”,&peso);
A função printf, exemplificada a seguir, também contém dois parâmetros: o 
primeiro é uma constante, apresentada entre aspas; o segundo é uma variável, 
denominada dias. O valor armazenado na variável dias será exibido na posição 
em que aparece o código de formato usado na mensagem, neste caso o %i.
printf(“Sua idade em dias e: %i”, dias);
Algoritmos e programação I.indd 125Algoritmos e programação I.indd 125 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
126
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Os códigos de formato podem ter modificadores que especifiquem o tamanho do 
campo, o número de casas decimais e um indicador de justificação à esquerda. 
Especificador de largura mínima do campo: um valor entre o símbolo % e o 
caractere de formato indica a largura mínima do campo, preenchendo a saída com 
brancos (padrão) ou com zeros (coloca-se um 0 antes do especificador de tamanho). 
Quando um valor é maior que o mínimo definido, este será impresso por completo. 
Exemplos: %05d preencherá um número com menos de cinco dígitos com zeros à 
esquerda, de maneira que seu tamanho total seja cinco. 
Especificador do número de casas decimais: para definir o número de casas 
decimais a serem exibidas em um ponto flutuante, usa-se um ponto entre o 
especificador de tamanho e o número de casas decimais desejadas. Por exemplo: 
%6.2f exibirá um valor com, no mínimo, seis dígitos de comprimento e duas 
casas decimais. 
Especificador para justificar informação à esquerda: por definição, toda saída é 
justificada à direita. O uso do sinal – depois do % faz com que a saída seja justificada 
à esquerda. Exemplo: %-6.2f justificará à esquerda um valor de ponto flutuante, 
com no mínimo seis dígitos e duas casas decimais. 
A Tabela 10.3 apresenta exemplos da utilização dos especificadores de tipos. O 
caractere especial \n, usado nos exemplos, é explicado na próxima seção. 
Tabela 10.3 î Exemplo da utilização dos especificadores de tipos
Código Resultado
float valor=136.472;
printf(“\n %f”,valor);
printf(“\n %8.1f”,valor);
printf(“\n %08.1f”,valor);
printf(“\n %-8.1f”,valor);
136.472000
 136.5
000136.5
136.5
int valor=790;
printf(“\n %i”,valor);
printf(“\n %5i”,valor);
printf(“\n %05i”,valor);
printf(“\n %-5i”,valor);
790
 790
00790
790
printf(“\n O valor total é %2d.”,350);
printf(“\n O valor total é %4d.”,350);
printf(“\n O valor total é %5d.”,350);
O valor total é 350.
O valor total é 350.
O valor total é 350.
Algoritmos e programação I.indd 126Algoritmos e programação I.indd 126 7/8/2013 16:01:207/8/2013 16:01:20
Process BlackProcess Black
127
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a10.7 Caracteres especiais 
Os caracteres especiais são usados para representar alguma formatação em 
particular e caracteres especiais que seriam impossíveis de usar diretamente no 
código-fonte. Esses caracteres devem ser precedidos da barra invertida, como 
o \n que representa nova linha. A Tabela 10.4 apresenta os caracteres e seus 
significados. 
Tabela 10.4 î Códigos de caracteres de escape
Código Significado Código Significado
\a alerta (beep) \v tab vertical
\b retrocesso (backspace) \\ exibe barra invertida
\f avanço de página \’ exibe aspa única
\n nova linha \“ exibe aspas duplas
\r retorna ao início da linha \? exibe ponto de interrogação
\t tab horizontal \0 nulo 
10.8 Comando de atribuição 
O comando de atribuição, representado por = (sinal de igualdade), é utilizado para 
atribuir valores a variáveis. É importante lembrar que os valores atribuídos a uma 
variável devem ser compatíveis com o seu tipo. Alguns exemplos de atribuição 
podem ser observados a seguir. 
total=345.60; 
idade=20; 
resp=’s’;
cont=cont+1;
Os caracteres são representados entre apóstrofos ( ‘ ) e as cadeias de caracteres 
entre aspas ( “ ). 
É possível atribuir um valor a duas ou mais variáveis através de um único comando, 
como no exemplo a seguir, em que as variáveis x e y recebem 10.
x=y=10;
Caso seja necessário atribuir uma cadeia de caracteres a uma variável, utiliza-se 
a função strcpy.
strcpy(nome,“Ana Paula Rocha”);
Algoritmos e programação I.indd 127Algoritmos e programação I.indd 127 7/8/2013 16:01:217/8/2013 16:01:21
Process BlackProcess Black
128
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Para utilizar strcpy (abreviação de string copy) é preciso inserir no programa, 
através da diretiva include, a biblioteca string.h.
10.9 Operadores e funções
A linguagem C possui operadores e funções predefinidas destinadas a cálculos 
matemáticos e à manipulação de caracteres. Alguns deles são apresentados nas 
Tabelas 10.5 e 10.6. Para utilizar as funções matemáticas, a biblioteca math.h deve 
ser incluída no programa através da diretiva include. Os operadores lógicos são 
apresentados na Tabela 10.7.
Tabela 10.5 î Operadores aritméticos
Operadores Matemáticos
Operador Exemplo Comentário
+ a + b Soma o conteúdo de a e de b.
- a – b Subtrai o conteúdo
de b do conteúdo de a.
* a * b Multiplica o conteúdo de a pelo conteúdo de b.
/ a / b Divide o conteúdo de a pelo conteúdo de b.
% a % b Obtém o resto da divisão de a por b.*
* O operador % só pode ser utilizado com operandos do tipo inteiro. 
Tabela 10.6 î Operadores relacionais
Operadores Relacionais
Operador Exemplo Comentário
== a == b Testa se o conteúdo de a é igual ao conteúdo de b.
!= a != b Testa se o conteúdo de a é diferente do conteúdo de b.
<= a <= b Testa se o conteúdo de a é menor ou igual que o conteúdo de b.
>= a >= b Testa se o conteúdo de a é maior ou igual que o conteúdo de b.
< a < b Testa se o conteúdo de a é menor que o conteúdo de b.
> a > b Testa se o conteúdo de a é maior que o conteúdo de b.
Algoritmos e programação I.indd 128Algoritmos e programação I.indd 128 7/8/2013 16:01:217/8/2013 16:01:21
Process BlackProcess Black
129
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aTabela 10.7 î Operadores lógicos
Operador Símbolo Descrição
e && Conjunção
ou || Disjunção
não ! Negação
Em C, também pode-se utilizar operadores reduzidos, exemplificados na Tabela 10.8.
Tabela 10.8 î Operadores reduzidos
Expressão Equivalente com operadores reduzidos
total=total+valor; total+=valor;
num=num*5; num*=5;
d=d-valor; d-=valor;
x=x/5; x/=5;
Além dos operadores apresentados anteriormente, a linguagem C disponibiliza 
operadores de pré e pós incremento e decremento, descritos na Tabela 10.9. O 
operador ++ incrementa 1 ao valor do seu operando, enquanto –- decrementa 1. 
Estes operadores podem ser usados antes (pré-fixados) ou depois (pós-fixados) do 
nome da variável. Em ambos os casos a variável é incrementada ou decrementada. 
Entretanto, ++n incrementa o valor da variável n antes que n seja usada e n++ 
usa o valor de n e depois o incrementa. 
Tabela 10.9 î Operadores pré e pós-fixados
Operador Descrição Pré-fixado Pós-fixado
++ Incrementa ++n n++
-- Decrementa --n n--
Algoritmos e programação I.indd 129Algoritmos e programação I.indd 129 7/8/2013 16:01:217/8/2013 16:01:21
Process BlackProcess Black
130
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Resumindo:
++i o incrementa o valor de i em 1 e depois o utiliza; 
i++ o utiliza o valor de i e depois incrementa-o em 1. 
Logo, conclui-se que: 
z=a; a=a+1; é equivalente a z=a++; 
z=a; a=a-1; é equivalente a z=a--;
a=a+1; z=a; é equivalente a z=++a; 
a=a-1; z=a; é equivalente a z=--a; 
10.10 Comentários
Os comentários são textos que podem ser inseridos no programa com o objetivo de 
documentá-lo e não são analisados pelo compilador. Os comentários de uma linha 
são precedidos do símbolo //, enquanto o comentário de várias linhas é envolvido 
por /* e */, conforme pode ser observado nos exemplos a seguir. 
// Este é um comentário de uma linha.
/* Este é um comentário
 de mais de uma linha. */
10.11 Funções de entrada e saída
As funções de entrada de dados são utilizadas para receber dados digitados pelo 
usuário. Os dados recebidos são armazenados em variáveis já declaradas no início 
do programa. As funções de entrada mais utilizados em C são scanf, fgets 
e getche.
A função scanf é utilizada para ler dados dos tipos numérico e caractere, enquanto 
a função fgets é utilizada para ler uma cadeia de caracteres e a função getche 
pode ser utilizada para ler um caractere por vez. 
O trecho de código a seguir apresenta um exemplo da utilização das funções scanf 
e getche. Os dois valores do tipo float são lidos com a função scanf (linhas 2 
e 6) e o dado do tipo caractere é lido com getche (linha 4). 
1 printf(“Digite o primeiro valor: “); 
2 scanf(“%f”,&valor1); 
3 printf(“Digite o operador: “); 
4 operador = getche(); 
5 printf(“Digite o segundo valor: “); 
6 scanf(“%f”,&valor2); 
Algoritmos e programação I.indd 130Algoritmos e programação I.indd 130 7/8/2013 16:01:217/8/2013 16:01:21
Process BlackProcess Black
131
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aA sintaxe das duas funções é diferente. A função scanf tem dois parâmetros: o 
primeiro indica o tipo do dado a ser lido (Tabela 10.2 – códigos de formatação), 
especificado por uma letra depois do símbolo % entre as aspas; e o nome da 
variável, antecedido do símbolo & (sem espaço) que referencia um endereço de 
memória. A função getche lê um caractere pressionado no teclado pelo usuário 
e o escreve na tela. Na linha 4, a variável operador recebe o valor lido através da 
função getche. 
Um exemplo da utilização da função fgets pode ser observado nas linhas de 
código apresentadas a seguir. A função fgets possui três parâmetros – o nome 
da variável, o tamanho máximo da variável e a entrada de dados padrão (stdin 
= standard input) – e antes de utilizá-la é preciso liberar o buffer do dispositivo de 
entrada de dados, o que é feito através da função fflush.
1 printf(“Nome do aluno...: “);
2 fflush(stdin); 
3 fgets(nome,60,stdin); 
A função de saída é utilizada para apresentar dados na tela, seja uma mensagem, o 
resultado de uma expressão ou o conteúdo armazenado em uma variável. A função 
de saída mais utilizada em C é o printf, que pode ser observado nos dois trechos 
de códigos apresentados anteriormente e na linha de código a seguir. 
 printf(“Sua idade em dias e: %i”, dias);
 Nesse exemplo, o comando printf tem dois parâmetros: a mensagem e a variável. 
O valor armazenado na variável dias será apresentado na tela no lugar em que 
está o %i na mensagem (o %i é a formatação do dado a ser exibido, que neste caso 
é um inteiro). 
10.12 Estruturas de controle condicional 
A seguir, são apresentados dois exemplos que utilizam estruturas de controle 
condicional - o exemplo 10.1 exemplifica a aplicação da estrutura SE (em C, if) e 
o exemplo 10.2 da estrutura ESCOLHA (em C, switch). Na coluna da esquerda 
dos Quadros 10.1 e 10.2, aparece a solução em português estruturado, enquanto a 
coluna da direita apresenta a mesma solução em linguagem C. 
Algoritmos e programação I.indd 131Algoritmos e programação I.indd 131 7/8/2013 16:01:217/8/2013 16:01:21
Process BlackProcess Black
132
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
 
Qu
ad
ro
 1
0.
1 
î E
xe
m
pl
o d
a 
es
tru
tu
ra
 d
e c
on
tro
le
 co
nd
ic
io
na
l S
E
Ex
em
pl
o 
10
.1
 - 
Le
r u
m
 v
al
or
 d
o 
tip
o 
in
te
ir
o 
e 
ve
ri
fi
ca
r s
e 
el
e 
é 
pa
r o
u 
ím
pa
r.
Po
rt
ug
uê
s 
es
tr
ut
ur
ad
o 
– 
SE
 
Li
ng
ua
ge
m
 C
 - 
if
al
go
ri
tm
o 
ex
em
pl
o1
01
va
ri
áv
ei
s 
 
 v
al
or
: 
in
te
ir
o
in
íc
io
 
 
es
cr
ev
er
("
Di
gi
te
 u
m 
va
lo
r:
 "
)
 
le
r(
va
lo
r)
 
se
(v
al
or
 m
od
 2
 =
 0
)e
nt
ão
 
 
es
cr
ev
er
(v
al
or
,"
 é
 p
ar
."
)
 
se
nã
o
 
 
es
cr
ev
er
(v
al
or
,"
 é
 í
mp
ar
."
)
fi
m 
 
#i
nc
lu
de
 <
st
di
o.
h>
 
 
 
 
//
bi
bl
io
te
ca
s
#i
nc
lu
de
 <
co
ni
o.
h>
vo
id
 m
ai
n(
) 
{ 
 
 
 
 
 
 
 
 
 
 
in
t 
va
lo
r;
cl
rs
cr
()
; 
 
 
 
 
 /
/l
im
pa
 a
 t
el
a
go
to
xy
(1
0,
10
);
 
 
 /
/p
os
ic
io
na
 o
 c
ur
so
r 
pr
in
tf
("
Di
gi
te
 u
m 
va
lo
r:
 "
);
 
 
sc
an
f(
"%
i"
,&
va
lo
r)
;
go
to
xy
(1
0,
14
);
 
 
 
if
(v
al
or
%2
==
0)
 
 
pr
in
tf
("
%i
 é
 p
ar
."
, 
va
lo
r)
;
 
el
se
 
 
 
 
 
pr
in
tf
("
%i
 é
 í
mp
ar
."
, 
va
lo
r)
;
 
ge
tc
h(
);
 
 
 
 
 
 
//
pa
us
a 
 
 
 
 
 
 
 
 
 
 
 
}
Algoritmos e programação I.indd 132Algoritmos e programação I.indd 132 7/8/2013 16:01:227/8/2013 16:01:22
Process BlackProcess Black
133
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 10.2 î Exemplo da estrutura de controle condicional ESCOLHA
Exemplo 10.2 - Construir uma calculadora que contenha as operações: +, - , * e /.
Português estruturado - ESCOLHA Linguagem C - switch
algoritmo exemplo102
variáveis
 valor1,valor2,r: real 
 operador: caractere
início
 escrever("Digite o 1º valor: ")
 ler(valor1)
 escrever("Digite o operador: ")
 ler(operador)
 escrever("Digite o 2º valor: ")
 ler(valor2)
 escolha(operador)
 caso "+": r m valor1 + valor2
 caso "-": r m valor1 - valor2
 caso "*": r m valor1 * valor2
 caso "/": se(valor2<>0)então
 r m valor1/valor2
 senão 
 r m 0 
 senão 
 
 escrever("Operador inválido!") 
 
 fim
 escrever ("Resultado = ", r)
fim 
#include <stdio.h> //bibliotecas
#include <conio.h>
void main(){
 float valor1,valor2, r;
 char operador;
 clrscr(); //limpa a tela
 gotoxy(10,5); //posiciona o cursor 
 printf("Digite o primeiro valor: "); 
 scanf("%f",&valor1); 
 gotoxy(10,8); 
 printf("Digite o operador: "); 
 operador = getche(); 
 gotoxy(10,11); 
 printf("Digite o segundo valor: "); 
 scanf("%f",&valor2); 
 switch(operador){ 
 case'+': r = valor1 + valor2; break;
 case'-': r = valor1 - valor2; break;
 case'*': r = valor1 * valor2; break;
 case'/': if(valor2!=0)
 r = valor1 / valor2;
 else
 r = 0;
 break;
 else{
 gotoxy(10,20);
 printf("Operador inválido!");
 }
 }
 gotoxy(10,24);
 printf("Resultado = %3.2f", r);
 getch(); //pausa
}
10.13 Estruturas de controle de repetição 
As estruturas de controle de repetição são exemplificadas nos quadros a seguir. 
Para facilitar o entendimento, a coluna da esquerda dos Quadros 10.3, 10.4 e 10.5 
apresenta a solução em português estruturado e a da direita em linguagem C. 
Algoritmos e programação I.indd 133Algoritmos e programação I.indd 133 7/8/2013 16:01:227/8/2013 16:01:22
Process BlackProcess Black
134
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 10.3 î Exemplo da estrutura de controle de repetição ENQUANTO
Exemplo 10.3 - Ler 10 valores do tipo inteiro, calcular e escrever a média dos valores 
lidos.
Português estruturado – ENQUANTO Linguagem C – while 
algoritmo exemplo103
variáveis 
 valor,soma,cont: inteiro
 media: real 
início 
 cont ĸ 0
 soma ĸ 0
 enquanto(cont<10)faça
 início 
 
 escrever("Digite um 
valor: ")
 ler(valor)
 cont ĸ cont + 1
 soma ĸ soma + valor
 fim
 media ĸ soma / 10
 escrever("Média = ", media)
fim 
#include <stdio.h> //bibliotecas
#include <conio.h>
void main() { 
 int valor, soma, cont;
 float media;
 cont = 0;
 soma = 0;
 while(cont<10)
 {
clrscr(); //limpa a tela
gotoxy(10,10); //posiciona cursor
printf("Digite um valor: "); 
scanf("%i",&valor); 
cont = cont + 1;
soma = soma + valor;
}
media = soma / 10;
gotoxy(10,14); 
printf("Media = %.2f", media); 
getch(); //pausa 
}
Algoritmos e programação I.indd 134Algoritmos e programação I.indd 134 7/8/2013 16:01:227/8/2013 16:01:22
Process BlackProcess Black
135
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aQuadro 10.4 î Exemplo da estrutura de controle de repetição REPITA
Exemplo 10.4 - Ler 25 valores, calcular e escrever o percentual de valores negativos.
Português estruturado – REPITA Linguagem C – do while 
algoritmo exemplo104
variáveis 
 cont: inteiro
 valor, negativo, perc: real 
início 
 cont m 0
 negativo m 0
 repita 
 
 
 escrever("Digite um valor: ")
 ler(valor)
 cont m cont + 1
 se (valor < 0) então
 negativo m negativo + 1
 até(cont=25)
 perc m (negativo*100)/25
 escrever("% negativos = ",perc)
fim
#include <stdio.h> //bibliotecas
#include <conio.h>
void main() { 
 int cont;
 float valor, negativo, perc;
 cont = 0;
 negativo = 0;
 do{
clrscr(); 
gotoxy(10,10); 
printf("Digite um valor: "); 
scanf("%f",&valor); 
cont = cont + 1;
if(valor < 0)
 negativo = negativo + 1;
} while(cont<25);
perc = (negativo*100)/25;
gotoxy(10,14); 
printf("%% de negativos = %.2f", perc); 
 getch(); //pausa 
}
Algoritmos e programação I.indd 135Algoritmos e programação I.indd 135 7/8/2013 16:01:227/8/2013 16:01:22
Process BlackProcess Black
136
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a Quadro 10.5 î Exemplo da estrutura de controle de repetição PARA
Exemplo 10.5 - Ler 10 valores do tipo inteiro, calcular e escrever a média dos valores lidos.
Português estruturado – PARA Linguagem C – for
algoritmo exemplo105
variáveis 
 valor,soma,cont: inteiro
 media: real 
início 
 soma ĸ 0
 para cont de 1 até 10 faça
 início 
 
 escrever("Digite um valor: ")
 ler(valor)
 soma ĸ soma + valor
 fim
 media ĸ soma / 10
 escrever("Média = ", media)
fim 
#include <stdio.h> //bibliotecas
#include <conio.h>
void main() { 
 int valor, soma, cont;
 float media;
 soma = 0;
 for(cont=1;cont<=10;cont++)
 {
 clrscr(); //limpa a tela
 gotoxy(10,10);//posiciona cursor
 printf("Digite o %i valor: ",cont); 
 scanf("%i",&valor); 
 soma = soma + valor;
 }
 media = soma / 10;
 gotoxy(10,14); 
 printf("Media = %.2f", media); 
 getch(); //pausa 
}
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: 
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do 
Brasil, 2012. 
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005. 
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MATTOS, Patrícia Noll de. Linguagem de Programação II (Caderno Universitário 027). 2.ed. 
Canoas: Ed. ULBRA, 2001.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
SCHILDT, Herbert. C Completo e Total. 3. ed. São Paulo: Makron Books, 1997.
Algoritmos e programação I.indd 136Algoritmos e programação I.indd 136 7/8/2013 16:01:227/8/2013 16:01:22
Process BlackProcess Black
137
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aAtividades 
Parte I - Questões objetivas 
1) A sintaxe das declarações de variáveis em C inclui o nome da variável seguido 
de um tipo.
( ) Certo 
( ) Errado 
2) São nomes válidos para variáveis na linguagem C:
(a) if, a*b_2, H789, &ya;
(b) A, b, Y, count;
(c) 9xy, a36, x*y, --j;
(d) 2_ou_1, \fi m, h, j; 
(e) i, j, int, obs.
3) Em C, os nomes cont e Cont não podem ser empregados
para representar a 
mesma variável ao longo de um programa.
( ) Certo 
( ) Errado 
4) Uma string é uma sequência de caracteres armazenada em um vetor de 
caracteres.
( ) Certo 
( ) Errado 
Algoritmos e programação I.indd 137Algoritmos e programação I.indd 137 7/8/2013 16:01:227/8/2013 16:01:22
Process BlackProcess Black
138
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 5) O que faz o seguinte programa em C ? 
#include <stdio.h> 
void main( ){ 
 int i =2; 
 printf (“O valor de i = %i \n”, i); 
}
(a) Imprime: O valor de i = 2 e pula para a próxima linha;
(b) Imprime: O valor de i = 2 \n;
(c) Pula para a próxima linha e imprime: O valor de i = 2 ;
(d) Imprime: O valor de i = 2 ;
(e) Nenhuma das alternativas anteriores.
6) Qual o resultado das variáveis j, k e l depois da seguinte sequência de 
operações?
int j,k,l; j=k=10; l=++j; j=-j; k++; j=j+k-l--; 
(a) j = -10, k = 10, l = 10; 
(b) j = -11, k = 11, l = 10; 
(c) j = -10, k = 11, l = 10; 
(d) j = 11, k= 11, l = 11; 
(e) Nenhuma das alternativas anteriores.
7) if(var) é equivalente a if(var!=0).
( ) Certo 
( ) Errado 
Algoritmos e programação I.indd 138Algoritmos e programação I.indd 138 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black
139
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a8) Considerando o conceito de variáveis em Linguagem C, leia as afi rmações a 
seguir e indique a afi rmativa correta.
I. As variáveis de um programa em C estão associadas a posições de 
memória, previamente identifi cadas, que armazenam informações
II. O primeiro caractere de um identifi cador deve ser uma letra e o 
restante do nome pode conter letras, números e sublinhado. Além 
disto, palavras-chaves não podem ser usadas como identifi cadores.
III. As variáveis são classifi cadas, quanto ao seu escopo, como globais 
ou locais. As globais são declaradas fora de qualquer função e são 
reconhecidas em todo o programa; as locais são declaradas dentro da 
função em que serão utilizadas e valem enquanto esta estiver ativa.
IV. O tipo de uma variável defi ne os valores que ela pode assumir e as 
operações que podem ser realizadas com ela.
V. A linguagem C não faz distinção entre as variáveis Cont, cont e 
CONT. 
 (a) II e III estão incorretas.
 (b) I, II e IV estão corretas. 
 (c) V está incorreta.
 (d) I, II e III estão corretas.
 (e) Todas estão corretas.
9) Na Linguagem C, os códigos de formação de tipo de dados NÃO estão 
corretamente associados na alternativa:
(a) int - %i;
(b) double - %d;
(c) fl oat - %f;
(d) char - %c;
(e) Nenhuma das respostas anteriores.
Algoritmos e programação I.indd 139Algoritmos e programação I.indd 139 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black
140
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a 10) Na expressão condicional A>=P||P>A , está correto afi rmar que a mesma
(a) nunca será verdadeira. 
(b) somente será verdadeira quando P for menor ou igual a A.
(c) somente será verdadeira quando P for maior que A. 
(d) nunca será falsa.
(e) Nenhuma das respostas anteriores.
11) Considerando os especifi cadores de tipo usados nos comandos de saída 
apresentados a seguir, assinale a alternativa INCORRETA.
(a) printf(“Total = %05i”,794);
T o t a l = 0 0 7 9 4
(b) printf(“Total = %-5i”,469);
T o t a l = 4 6 9
(c) printf(“Total = %.2f”,280.338);
T o t a l = 2 8 0 . 3 4
(d) printf(“Total = %4i”,258);
T o t a l = 2 5 8
(e) printf(“Total = %4.2f”,587.222);
T o t a l = 5 8 7 . 2 2
12) Para que faixa de valores da variável x o seguinte segmento de código imprime 
a letra C? (Questão da prova do POSCOMP 2003)
if(x<=200)
 if(x<100)
 if(x<0) printf(“A”)
 else printf(“B”)
 else printf(“C”)
 else printf(“D”)
(a) 0<x<100;
(b) x<=100; 
(c) 100<x<=200;
(d) x>200;
(e) 100<=x<=200.
Algoritmos e programação I.indd 140Algoritmos e programação I.indd 140 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black
141
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
aParte II - Resolução de problemas
Escolha um exercício de cada um dos capítulos anteriores e reescreva sua solução 
em Linguagem C (utilize um compilador de Linguagem C para executar os 
programas resolvidos).
Respostas dos exercícios da Parte I
 1 - Errado
 2 - b
 3 - Certo
 4 - Certo
 5 - a
 6 - b
 7 - Certo
 8 - c
 9 - b
 10 - d
 11 - d
 12 - e
Algoritmos e programação I.indd 141Algoritmos e programação I.indd 141 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black
142
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
Algoritmos e programação I.indd 142Algoritmos e programação I.indd 142 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black
143
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
Algoritmos e programação I.indd 143Algoritmos e programação I.indd 143 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black
144
UL
BR
A 
– E
du
ca
çã
o a
 D
ist
ân
ci
a
Algoritmos e programação I.indd 144Algoritmos e programação I.indd 144 7/8/2013 16:01:237/8/2013 16:01:23
Process BlackProcess Black