Linguagem e Tecnicas de Programação

Prévia do material em texto

Linguagem e 
Técnicas de Programação
U416. 78
 
 
Autor: Prof. Olavo Ito
Colaboradores: Prof. Luciano Soares de Souza
 Prof. Marcelo Nogueira
Linguagem e 
Técnicas de Programação
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Professor conteudista: Olavo Ito
Mestre em Engenharia de Produção pela UNIP, bacharel em Física pelo Instituto de Física da USP, licenciado em 
Ciências pela Faculdade de Educação da USP e bacharel em Língua e Literatura Japonesa pela FFLCH-USP.
Os primeiros passos do autor no mundo da programação de computadores foram dados com calculadoras 
programáveis HP25C e Sharp Pocket Computer. Nessa mesma época, aprendeu lógica de programação, perfurando 
cartões para praticar seus conhecimentos em computador de grande porte (Burroughs B6700).
Possui experiência com linguagem Fortran e teve contato com um dos dois únicos computadores IBM 360 
remanescentes no mundo, na época, pertencente ao laboratório do acelerador de partículas Pelletron. Também teve 
a oportunidade de trabalhar com um Itautec I-7000, que tinha tanto poder de processamento quanto o gigantesco 
IBM360 e permitia o uso de outras linguagens de programação além de Fortran: Basic, xBase, C, Pascal, Algol, COBOL 
e muitas outras.
A experiência com programação levou-o a sair da vida acadêmica para trabalhar na iniciativa privada, mas 
sem deixar de lado o compromisso com o ensino. Trabalhou em banco, consulado, holdings, indústria e comércio, 
especializando-se em implantação de Enterprise Resource Planning (ERP) – Sistemas de Gestão Empresarial.
Professor dos cursos de graduação tradicional de Sistemas de Informação e Ciência da Computação, bem como 
do curso superior tecnológico de Análise e Desenvolvimento de Sistemas. Das disciplinas que ministra, Linguagem e 
Técnicas de Programação é especial, pois engloba dois assuntos que tem especial prazer em lecionar: Algoritmos e 
Estrutura de Dados.
© Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer forma e/ou 
quaisquer meios (eletrônico, incluindo fotocópia e gravação) ou arquivada em qualquer sistema ou banco de dados sem 
permissão escrita da Universidade Paulista.
Dados Internacionais de Catalogação na Publicação (CIP)
 I96L Ivo, Olavo.
Linguagens e técnicas de programação. / Olavo Ivo. – São Paulo, 
2014.
568 p., il.
Nota: este volume está publicado nos Cadernos de Estudos e 
Pesquisas da UNIP, Série Didática, ano XIX, n. 2-082/14, ISSN 1517-9230.
1. Técnicas de programação. 2. Estrutura de dados. 3. Estrutura 
unidimensional. I. Título.
CDU 681.3.02
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Prof. Dr. João Carlos Di Genio
Reitor
Prof. Fábio Romeu de Carvalho
Vice-Reitor de Planejamento, Administração e Finanças
Profa. Melânia Dalla Torre
Vice-Reitora de Unidades Universitárias
Prof. Dr. Yugo Okida
Vice-Reitor de Pós-Graduação e Pesquisa
Profa. Dra. Marília Ancona-Lopez
Vice-Reitora de Graduação
Unip Interativa – EaD
Profa. Elisabete Brihy 
Prof. Marcelo Souza
Prof. Dr. Luiz Felipe Scabar
Prof. Ivan Daliberto Frugoli
 Material Didático – EaD
 Comissão editorial: 
 Dra. Angélica L. Carlini (UNIP)
 Dra. Divane Alves da Silva (UNIP)
 Dr. Ivan Dias da Motta (CESUMAR)
 Dra. Kátia Mosorov Alonso (UFMT)
 Dra. Valéria de Carvalho (UNIP)
 Apoio:
 Profa. Cláudia Regina Baptista – EaD
 Profa. Betisa Malaman – Comissão de Qualificação e Avaliação de Cursos
 Projeto gráfico:
 Prof. Alexandre Ponzetto
 Revisão:
 Juliana Maria Mendes
 Amanda Casale
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Sumário
Linguagem e Técnicas de Programação
APRESENTAçãO ......................................................................................................................................................9
INTRODUçãO ........................................................................................................................................................ 10
Unidade I
1 ALGORITMOS ..................................................................................................................................................... 13
1.1 Conceitos básicos ................................................................................................................................. 13
1.2 Programas................................................................................................................................................ 14
1.3 Lógica de programação...................................................................................................................... 14
1.4 Representação lógica .......................................................................................................................... 15
1.5 Tipos de algoritmos ............................................................................................................................. 15
1.5.1 Descrição narrativa ................................................................................................................................ 15
1.5.2 Fluxograma ................................................................................................................................................ 16
1.5.3 Pseudocódigo ou Portugol .................................................................................................................. 17
1.6 Regras para construção do algoritmo ......................................................................................... 18
1.7 Introdução à programação ............................................................................................................... 20
1.7.1 Tipos de informações, entrada e saída ........................................................................................... 20
1.7.2 Dados ........................................................................................................................................................... 21
1.7.3 Tipos de dados .......................................................................................................................................... 21
1.8 Programação sequencial ................................................................................................................... 33
1.8.1 Estrutura sequencial .............................................................................................................................. 34
1.9 Estrutura de um pseudocódigo ...................................................................................................... 34
1.10 Entrada e saída de informações ................................................................................................... 37
1.10.1 Instrução primitiva de saída de dados ......................................................................................... 37
1.10.2 Instrução primitiva de entrada de dados ................................................................................... 39
1.10.3 Teste de mesa ......................................................................................................................................... 41
Unidade II
2 INTRODUçãO à LINGUAGEM C ................................................................................................................. 59
2.1 Histórico ................................................................................................................................................... 60
2.2 Regras da linguagem ..........................................................................................................................60
2.2.1 Estrutura de um programa em C ...................................................................................................... 63
2.3 Tipos de informações, variáveis e constantes ........................................................................... 64
2.4 Operadores .............................................................................................................................................. 68
2.5 Entrada e saída de informações ..................................................................................................... 72
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
3 TOMADA DE DECISõES.................................................................................................................................. 86
3.1 Teoria ......................................................................................................................................................... 86
3.2 Condicionais ........................................................................................................................................... 86
3.2.1 Se então ...................................................................................................................................................... 86
3.2.2 Se então senão......................................................................................................................................... 94
3.2.3 Estrutura condicional se aninhada ................................................................................................102
3.2.4 Escolha-caso ...........................................................................................................................................131
3.3 Laboratório ............................................................................................................................................160
3.3.1 Escolha-caso na linguagem C++ .................................................................................................. 167
Unidade IV
4 LAçOS DE REPETIçãO ..................................................................................................................................184
4.1 Teoria .......................................................................................................................................................184
4.1.1 Laços condicionais ............................................................................................................................... 184
4.1.2 Laços contados ..................................................................................................................................... 229
4.2 Laboratório ............................................................................................................................................248
4.2.1 Repita até que ....................................................................................................................................... 248
4.2.2 Enquanto faça ....................................................................................................................................... 250
4.2.3 Para até que ........................................................................................................................................... 252
Unidade V
5 ESTRUTURA DE DADOS ...............................................................................................................................269
5.1 Dados homogêneos ...........................................................................................................................269
5.1.1 Vetores, strings e matrizes ............................................................................................................... 269
5.1.2 Vetores em C .......................................................................................................................................... 294
5.1.3 Matrizes ................................................................................................................................................... 296
5.1.4 Matrizes em C ....................................................................................................................................... 297
5.1.5 Cadeias de caracteres em C ............................................................................................................. 298
5.1.6 Caracteres em C .................................................................................................................................... 299
5.1.7 Manipulação de strings ..................................................................................................................... 300
5.2 Dados heterogêneos..........................................................................................................................305
5.2.1 Estrutura em C .......................................................................................................................................307
5.2.2 Tipo união ............................................................................................................................................... 308
5.3 Modularização .....................................................................................................................................308
5.3.1 Teoria ........................................................................................................................................................ 309
5.3.2 Funções e procedimentos ..................................................................................................................310
5.3.3 Funções e procedimentos em C ......................................................................................................351
5.3.4 Variáveis locais e variáveis globais ............................................................................................... 353
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade VI
6 ALOCAçãO DINâMICA DA MEMóRIA ...................................................................................................392
6.1 O uso da memória ..............................................................................................................................392
6.2 Ponteiro de variáveis .........................................................................................................................396
6.3 Passagem de valores por valor e por referência ....................................................................400
6.4 Passagem de vetores para funções .............................................................................................413
6.5 Funções da biblioteca-padrão .......................................................................................................414
6.6 Recursividade .......................................................................................................................................419
Unidade VII
7 ESTRUTURA UNIDIMENSIONAL, LISTAS ...............................................................................................436
7.1 Listas ligadas ........................................................................................................................................437
7.1.1 Função de inicialização ..................................................................................................................... 439
7.1.2 Função de inserção ............................................................................................................................. 440
7.1.3 Função de remoção .............................................................................................................................450
7.1.4 Função de busca, função de impressão e função de liberação de memória ................461
7.2 Pilhas .......................................................................................................................................................464
7.2.1 Implementação de pilha com lista – representação encadeada ...................................... 465
7.2.2 Criação da pilha com lista ................................................................................................................ 466
7.2.3 Inserção na pilha com lista .............................................................................................................. 468
7.2.4 Remoção da pilha ................................................................................................................................ 473
7.2.5 Função de impressão e função de liberação de memória ................................................... 480
7.3 Filas ..........................................................................................................................................................483
7.3.1 Implementação de fila com lista – representação encadeada .......................................... 484
7.3.2 Criação da fila com lista ................................................................................................................... 485
7.3.3 Inserção na pilha com lista .............................................................................................................. 486
7.3.4 Remoção de nó da fila ....................................................................................................................... 495
7.3.5 Função de impressão e função de liberação de memória ................................................... 498
Unidade VIII
8 ÁRVORES ..........................................................................................................................................................507
8.1 Árvores binárias ...................................................................................................................................508
8.2 Percurso em árvores binárias .........................................................................................................509
8.2.1 Percurso em pré-ordem ou prefixo (busca em profundidade) .......................................... 509
8.2.2 Percurso em ordem ou infixo (ordem simétrica)......................................................................517
8.2.3 Percurso em pós-ordem ou posfixo ..............................................................................................521
8.3 Árvores binárias de busca ...............................................................................................................526
8.3.1 Operação de busca .............................................................................................................................. 528
8.3.2 Operação de inserção ......................................................................................................................... 529
8.3.3 Operação de remoção ........................................................................................................................ 530
8.3.4 Remoção de folha ................................................................................................................................531
8.4 Estrutura de árvores binárias em C .............................................................................................534
9
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
APresenTAçãO
A disciplina de Linguagem e Técnicas de Programação tem duas partes. A primeira será de 
estudo da técnica de programação de computadores, a chamada programação estruturada. Nela 
veremos os comandos básicos que qualquer das linguagens de programação deve ter, bem como 
usaremos o raciocínio lógico para fazer o computador executar aquilo que queremos.
Inicialmente, apresentaremos a teoria, ou seja, o desenvolvimento da lógica da programação 
utilizando o chamado pseudocódigo, numa linguagem em português cuja principal função é 
montar a lógica do programa e testar manualmente o funcionamento deste. A seguir, abordaremos 
a tradução para uma linguagem de programação, que, no nosso caso, será a linguagem C++, 
quando efetivamente será possível fazer o computador perder sua característica de “irracional” 
e executar aquilo que foi programado para fazer. A Unidade I é específica para apresentar a 
lógica de programação, e a Unidade II é específica para fazer a introdução à linguagem C. Nas 
Unidades III e IV, é apresentado o controle do fluxo dos programas. Em cada uma delas será feita 
uma apresentação teórica e, no final de cada uma, a passagem da teoria para a linguagem de 
programação.
Uma vez entendida a programação básica, passaremos à análise das estruturas clássicas de 
programação. Serão apresentados programas básicos, simplificados ao máximo, porém com um alto grau 
de sofisticação. Esses programas serão desenvolvidos utilizando apenas a linguagem C++. Na Unidade 
V, será feita a transição da programação sequencial simples para a programação modular, bem como a 
apresentação de estruturas mas sofisticadas de armazenamento na memória. Com isso, será necessário 
conhecer o processo de gerenciamento da memória; assim, na Unidade VI, a linguagem C, por ser muito 
próxima à linguagem de máquina, sem perder a facilidade de entendimento da lógica, passará a ser a 
ferramenta principal para o restante do curso.
Utilizando a linguagem C e usando um modelo fictício, porém didático, de um mapeamento da 
memória de um computador, estudaremos nas Unidades VII e VIII os principais modelos de estruturas de 
dados: lista ligada, pilha, fila e árvores.
É importante observar que este não é um “curso de linguagem C”, a qual será apenas um exemplo 
de linguagem de programação que o computador entende. A intenção é desenvolver a lógica de 
programação no chamado pseudocódigo, a fim de, posteriormente, traduzi-lo para qualquer linguagem 
de programação.
Existem programadores que escrevem diretamente em uma linguagem de programação, sem usar o 
pseudocódigo. Isso é um risco muito grande, pois a história mostra que sempre existiu uma linguagem 
popular que, depois, foi abandonada e substituída por outra. Aconteceu isso com diversas linguagens, 
como COBOL, FORTRAN, Pascal, Basic, a família xBase (Dbase, Clipper) e muitas outras, e nada indica 
que as novas linguagens deixarão de ser desenvolvidas. O uso preliminar do pseudocódigo permite que 
o foco seja a lógica, e não a linguagem. Outro problema comum em programar diretamente em uma 
linguagem de programação é a perda da linha de raciocínio. As linguagens de programação são muito 
sensíveis à sintaxe e à correta escrita de seus comandos. Um erro de sintaxe sempre causa uma falha, 
10
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
impedindo o funcionamento do programa. Assim, ocorrerá uma interrupção do raciocínio lógico do 
programador. Um pseudocódigo nunca apresentará erro de sintaxe.
O importante é o programador ter uma sólida base de lógica de programação, e não ser um 
especialista em uma linguagem de programação.
 saiba mais
Todos os programas apresentados neste livro-texto foram testados no 
Microsoft Visual C++ 2010 Express, que pode ser instalado gratuitamente. 
O download pode ser efetuado no site:
MICROSOFT VISUAL STUDIO. Downloads do Visual Studio. s.l., 2014. 
Disponível em: <http://www.visualstudio.com/downloads/download-
visual-studio-vs>. Acesso em: 14 abr. 2014.
Em caso de mudança no link, os programas poderão ser procurados 
navegando pelo site: <http://www.visualstudio.com>. Alémdo Visual 
C++, os programas foram testados no Borland Turbo C++. Não 
recomendamos outras versões, pois, além de os programas não terem sido 
testados, podem acontecer diferenças no processo de gerenciamento da 
memória.
InTrOduçãO
O computador é totalmente irracional, incapaz de executar qualquer tarefa se não houver algo 
ou alguém que o instrua quanto aos passos para efetuá-la. Ao mesmo tempo, é extremamente fiel: 
a máquina obedecerá às suas ordens exatamente da maneira que foram expressas. Por um lado, essa 
obediência é muito louvável, mas, por outro, isso significa que uma ordem maldada será executada 
fielmente, da maneira que foi instruído.
Um outro problema é o fato de o computador entender poucas palavras, significando que existe a 
possibilidade de uma ordem nossa não estar no vocabulário dele, portanto devemos ensinar-lhe novas 
palavras. Essa falta de vocabulário, a princípio, pode parecer um problema sério, porém é uma vantagem, 
pois, apesar da necessidade de um texto maior, evita a dupla interpretação.
Com o vocabulário limitado é necessário fazer programas que tornem amigável a experiência de uma 
pessoa leiga ao utilizar o computador. Nossa função ao fazer este curso é montar programas, sistemas 
que permitam ao usuário leigo a possibilidade de trabalhar com o computador sem a necessidade de 
conhecer os detalhes da máquina. Apresentar soluções computacionais sem uma intervenção nossa 
(especialistas).
11
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Quem usa uma planilha eletrônica não precisa saber computação, mas “alguém” teve de programar 
para que a planilha fosse funcional. Quem se diverte em um jogo eletrônico não precisa saber dos 
detalhes da programação do computador, mas “alguém” teve de dar aos elementos do jogo instruções 
para o comportamento durante a partida. Quem usa um celular não precisa saber que existe uma 
conversa digital entre o aparelho e a operadora antes de uma ligação se completar, pois “alguém” deixou 
montado um processo que permite ao aparelho tomar uma série de decisões antes de ligar ou recusar 
uma conexão. Num mundo cada vez mais digital, existem vários programas que ficam executando 
instruções que diminuem as operações manuais, os chamados programas embarcados, e alguém os 
automatizou, por meio da programação de computador; todos esses profissionais, no mínimo, devem 
conhecer a lógica de programação. Dessa forma, este curso apresenta o conhecimento mínimo para o 
desenvolvimento de pequenos programas até grandes sistemas empresariais.
13
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Unidade I
Vamos pensar nas ações que praticamos em nossa rotina matinal: o despertador toca, tiramos a 
coberta, levantamos, procuramos o chinelo debaixo da cama, escovamos os dentes, e assim por diante. 
Vamos nos concentrar no ato de escovar os dentes. Mesmo sem pensar em nada, exceto por algumas 
variações, agimos pegando o tubo do dentifrício, abrindo a tampa, depois pegamos a escova de dente, 
damos uma molhadinha nas cerdas, colocamos um pouco da pasta de dentes nela, escovamos os dentes, 
abrimos a torneira da pia, enxaguamos a boca, limpamos a escova, fechamos a torneira, fechamos a tampa 
do tubo. Nesse momento, estamos com os dentes limpos e escovados, a escova limpa, o tubo tampado e 
a torneira fechada. Imaginemos que um dia acordemos mal-humorados e resolvamos mudar a ordem de 
algumas das ações. Pegamos a escova de dentes, abrimos a torneira, damos uma molhadinha nas cerdas, 
escovamos os dentes, pegamos o tubo do dentifrício, abrimos a tampa, colocamos um pouco da pasta na 
escova, fechamos a tampa, enxaguamos a boca, limpamos a escova, fechamos a torneira. No final, teremos 
a escova limpa, a torneira fechada, o tubo fechado e os dentes escovados, porém não estarão limpos. Será 
que é isso mesmo? Vamos estudar cada ação executada no segundo caso, passo a passo. Após pegar a 
escova de dentes, abrir a torneira, molhar as cerdas e escovar os dentes, teremos a torneira aberta, a escova 
suja ainda sem a pasta e os dentes escovados sem o creme dental. Depois, pegamos o tubo, abrimos a 
tampa, colocamos a pasta na escova e fechamos a tampa. Agora, temos o tubo novamente fechado, a 
escova com pasta e os dentes escovados sem o creme dental. Finalmente, enxaguamos a boca, retiramos 
o creme dental da escova e fechamos a torneira, chegando à conclusão anterior, com a escova limpa, a 
torneira fechada, o tubo fechado e os dentes escovados, porém não limpos.
A situação anterior mostra que cada coisa que fazemos em qualquer momento da vida obedece a 
uma sequência de ações, desde o simples ato de procurar o botão para desligar o despertador até o de 
apagar a lâmpada antes de dormir. As ações obedecem a uma sequência lógica, procurando chegar a 
um certo objetivo. Quando queremos flertar com uma pessoa, há um encadeamento, uma sequência 
de ações, de tomadas de decisões, escolha entre várias possibilidades, além do uso das experiências 
adquiridas. Existe o desenvolvimento de um algoritmo com o intuito de conquistar essa pessoa.
O computador não possui conhecimento próprio. Assim, se precisarmos de sua ajuda para atingir um 
objetivo, deveremos instruí-lo com um algoritmo escrito conforme uma lógica correta, para ele cumprir a 
tarefa que queremos. Vamos estudar como fazer o computador começar a executar aquilo que desejamos.
1 ALgOrITmOs
1.1 Conceitos básicos
Pelo texto introdutório, podemos ter uma vaga ideia do que seja um algoritmo. Todas as ações no 
nosso dia a dia seguem um algoritmo, seja um ato intencional, seja um ato instintivo. Com o decorrer 
da vida, conforme vamos crescendo e aprendendo, novas instruções vão se incorporando ao nosso 
14
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
repertório. A experiência humana é um repertório de algoritmos que foram se acumulando durante a 
vida. O algoritmo é um conjunto finito de instruções, de comandos, de ações que tem como objetivo a 
resolução de uma tarefa, ou a resolução de um problema.
Algumas outras definições sobre algoritmos:
“Algoritmo é uma sequência finita de instruções ou operações cuja execução, em tempo finito, 
resolve um problema computacional, qualquer que seja sua instância. [...]
Algoritmo é uma sequência de passos que visam atingir um objetivo bem-definido” (FORBELLONE, 
1993, p. 3).
“Algoritmo são regras formais para a obtenção de um resultado ou da solução de um problema, 
englobando fórmulas de expressões aritméticas” (MANZANO, 1996, p. 6).
“Algoritmo é a descrição de uma sequência de passos que deve ser seguida para a realização de uma 
tarefa” (ASCENCIO; CAMPOS, 2003, p. 1).
Ação é um acontecimento que, a partir de um estado inicial, após um período 
de tempo finito, produz um estado final previsível e bem-definido. Portanto 
um algoritmo é a descrição de um conjunto de comandos que, obedecidos, 
resultam numa sucessão finita de ações (FARRER et al., 1999, p. 14).
1.2 Programas
Os computadores executam as tarefas que são comandadas pelo sistema operacional. Mais 
especificamente, o hardware (equipamento, monitor, teclado, mouse, tela de toque, dentre vários 
dispositivos), para interagir com o mundo físico, necessita de uma camada intermediária, que faça a ponte 
para executar os softwares (os programas, as instruções) Essa ponte é o chamado sistema operacional.
Hoje conhecemos alguns sistemas, como Linux, Windows, Mac OS, Android, e, no passado, tivemos 
outros, como MS-DOS, DOS, CP/M. O sistema operacional, por sua vez, compreende as instruções-padrão 
queos programas mandam executar. Esses programas são uma “tradução” dos comandos escritos em 
linguagem computacional que resultaram dos algoritmos por nós pensados. Assim, nossos algoritmos, 
uma vez corretos, podem ser transcritos em linguagem computacional, ou linguagem de programação, 
como o C, o C++, o C#, o Delphi, o Pascal, o PHP, o COBOL e diversas outras já existentes ou que virão a 
existir. Além do algoritmo, os programas incluem os dados a serem utilizados no processamento.
1.3 Lógica de programação
Na feira, as peras-asiáticas custam R$ 1,50 cada. Tenho R$ 10,00. Quantas peras eu posso comprar?
Nesse momento, o cérebro busca informações aprendidas no Ensino Fundamental e começa a fazer 
cálculos, ou a imaginar como resolver esse problema. Algumas pessoas, mentalmente, começam a somar 
15
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
e a contar no dedo: 1,50... 3,00... 4,50... 6,00... 7,50... 9,00... 10,50... Passou, então são seis. Outras já fazem 
a conta 10 dividido por 1,50, então 6 e sobra 1.
Esse processo, aplicado na programação de computadores, chama-se Lógica de Programação. Antes 
de montar um algoritmo, precisamos ter uma noção do que iremos fazer, ou, pelo menos, uma estrutura 
mental de como realizar a tarefa, ou de como resolver o problema proposto. Assim, é a técnica de 
encadear pensamentos para atingir um determinado objetivo.
O objetivo principal da Lógica de Programação é demonstrar técnicas para resolução de problemas 
e, consequentemente, para automatização de tarefas.
1.4 representação lógica
Para desenvolver um programa, uma vez estruturado o raciocínio lógico, passamos a utilizar 
simbologias dos algoritmos para representarmos esse pensamento. Na linguagem computacional, temos 
três tipos de algoritmos mais utilizados: descrição narrativa, fluxograma e pseudocódigo ou portugol, 
que descreveremos a seguir.
1.5 Tipos de algoritmos
1.5.1 Descrição narrativa
Para fazer uma descrição narrativa é necessário entender o problema proposto e narrar a sua solução 
por meio da linguagem normalmente utilizada no dia a dia, ou seja, a língua portuguesa.
Exemplo: você está perdido em um lugar de uma cidade desconhecida e procura a rodoviária; 
encontra um policial e pede auxílio:
– Por favor, como eu chego até a rodoviária?
O policial responde usando a descrição narrativa:
– Siga em frente e, na quarta esquina, vire à direita; siga em frente e, de lá, você já vai vê-la.
Quadro 1 – Vantagem e desvantagem de usar a descrição narrativa
Vantagem Desvantagem
Não é necessário aprender nenhum 
conceito novo. Basta escrever da 
maneira como se fala 
Essa linguagem dá margem para vários 
tipos de interpretação. Portanto, se 
você não for claro o suficiente, isso 
poderá dificultar a transição desse 
algoritmo para a programação 
16
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
 saiba mais
Assista ao filme:
UMA MENTE brilhante. Direção: Ron Howard. Produção: Brian Grazer e 
Ron Howard. EUA: Universal Pictures, 2001. 1 DVD (135 min).
Nesse filme, a personagem principal, o professor John Nash, utiliza 
algoritmos em diversas ocasiões. É interessante acompanhar o filme para 
compreender o processo de relacionar eventos cotidianos com as suas 
teorias. A tentativa de criar uma algoritmo para os passos do pombo e, 
principalmente, como a conquista de um grupo de garotas por um grupo 
de rapazes leva à derrubada de uma teoria clássica.
1.5.2 Fluxograma
No fluxograma, os passos para a resolução de um problema são demonstrados por meio de um 
conjunto de símbolos-padrão (Quadro 2).
Quadro 2 – Principais símbolos de um fluxograma
Símbolo Função
Início e fim do algoritmo 
Indica cálculo e atribuições de valores 
Indica a entrada de dados 
Indica uma decisão com possibilidades de desvios 
Indica saída de dados 
Indica o fluxo de dados. Serve também para conectar 
os blocos ou símbolos existentes
17
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Voltando ao exemplo do tópico anterior, se o guarda respondesse com um fluxograma, ele o faria 
conforme a Figura 1:
início
fim
Siga em frente
Contaesquina=1
Vire à esquerda
Siga em frente
Contaesquina=Contaesquina+1Contaesquina=4
não
sim
Figura 1 – Fluxograma para chegar à rodoviária
Quadro 3 – Vantagem e desvantagens de usar o fluxograma
Vantagem Desvantagens
O entendimento é bem mais simples
É necessário que se tenha conhecimento dos símbolos
Modificações e edições difíceis
1.5.3 Pseudocódigo ou Portugol
Essa estrutura é escrita em português, muito próxima à linguagem natural, utilizando regras 
predefinidas para escrevê-la. Essas regras não são tão rígidas quanto as de uma linguagem de programação, 
portanto o foco do pseudocódigo é a lógica, e não a rigidez sintática. Utilizando a situação anterior, do 
pedido de auxílio ao guarda, um exemplo de pseudocódigo (ainda sem as regras bem-definidas, como 
veremos mais adiante) seria:
18
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Algoritmo procura_rodoviária 
Variáveis 
contaesquina: inteiro 
Inicio 
Siga(“em frente”)
contaesquina ← 1 
Enquanto contaesquina ≠ 4 faça 
 contaesquina ← contaesquina + 1 
fim Enquanto
Vire(“direita”)
Siga(“em frente”)
Fim.
Quadro 4 – Vantagens e desvantagem de usar o pseudocódigo
Vantagens Desvantagem
O entendimento é bem mais simples
Não ocorrem erros de compilação
É necessário que se tenha conhecimento de 
pseudocódigo, que veremos mais adiante
1.6 regras para construção do algoritmo
Para construir um algoritmo, existem algumas regras práticas, que podem ser aperfeiçoadas conforme 
a experiência do programador. Deve-se ter em mente que um mau desenvolvedor de algoritmos 
dificilmente será um bom programador. Portanto, antes de ficar diante do computador para desenvolver 
um programa, é preciso definir as metas.
Assim, diante de um problema, devem-se seguir alguns passos.
•	 Leia	todo	o	problema:	faça	uma	leitura	de	todo	o	problema	até	o	final,	para	formar	a	primeira	
impressão. Releia o problema e faça anotações sobre os pontos principais.
•	 Entendimento:	o	problema	foi	bem-entendido?	Questione,	se	preciso,	o	autor	da	especificação	
sobre suas dúvidas. Releia o problema quantas vezes for preciso para entendê-lo.
•	 Resultados	esperados:	extraia	do	problema	todas	as	suas	saídas.
•	 Informações	disponíveis:	extraia	do	problema	todas	as	suas	entradas.
•	 Como	funciona:	identifique	qual	é	o	processamento	principal.
•	 Outras	 informações:	 verifique	 se	 será	 necessário	 algum	 valor	 intermediário	 que	 auxilie	 na	
transformação das entradas em saídas. Essa etapa pode parecer obscura no início, mas, com 
certeza, no desenrolar do algoritmo, esses valores aparecerão naturalmente.
19
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 Verificação:	 teste	 cada	 passo	 do	 algoritmo,	 com	 todos	 os	 seus	 caminhos,	 para	 verificar	 se	 o	
processamento está gerando os resultados esperados. Crie valores de teste para submeter ao algoritmo.
•	 Normatização:	reveja	o	algoritmo,	checando	as	boas	normas	de	criação.
Além disso, existem algumas recomendações para escrever um algoritmo legível: basta ser simples e 
objetivo. Para isso, descrevaa sequência de instruções conforme as indicações que seguem:
•	 	seja	objetivo,	usando	apenas	um	verbo	por	frase;
•	 	o	algoritmo	deve	ser	simples	o	suficiente	para	qualquer	pessoa	que	não	trabalhe	com	informática	
entender;
•	 não	use	frases	complexas	e	confusas,	o	importante	é	ser	simples	e	claro	no	seu	objetivo;
•	 	não	utilize	palavras	que	tenham	duplas	interpretações	ou	deixem	margem	a	dúvidas.
Por exemplo: desde que os celulares e os smartphones estão no mercado, os telefones públicos 
estão quase esquecidos, e nem sempre as pessoas sabem mais como utilizá-los. Existem sempre as 
emergências, principalmente, quando você percebe que se esqueceu de carregar o celular, está longe de 
casa e precisa fazer uma ligação urgente. Pensando nessa situação, faça um algoritmo não computacional 
cujo objetivo é usar um telefone público.
•	 Tirar	o	fone	do	gancho.
•	 Ouvir	o	sinal	de	linha.
•	 Introduzir	o	cartão.
•	 Teclar	o	número	desejado.
•	 Se	der	o	sinal	de	chamar:
— conversar;
— desligar;
— retirar o cartão.
•	 Se	não	der	o	sinal	de	chamar:
— colocar o fone no gancho;
— repetir.
20
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
 Observação
Pense em algumas situações do dia a dia nas quais esse raciocínio 
pode ser aplicado, como dar partida no carro, tomar café, ficar com dor de 
barriga no meio da rua etc.
 saiba mais
Existem programas que ajudam a organizar o pensamento e que se 
chamam mapas mentais. Existem vários programas desse tipo, como 
Freemind e Open Mind, que podem ser baixados e instalados gratuitamente.
Alguns sites oferecem programas para o uso on-line, como os seguintes:
<http://www.mindmeister.com/pt>.
<http://www.mindmup.com/>.
1.7 Introdução à programação
Uma vez tendo a noção geral de um algoritmo, veremos agora as regras para a montagem de 
programas.
É importante frisar que iremos aprender o pseudocódigo, mas a nomenclatura, os comandos e a 
estrutura sintática podem mudar, conforme a literatura. O importante não é a rigidez das regras formais, 
mas a ideia contida, ou seja, o que um comando faz, para que serve e como o faz. O pseudocódigo serve 
para desenvolver o raciocínio que será utilizado para criar um programa, e não para nos preocuparmos 
se estamos escrevendo dentro de normas rígidas como as exigidas por uma linguagem de programação.
Inicialmente, veremos os recursos: com que tipo de informação o computador trabalha, como 
fazemos a entrada e a saída de dados e quais operações é possível realizar.
1.7.1 Tipos de informações, entrada e saída
Podemos classificar os tipos de informações a serem processadas pelo computador, de modo geral, em 
dados e instruções. Os dados são as informações a serem processadas, e as instruções são os comandos 
que orientam o processamento feito por um computador.
Nesta primeira unidade focalizaremos, principalmente, os dados.
21
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
1.7.2 Dados
Desde o Ensino Fundamental, trabalhamos com unidades de medida (kg, km, L, m etc.) e com tipos 
de número (natural, inteiro, real). Os algoritmos e as linguagens de programação trabalham com dados 
bem-definidos. Esses dados são classificados em tipos.
1.7.3 Tipos de dados
Conforme o tipo de dado, o computador trabalha de uma forma diferente no tratamento destes 
durante o processamento.
1.7.3.1 Variáveis, constantes e operadores
1.7.3.1.1 Tipos primitivos de dados
Em princípio, os computadores trabalham com quatro tipos de dados. Partindo destes, as linguagens 
de programação derivam outros mais específicos, ou com uma precisão maior. O tratamento lógico 
entre esses tipos derivados é o mesmo. Assim, em Algoritmo trataremos apenas dos fundamentais: 
Números Inteiros; Números Reais; Caracteres e Cadeias; e Lógicos, definidos conforme a seguir.
•	 Números	Inteiros
— Toda e qualquer informação numérica que pertença ao Conjunto dos Números Inteiros 
(negativa, nula ou positiva). Exemplos: 1; 2; 44; 100; 0; -15; -99.
— Usos mais comuns: contador de eventos, idade, ano, quantidade.
•	 Números	Reais
— Toda e qualquer informação numérica que pertença ao Conjunto dos Números Reais (negativa, 
nula ou positiva). Exemplos: 0,12; 3,14159; 0,000; -1,23.
— Usos mais comuns: valores em dinheiro, como salário, preço total, preço unitário, peso, média.
•	 Caracteres	(char) e cadeias (string)
— Toda e qualquer informação composta por um conjunto de caracteres alfanuméricos:
– numéricos (‘0’...‘9’);
– alfabéticos (‘A’...‘Z’; ‘a’...‘z’);
– especiais (por exemplo, ‘#’, ‘?’,’ !’, ‘@’).
22
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
— São identificados por estarem entre apóstrofos (‘’).
— Uma cadeia é um conjunto de caracteres; assim, ‘a’ é um caractere, e ‘avião’ é uma cadeia.
— Usos mais comuns: nome, endereço, descrição.
•	 Lógicos
— Toda e qualquer informação que se enquadre em apenas duas situações:
– Valores booleanos V (verdadeiro) ou F (falso).
— Usos comuns: controle de fluxo de programa, flags.
Exemplo: identificar o tipo.
Tabela 1 – Identificação dos tipos
3,14159 Real
123 Inteiro
‘B52’ Cadeia
V Lógico
315,0 Real (pois o número pode assumir valores depois da vírgula)
-12 Inteiro
‘F’ Caractere (note os apóstrofos)
2014 Inteiro
‘Universidade Paulista’ Cadeira
1.7.3.1.2 Constantes
Quando um dado não sofre nenhuma variação durante a execução do programa, é chamado 
constante. Seu valor deverá ser o mesmo do início ao fim da execução do programa, assim como é o 
mesmo para execuções diferentes.
As constantes podem ser de qualquer tipo de dado e, normalmente, são definidas em parte específica 
de um programa.
Exemplo:
#definido PI = 3,141617 (nunca muda).
1.7.3.1.3 Variáveis
As variáveis são espaços reservados na memória principal do computador em que os dados são 
armazenados para reutilização posterior.
23
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Mesmo nas calculadoras mais simples, há um botãozinho M+ que pouca gente usa. Ele serve 
para guardar (ou acumular) temporariamente um valor, que recuperamos apertando a tecla MR. Essa 
tecla é especialmente útil quando temos operações mais complexas ou fórmulas com parênteses. No 
computador, podemos ter uma infinidade desses botões e, para podermos reconhecer o conteúdo de 
cada um deles, podemos batizar com um nome. Cada um desses botões é uma variável.
1.7.3.1.4 Variáveis – nomenclaturas
Para batizar uma variável, é recomendado dar um nome que lembre a informação armazenada.
Os nomes das variáveis são atribuídos pelo usuário e obedecem a certas regras:
•	 o	primeiro	caractere	deve	ser	uma	letra;
•	 	os	nomes	podem	ser	formados	por	letras,	dígitos	e	pelo	caractere	sublinhado	(underline);
•	 	podem	ter	qualquer	comprimento.
O computador, para poder trabalhar com as informações, precisa saber a localização do dado na 
memória. Portanto, cada variável criada possui um endereço em uma posição de memória, ou seja, um 
número representado por meio da notação hexadecimal que indica o endereço de memória em que está 
armazenada a informação.
Tabela 2 – Modelo de tabela de memória
Código 7000: B128 ‘ABC’ 
Letra 2000: 0007 ‘D’
Saldo 8900: 138D 12395 
Os endereços lógicos são locais que representam o endereço físico da memória RAM, que armazenam 
momentaneamente algum tipo de informação, ou seja, não ficam o tempo todo como mesmo valor. Na 
Tabela 2, os dados podem ser diversos; a caixa com o endereço 7000: B128 recebeu o texto ‘ABC’, mas, 
em outro momento, pode receber uma cadeia de caracteres qualquer. Assim, pode-se considerar que o 
conteúdo dos endereços lógicos pode sofrer alterações a qualquer momento. Daí vem o nome utilizado 
para essa representação: variáveis, pois variam durante cada execução do programa.
Ao definirmos uma variável como caractere ou string (ou cadeia de caracteres), alocaremos até 255 
bytes, um byte para cada caractere da string (cadeia). Com relação a cadeias, podemos utilizar o valor 
entre aspas ou entre apóstrofos.
Exemplo: crie nomes para as variáveis e determine os possíveis tipos de dados:
•	 cargo	do	funcionário;
24
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
•	 salário;
•	 valor	do	aluguel;
•	 telefone;
•	 endereço;
•	 nome	do	cantor;
•	 idade;
•	 RG;
•	 CNPJ;
•	 	título	do	CD.
Poderia ser:
Quadro 5 – Exemplo de nomes e tipos para variáveis
Cargo do funcionário CFunc ou Cargo_Func... Cadeia
Salário Salário... Real
Valor do aluguel VAluguel ou Valor_Aluguel... Real
Telefone Tel ou fone ou Telefone... Cadeia ou Inteiro
Endereço End ou Endereço... Cadeia
Nome do cantor Cantor ou N_Cantor ... Cadeia
Idade Idade Inteiro
RG RG Cadeia ou Inteiro
CNPJ CNPJ Cadeia ou Inteiro
Título do CD Titulo ou Tit_Cd... Cadeia
Exemplo: dados alguns nomes de variáveis, quais são válidos? Justifique os que não são.
Quadro 6 – Nomes de variáveis válidos e inválidos
dia/mês Caractere ‘/’ inválido
CEP Válido
1parcela Inicia com número
B52 Válido
P{O} Caracteres ‘{}’ inválidos
O&O Caractere ‘&’ inválido
AB*C Caractere ‘*’ inválido
ASDRUBAL Válido
25
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
UYT Válido
KM/L Caractere ‘/’ inválido
#55 Caractere ‘#’ inválido
“ALUNO” Nome entre aspas
AH! Caractere ‘!’ inválido
U2 X
VALOR TOTAL Espaço entre os nomes
1.7.3.1.5 Variáveis – declaração
Criar uma variável significa reservar um espaço na memória do computador dando-lhe um nome e 
determinar qual o tipo de dado que essa memória armazenará.
O processo de criação de uma variável é chamado também de declaração de variável. A declaração 
de uma variável no pseudocódigo tem um trecho (sessão) específico identificado como var ou variável. 
Assim, a declaração é feita conforme segue.
Var (ou variável)
 <nome da variavel1>,...<nome da variaveln>: <tipo>
 <nome da variaveln1>,...<nome da variavelnn>: <tipo>
Exemplo:
Var
 Nome, Código: Cadeia
 Contador, idade:inteiro
Agora, vamos entender, passo a passo, como o computador entende e faz as operações do 
exemplo.
Ao encontrar a instrução var, o computador entende que se trata da seção de declaração de variáveis 
e prepara a memória para criar os espaços para as variáveis. Na linha seguinte, encontra dois nomes 
que batizarão espaços de memória, Nome e Código. Ao final da linha, há a indicação de que o espaço 
a ser reservado será do tipo Cadeia. Assim, para cada uma das variáveis, serão reservados 256 bytes, 
e o computador armazenará, por critérios técnicos, os endereços de memória no local em que foram 
criados; no caso, do byte do endereço 100 até o byte do endereço 355, para Nome, e do endereço 
356 até o 611, para Código. A seguir, encontra dois novos nomes, Contador e Idade, que são do tipo 
Inteiro. O computador reserva 4 bytes (inteiros, no nosso caso, mas que podem mudar de programa 
para programa) para cada uma das variáveis. Assim, reserva os bytes do endereço 612 até o 615, para 
Contador, e de 616 até 619, para Idade.
26
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Quadro 7 – Passo a passo da declaração de variáveis
Linha de execução Computador
Var ◄
 Nome, Código: Cadeia
 Contador, idade:inteiro
Vou começar a 
reservar espaço 
na memória
Var
 Nome, Código: Cadeia◄
 Contador, idade:inteiro
Variável: Nome
Endereço: 100 a 355
Memória
Variável: Código
Endereço: 356 a 611
Var
 Nome, Código: Cadeia
 Contador, idade:inteiro◄
Variável: Nome
Endereço: 100 a 355
Contador
612 a 615
idade
616 a 619
Memória
Variável: Código
Endereço: 356 a 611
1.7.3.2 Operadores
O computador faz uma série de operações. Quando falamos em operações, não são apenas as 
matemáticas – soma, subtração, entre outras –, mas sim aquels feitas para operar qualquer manipulação 
de dados. Assim, operadores são elementos que atuam sobre operandos para produzirem um resultado. 
Ao tomarmos a expressão aritmética 2 + 3, temos dois operandos ,os números 2 e 3, que são relacionados 
pelo operador soma (+), fazendo a operação de adição. Os operadores podem ser binários, quando atuam 
sobre dois operadores (soma, subtração etc.), ou unários, quando atuam somente sobre um operador 
(como o sinal negativo em um número).
1.7.3.2.1 Operador de atribuição (→ ou <-)
Vimos que as variáveis armazenam valores para o uso posterior no transcorrer do programa, mas 
como colocar um valor em uma variável?
Para armazenar um valor em uma variável utilizamos o operador de atribuição.
O operador de atribuição é representado por uma seta apontando para a esquerda (¬), ou, por 
questões gráficas, por um símbolo de “menor” e um “traço” (<-).
27
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Forma:
<variável> ← valor
Exemplo:
Var
Nome:Cadeia
Idade:inteiro
Inicio
Nome<-“Aderbal Schmydt”
Idade<-19
Fim
Estudando detalhadamente cada passo do computador:
Var (O computador entende que entrará em processo de reserva de memória.)
Nome:Cadeia (Reserva o espaço chamado Nome para o tipo String.)
Nome
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ... ... 255
Figura 2 – Reservando a variável “nome”
Idade:inteiro(Reserva o espaço chamado Idade para o tipo Inteiro.)
Idade
1 2 3 4
Figura 3 – Reservando a variável “idade”
Inicio (Início do processamento.)
Nome<-“Aderbal Schmydt” (O Valor “Aderbal Schmydt” será armazenado 
no espaço chamado Nome.)
Nome
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ... ... 255
‘A’ ‘d’ ‘e’ ‘r’ ‘b’ ‘a’ ‘l’ ‘S’ ‘c’ ‘h’ ‘m’ ‘y’ ‘d’ ‘t’
Figura 4 – Atribuindo valor
Idade <- 19 (O Valor 19 será armazenado no espaço chamado Idade.)
28
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Idade
1 2 3 4
 19
Figura 5 – Atribuindo valor numérico
Fim (Fim do processamento.)
 Lembrete
Você somente conseguirá atribuir um valor a uma variável se ela estiver 
criada na seção de declaração.
1.7.3.2.2 Operadores aritméticos
Como fazemos contas com os algoritmos? Da mesma forma que na matemática, utilizamos os 
operadores aritméticos. Como são aritméticos, as operações são feitas entre números, resultando em 
um outro número.
Quadro 8 – Principais operadores aritméticos
Operador Referência do operador 
+ Adição 
- Subtração 
* Multiplicação 
/ Divisão 
DIV Quociente 
MOD Resto da divisão 
** Exponenciação 
As operações de soma, subtração, multiplicação, divisão e exponenciação são as habituais da 
matemática. A computação oferece duas outras que são de extrema utilidade: o DIV e o MOD.
A divisão, o MOD e o DIV envolvem a operação de divisão, mas cada uma dessas operações pode dar 
resultados diferentes. Vamos tomar a divisão de9 por 2.
A divisão 9/2 resulta em 4,5, conforme segue:
 9 2
-8 4,5
 10
-10
 0
9/2
29
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Para entender o MOD e o DIV, é importante ter em mente que as operações envolvem apenas 
números inteiros:
 9 2
-8 4
 1
9 div 2
9 mod 2
Resumindo:
9 / 2 resulta em 4,5
9 div 2 resulta em 4
9 mod 2 resulta em 1
Exemplos:
•	 Para	verificar	se	um	número	é	par,	é	bem	simples:	por	definição,	os	pares	são	divisíveis	por	2,	ou	
seja, o resto da divisão tem de ser zero. Portanto, ao fazer a operação:
Numero mod 2
Se o resultado for zero, o conteúdo da variável número será par.
•	 Em	 muitos	 jogos,	 é	 necessário	 delimitar	 uma	 faixa	 de	 número.	 Num	 jogo	 de	 dados,	 os	
resultados sempre estão entre 1 e 6. A melhor forma de conseguir é utilizando o princípio de 
que o resto de uma divisão sempre estará entre 0 e o valor do divisor menos 1; assim, o resto 
da divisão de qualquer número inteiro por 6 resultará em um número entre 0 e 5. Como o 
resultado tem de estar entre 1 e 6 e o resto está entre 0 e 5, basta somar 1.
Numero mod 6 + 1
Qualquer que seja o conteúdo da variável número, o resultado sempre será 1, 2, 3, 4, 5 ou 6.
•	 Para	separar	os	algarismos	de	um	número	de	dois	dígitos,	como	usamos	um	sistema	de	numeração	
decimal, base dez, ao utilizarmos o quociente da divisão inteira teremos o dígito das dezenas, e o 
resto, o dígito das unidades.
Numero div 10
Numero mod 10
Caso a variável número contenha um valor entre 0 e 99 (dois dígitos), ao fazer a operação DIV, ela 
resultará num valor entre 0 e 9, e o MOD a unidade que resta dos múltiplos de dez.
30
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
1.7.3.2.3 Operadores relacionais
Quando queremos comparar duas informações, são usados os operadores relacionais. Como são 
comparações, os resultados possíveis serão o verdadeiro ou o falso. Mas o que são essas comparações?
Ocorrem quando um mesmo tipo de informação pode ser avaliado quanto à sua grandeza, ou à sua 
igualdade. Assim, um número pode ser maior ou menor que outro, ou, ainda, igual a esse número.
Quadro 9 – Operadores relacionais
Operador Referência do operador 
= Igual 
<> Diferente 
>= Maior ou igual 
<= Menor ou igual 
> Maior 
< Menor 
Exemplo: avaliar o resultado das operações relacionais.
Tabela 3 – Exemplo de resultado dos operadores relacionais
9 > 8 Verdadeiro
15 <=15 Verdadeiro A operação é menor ou igual; portanto, nesse caso, a igualdade valida a comparação
15 > 15 Falso
15 <> 15 Falso Atenção: os números são iguais, e a comparação é diferente 
15 = 15 Verdadeiro
17 >= 20 Falso
“rata”< “rato” Verdadeiro No caso de cadeias, compara-se dígito a dígito, até encontrar um caractere diferente, com o qual será feita a comparação 
1.7.3.2.4 Operadores lógicos
Para fazer cálculos com os valores verdadeiro e falso, são utilizados os operadores lógicos. Os mais comuns são 
os operadores ‘e’, ‘ou’ e ‘não’; e, menos comumente, o ‘xor’. Cada um dos operadores obedece a uma lei de formação.
•	 Operador	 ‘e’:	o	resultado	do	operador	e somente será verdadeiro quando ambos os operandos 
forem verdadeiros. Assim, a chamada tabela-verdade para o e será como segue.
Quadro 10 – Tabela-verdade da operação e
Operando 1 Operando 2 Resultado
VERDADEIRO E VERDADEIRO → VERDADEIRO 
VERDADEIRO E FALSO → FALSO 
FALSO E VERDADEIRO → FALSO 
FALSO E FALSO → FALSO 
31
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 Operador	‘ou’:	o	resultado	do	operador	ou somente será verdadeiro quando pelo menos um dos 
operandos for verdadeiro. Assim, a chamada tabela-verdade para o ou será como segue.
Quadro 11 – Tabela-verdade da operação ou
Operando 1 Operando 2 Resultado
VERDADEIRO OU VERDADEIRO → VERDADEIRO
VERDADEIRO OU FALSO → VERDADEIRO
FALSO OU VERDADEIRO → VERDADEIRO
FALSO OU FALSO → FALSO
•	 Operador	‘não’:	o	operador	não é unário, ou seja, tem apenas um operando e inverte o valor do 
resultado desse operando. Assim, a chamada tabela-verdade para o não será como segue.
Quadro 12 – Tabela-verdade da operação não
Operando Resultado
NÃO VERDADEIRO → FALSO
NÃO FALSO → VERDADEIRO
•	 Operador	XOR:	o	operador	XOR	é	menos	utilizado;	seu	resultado	somente	será	verdadeiro	quando	
os dois operandos forem diferentes. O XOR é conhecido também como ou exclusivo. Assim, a 
chamada tabela-verdade para o XOR será como segue.
Quadro 13 – Tabela-verdade da operação XOR
Operando 1 Operando 2 Resultado
VERDADEIRO XOR VERDADEIRO → FALSO
VERDADEIRO XOR FALSO → VERDADEIRO
FALSO XOR VERDADEIRO → VERDADEIRO
FALSO XOR FALSO → FALSO
Exemplo de aplicação
Um caso típico do uso do XOR é para analisar a diferença de valores binários, por exemplo:
a) 0101 (5 decimal).
b) 0100 (4 decimal).
Ao aplicamos o operador XOR nos dois valores, teremos o seguinte resultado:
0101
0100
----
0001
32
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Assim, vemos facilmente que a diferença está no quarto bit.
1.7.3.2.5 Prioridade na avaliação de expressões
Encontre o resultado de:
2 + 3 x 5
A resposta não é 25. O correto é 17. Voltando à aritmética do Ensino Fundamental, vamos nos 
lembrar de que a multiplicação é efetuada antes da soma.
O mesmo acontece com a programação: existe uma sequência para realizar as operações. Portanto, 
deve-se obedecer à seguinte ordem:
•	 parênteses	e	funções	(resolvidos	da	esquerda	para	a	direita);
•	 multiplicação	(*),	divisão	(	/	e	div	)	e	resto	(	Mod	)	(resolvidos	da	esquerda	para	a	direita);
•	 soma	e	subtração;
•	 operadores	relacionais:	>,	<,	>=,	<=,=,<>;
•	 operador	lógico	não;
•	 operador	lógico	e;
•	 operador	lógico	ou.
Exemplo: resolver a seguinte expressão.
X=((1+ 2 * 3) <= (4 + 6 / 2)) e (não((6+1)<>(10-3)))
X=((1+ 6 ) <= (4 + 3 )) e (não( 7 <> 7))
X=( 7 <= 7 ) e (não( Falso ))
X=( Verdadeiro ) e ( Verdadeiro )
X=Verdadeiro
Exemplo: sabendo que A = 5, B = 4, C = 3 e D = 6, avaliar as expressões a seguir.
Tabela 4 – Exemplos de expressões
(A > C) e (C<=D) Verdadeiro
(A+B) > 10 ou (A+B) = (C+D) Verdadeiro
(A>=C) e não(D>=C) Falso
33
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 Lembrete
O operador aritmético atua entre dois números, resultando em 
outro número.
O operador relacional atua entre duas grandezas, resultando num 
valor lógico.
O operador lógico atua apenas em valores lógicos, resultando em um 
valor lógico.
1.7.3.2.6 Linearização
O computador não reconhece as fórmulas matemáticas armadas; por exemplo, para calcular a área 
de um triângulo, aprendemos que:
Área=
base x altura
2
Para que o computador entenda a fórmula, precisamos, manualmente, fazer o processo de 
linearização. Esse processo consiste em remontar a fórmula utilizando parênteses e escrevendo-a em 
apenas uma linha. Assim, a fórmula da área do triângulo fica:
Área <- (base * altura)/2
Exemplo: no manual do aluno, consta que o cálculo da média final é:
MF
xNP xNP xPIM
=
+4 1 4 2 2
10
.
Linearizando, fica:
NF <- (4*NP1 + 4*NP2 + 2*PIM)/10
1.8 Programação sequencial
Agora que sabemos as operações, vamos começar a programar.Como você deve ter notado, os 
eventos que vimos com relação à execução de um algoritmo são feitos linha a linha; temos uma 
instrução e, uma vez realizada, passamos para a linha seguinte. Na programação ocorre o mesmo. O 
computador lê cada linha e executa o comando escrito pelo programador; feito isso, passa para a linha 
seguinte, e assim sucessivamente, até o final do programa.
34
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
1.8.1 Estrutura sequencial
Essa maneira de programar, em que as instruções são executadas uma após a outra, na ordem 
em que foram escritas, chama-se programação sequencial, ou podemos dizer que o programa foi 
escrito numa estrutura sequencial. Portanto, a estrutura sequencial é um conjunto de comandos que 
serão executados numa sequência linear de cima para baixo, linha a linha. Pode aparecer em qualquer 
estrutura de controle, agrupada ou não por blocos.
comando 1; 
comando 2; 
início comando 3 ... 
meio comando 3 ... 
fim comando 3 ; ... 
 comando n; 
.
.
.
Quando é feito o uso de fluxogramas, a estrutura sequencial é caracterizada por um único fluxo 
de execução (um único caminho orientado) no diagrama (Figura 2). Em pseudocódigos, a estrutura 
sequencial caracteriza-se por um conjunto de comandos dispostos ordenadamente.
Comando 1
Comando 2
Comando 3
Figura 6 – Operações sequenciais
1.9 estrutura de um pseudocódigo
Não existe uma estrutura rígida de escrita de um pseudocódigo; conforme a literatura, tal estrutura 
pode mudar, mas o importante é que transmita a ideia, com vistas à posterior passagem para a 
linguagem computacional. Exigir regras fixas e pouco flexíveis é tornar o pseudocódigo uma linguagem 
de programação. Isso não quer dizer que um pseudocódigo possa ser escrito de qualquer forma. Um 
mínimo de formalidade é necessário para um bom entendimento.
35
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Com base nas formas mais comuns encontradas na literatura, um pseudocódigo tem três partes:
•	 cabeçalho	com	o	nome	do	programa;
•	 uma	seção	para	a	declaração	das	constantes	e	das	variáveis;
•	 o	corpo	do	programa,	em	que	é	feita	a	programação	sequencial.
Segue um algoritmo completo: em azul-claro, temos o cabeçalho; em bege, a declaração das 
variáveis; e, em verde, o corpo do programa.
Temos também algumas regras de etiqueta, ou boa educação. Essas regras não estão diretamente 
ligadas ao processamento em si, mas facilitam a compreensão do programa, tanto pelo autor quanto 
pelas pessoas que, posteriormente, tentarão entender o programa. Usando o mesmo código, veremos 
dois conceitos importantíssimos: o comentário e a identação (são válidos tanto o termo indentação, 
um anglicismo vindo de to indent, quanto o oficialmente adotado endentação).
•	 Comentário	 são	 as	 linhas	marcadas	 em	 azul	 (a	 seguir).	 Serve	 para	 lembrar	 ou	 explicar	 o	 que	
está acontecendo em um determinado local do código. Deve ser feito com critério, para ser 
bem objetivo, e conter a ideia daquele trecho, e não especificamente dizer o que uma linha está 
executando.
36
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
•	 A	 identação	 é	útil	 para	 separar	 blocos	de	programação,	 afastando	 e	 realinhando	as	 linhas	da	
margem esquerda. A identação na confecção do pseudocódigo é fundamental, e, muitas vezes, os 
códigos são considerados inválidos caso esta não seja feita. No código a seguir, as linhas verticais 
são os blocos, e as setas horizontais, as identações.
37
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Ao tirarmos a identação, o mesmo código fica da seguinte forma:
algoritmo “Calc_Preco_final”
var
parcelas,i:inteiro
preco,taxa,juros, prestacao, precofinal,parcelamensal:real
inicio
escreva(“Entre com o preço do produto”)
leia(preco)
escreva(“Entre com a quantidade de parcelas”)
leia(parcelas)
se parcelas > 1 entao
//venda parcelada
escreva(“Entre com a taxa de juro % mensal”)
leia(taxa)
prestacao<-preco/parcelas
//inicializando o valor total
precofinal<-0
//acumulando as prestações
para i de 1 ate parcelas faca
parcelamensal<-prestacao + (prestacao * taxa / 100)
escreva(“prestacao “,i,” valor “, parcelamensal)
precofinal<-precofinal + parcelamensal
fimpara
senao
// venda a vista
precofinal<-preco
fimse
escreva(“Preço final”,precofinal)
fimalgoritmo
Notam-se claramente o desconforto e a perda total das diversas seções do código, bem como do 
início e do fim dos blocos de execução.
1.10 entrada e saída de informações
Nos primeiros passos da programação vistos até agora, os programas efetuaram operações, mas não 
interagiram com o ser humano, o usuário.
1.10.1 Instrução primitiva de saída de dados
Para podermos ver no monitor, ou em uma impressora (os chamados dispositivos de saída), precisamos 
ter uma instrução específica. Esta é chamada de instrução primitiva de saída de dados. Primitiva, pois é 
uma instrução nativa, que não requer programação e já vem pronta para ser utilizada. Essa instrução é a 
38
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
maneira que temos para mostrar (colocar no dispositivo de saída) as informações contidas na memória 
dos computadores, para que o usuário possa visualizá-las. A sintaxe é:
escreva(<lista_de_variáveis>)
escreva(“Texto”)
Ou 
escreva(“Texto”,<variáveis>,”Texto”,<variáveis>...)
Uma <lista_de_variáveis> é um conjunto de nomes de variáveis separados por vírgulas:
Exemplo:
escreva(i,j,total)
escreva(“Entre com a taxa de juro % mensal”)
escreva(“prestacao “,i,” valor “, parcelamensal))
 Observação
Muitas obras utilizam as instruções escrever ou imprimir, em vez de 
escreva. Todas estão corretas e podem ser utilizadas no curso. O importante 
é a compreensão do comando que está sendo utilizado. Essa é a grande 
vantagem de utilizar o português estruturado: ele não fica limitado a uma 
regra restrita de linguagem de programação.
Escreva (escrever), por ser considerada uma palavra reservada, não mais poderá ser utilizada como 
nome de variável. Assim, toda vez que ela for encontrada dentro dos pseudocódigos, será identificada 
como um comando de saída de dados.
No fluxograma, uma instrução de saída de dados é representada como na Figura 7.
Lista de 
variáveis 
ou “texto”
Lista de 
variáveis 
ou “texto”
Figura 7 – Símbolo de saída
No fluxograma, não é necessário o uso do comando escreva, uma vez que a forma geométrica da 
figura determina a ação.
39
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Exemplo: o algoritmo a seguir mostra o uso da instrução de saída. O programa faz o cálculo do preço 
total de cinco produtos que custam cinco reais cada, apresentando na tela o resultado.
algoritmo “ExemploSaida”
var
PR_UNIT, PR_TOT: Real
QTD: Inteiro
inicio
 PR_UNIT <- 5.0
 QTD<-10
 PR_TOT<-PR_UNIT*QTD
 escreva(PR_TOT)
fimalgoritmo
Esse mesmo programa, escrito em forma de fluxograma (Figura 8), fica:
início
fim
PR_UNIT<-5.0
QTD<-10
PR_TOT<-
PR_UNIT*QTD
PR_TOT
Figura 8 – Algoritmo do exemplo de saída
1.10.2 Instrução primitivade entrada de dados
No algoritmo do exemplo anterior, a interação com o computador ainda não está completa. O 
programa faz o cálculo e mostra o resultado na tela. Os valores do preço unitário (5.0) e da quantidade 
(10) são fixos. O ideal seria poder alterar esses valores a cada execução do programa. Para isso, teríamos 
de fazer a interação de introduzir um valor no programa, durante a sua execução, por meio do teclado. 
40
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
A instrução primitiva, no caso, é o leia. Essa instrução interrompe a execução e espera a interação do 
usuário para introduzir uma informação, que será armazenada na variável indicada pelo comando e que 
será utilizada no transcorrer do programa.
leia(<variável>)
leia(<lista de variáveis>)
 Observação
O leia pode aparecer como ler, conforme o autor.
No fluxograma (Figura 9), a representação fica:
variáveis variáveis
Figura 9 – Símbolo para a entrada de informações
Exemplo: voltando ao programa do exemplo anterior, agora será alterado para entrar com os valores 
da quantidade e do preço do produto.
algoritmo “ExemploSaida”
var
PR_UNIT, PR_TOT: Real
QTD: Inteiro
inicio
 leia (PR_UNIT, QTD<-10)
 PR_TOT<-PR_UNIT*QTD
 escreva(PR_TOT)
fimalgoritmo
Assim, o fluxograma (Figura 10) será alterado também, para receber a entrada de informações.
41
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
início
fim
PR_UNIT, QTD
PR_TOT
PR_TOT<-
PR_UNIT*QTD
Figura 10 – Programa com entrada e saída
1.10.3 Teste de mesa
Um algoritmo precisa ser validado pela utilização do teste de mesa. Nesse teste, você assume o 
papel do processador e fica responsável por executar cada linha do código. O teste permite verificar se 
o código está realmente executando a função para a qual foi criado e se existe algum erro de lógica nos 
passos apresentados.
Esse teste é de uma época em que programar um computador era extremamente complicado, e cada 
processamento era muito caro. Processar um código incerto era um desperdício de tempo, e, portanto, 
era necessário ter certeza de que aquele programa funcionaria. Nos testes manuais, os programadores 
faziam simulações de execução e corrigiam erros encontrados antes mesmo de executar o código na 
máquina real. Essa prática se perdeu com o tempo, com o advento da programação interativa (na qual 
o programador tem acesso à máquina e pode testar alterações).
Para fazer um teste de mesa, inicialmente, vamos estudar um código.
O programa foi escrito para calcular o valor de um termo de uma progressão aritmética (PA) que fica 
determinada pela sua razão (r) e pelo primeiro termo (a1). Esta é dada pela fórmula:
an=a1 + (n – 1) x r
algoritmo “PA”
// Seção de Declarações
Var
razao, n, a1, an:inteiro
Inicio
// Seção de Comandos
42
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razao
 escreva(“O elemento”,n,” é “,an)
fimalgoritmo
Vamos fazer o teste de mesa verificando o resultado para r = 5, a1 = 12 e n = 4.
Inicialmente, vamos verificar qual o valor esperado efetuando matematicamente a fórmula:
a4 = 12 + (4 – 1) x 5
a4 = 27
Portanto, o valor esperado é 27.
Como estamos assumindo o papel do computador, executaremos sequencialmente cada linha do 
programa.
•	 Iniciando	a	execução,	o	computador	está	com	a	memória	totalmente	vazia.
Memoria
Figura 11 – Memória no início da execução do programa
•	 Na	primeira	linha,	encontramos	a	identificação	do	programa.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razao
 escreva(“O elemento”,n,” é “,an)
fimalgoritmo
43
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Assim, reservamos a memória para o programa PA.
Memoria: PA
Figura 12 – Memória reservada para o programa PA
•	 Na	linha	seguinte,	encontramos	um	comentário,	portanto	este	será	ignorado.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razao
 escreva(“O elemento”,n,” é “,an)
fimalgoritmo
A memória continua sem alteração.
Memoria: PA
Figura 13 – Memória sem mudanças
•	 A	seguir,	encontramos	a	seção	de	declaração	das	variáveis.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
44
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
 leia(n)
 an<-a1+(n-1)*razao
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
Nesse ponto, o computador criará os espaços na memória para as variáveis. Em nossa memória 
simulada, cada variável será representada em uma coluna.
Memoria: PA
razao n a1 an
Figura 14 – Espaços criados na memória pelo computador
•	 Montadas	as	variáveis,	é	iniciado	o	processamento	do	programa,	que	encontra	mais	um	comentário	
e encontrará um comando de saída.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razao
 escreva(“O elemento”,n,” é “,an)
fimalgoritmo
Para simular a saída, criaremos uma nova coluna, chamada tela, em que serão simuladas as 
informações de entrada e saída (no caso, a instrução escreva).
Memoria: PA
razao Tela
Entre com a razão
n a1 an
Figura 15 – Memória com tela para as informações de entrada e saída
45
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 No	 passo	 seguinte,	 o	 programa	 esperará	 que	 o	 usuário	 digite	 um	 valor,	 que	 será	 atribuído	 à	
variável razão.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
Entramos com o valor 5, pois este foi definido como precondição para a simulação. Assim, a 
informação será armazenada na variável razão.
Memoria: PA
razao Tela
Entre com a razão
5
5
n a1 an
Figura 16 – Memória com tela mostrando o valor 5
•	 O	computador	encontra,	no	passo	seguinte,	mais	uma	instrução	de	saída.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre como elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
46
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
O texto será mostrado na tela.
Memoria: PA
razao Tela
Entre com a razão
5
Entre com o primeiro termo
5
n a1 an
Figura 17 – Memória com tela mostrando o texto
•	 A	seguir,	é	feita	a	leitura,	para	atribuir	valor	à	variável	a1.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
A variável a1 receberá 12.
Memoria: PA
razao Tela
Entre com a razão
5
Entre com o primeiro termo
12
5 12
n a1 an
Figura 18 – Atribuição do valor 12 à vaiável a1
•	 Novamente,	é	executada	a	saída	de	um	texto.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
47
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
O texto será exibido na tela.
Memoria: PA
razao Tela
Entre com a razão
5
Entre com o primeiro termo
12
Entre com elemento N
5 12
n a1 an
Figura 19 – Memória mostrando o texto na tela
•	 Finalmente,	será	feita	a	leitura	do	valor	do	termo	que	queremos	saber	na	PA.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
Nesse momento, a variável razão contém o valor 5, a variável n contém 4, a variável a1 contém 12 
e a variável an continua vazia.
48
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Memoria: PA
razao Tela
Entre com a razão
5
Entre com o primeiro termo
12
Entre com o elemento N
4
5 124
n a1 an
Figura 20 – Memória exibindo somente a variável an sem valor atribuído
•	 É	efetuado	o	cálculo	substituindo-se	os	nomes	das	variáveis	pelo	seu	conteúdo	e	atribuindo	o	
resultado à variável an.
algoritmo “PA”
// Seção de Declarações
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
O resultado 27 será armazenado na variável an.
Memoria: PA
razao Tela
Entre com a razão
5
Entre com o primeiro termo
12
Entre com o elemento N
4
5 124 27
n a1 an
Figura 21 – Memória com o resultado 27 armazenado na variável an
•	 O	passo	seguinte	é	mostrar	o	resultado.
algoritmo “PA”
// Seção de Declarações
49
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Var
razao,n,a1,an:inteiro
Inicio
// Seção de Comandos
 escreva(“Entre com a razao:”)
 leia(razao)
 escreva(“Entre com o primeiro termo”)
 leia(a1)
 escreva(“Entre com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
Como n vale 4, an vale 27, e a saída será “O elemento 4 é 27”.
Memoria: PA
razao Tela
Entre com a razão
5
Entre com o primeiro termo
12
Entre com o elemento N
4
O elemento 4 é 27
5 124 27
n a1 an
Figura 22 – Memória com tela mostrando o resultado
•	 A	última	linha	é	apenas	uma	indicação	de	encerramento	do	programa.
Ao final da simulação, o valor foi 27; correspondendo ao calculado matematicamente, podemos 
considerar o programa correto.
Para fazer um bom teste de mesa, há algumas sugestões. Existirão termos ainda não estudados, mas 
devemos nos lembrar deles no futuro.
•	 Quando	o	programa	for	muito	extenso	e	existir	um	trecho	a	ser	estudado,	identifique	as	variáveis	
que serão necessárias, pois algumas poderão ser inúteis naquele trecho.
•	 Sempre	fique	atento	aos	limites	dos	laços	(que	veremos	mais	adiante),	pois	a	repetição	pode	
levar ao engano no controle; faça cada iteração, pois pode existir um ponto de saída sem o laço 
estar concluído.
•	 Preste	atenção	nas	funções	chamadas	durante	a	iteração	dos	laços.
•	 Como	vimos,	execute	cada	linha	do	programa,	e	na	sequência	correta.
50
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
 resumo
Nesta unidade, vimos os princípios básicos da programação: o processo 
da montagem de um programa, desde a apresentação de um problema, 
passando pelo entendimento, até a transformação em um algoritmo.
Aprendemos os conceitos de lógica de programação, aquele raciocínio 
lógico para a resolução de um problema, e de algoritmo, a sequência 
de instruções montadas de forma que facilmente sejam convertidas em 
qualquer linguagem de programação, que é o algoritmo escrito numa 
linguagem que o computador (ou o compilador) entende.
Para a montagem do algoritmo, vimos que existem três 
possibilidades de representar e desenvolver a lógica: a descrição 
narrativa, que é a narração em português do dia a dia, que tem a 
vantagem de não precisar de conhecimento prévio de programação, 
mas abre a possibilidade de dupla interpretação; o fluxograma, que 
faz uso de símbolos gráficos de fácil visualização, mas de difícil 
construção; e o Portugol, que exige um prévio conhecimento de 
estruturas de programação, mas facilita o desenvolvimento lógico e a 
tradução para a linguagem de máquina.
Uma vez apresentados os fundamentos, passamos a aprender os 
conceitos básicos para a programação. Inicialmente, vimos quais 
informações um programa manipula, os dados, os tipos primitivos, que são 
os números inteiros e reais, os lógicos (falso e verdadeiro) e os caracteres. 
Uma vez vistos os tipos de dados, abordamos como estes podem ser 
trabalhados no programa e como são armazenados em memórias chamadas 
variáveis.
Com os dados na memória, passamos a ver como trabalhar com eles por 
meio de operações, tais como a operação de atribuição para movimentar 
os	valores,	as	operações	aritméticas	 (+,-,	 *,	 /,	MOD	e	DIV),	os	operadores	
relacionais que comparam grandezas (>,>=<, <=, =, <>) e os operadores 
lógicos (e, ou, não, XOR). Lembrando que todos esses operadores podem 
ser colocados em uma única expressão e calculados obedecendo a uma 
hierarquia que determina quais operações devem ser efetuadas antes e 
quais devem ser efetuadas depois.
Vimos, portanto, que um programa é uma sequência de comandos 
e operações, e aprendemos como essa sequência deve ser construída, a 
chamada estrutura sequencial.
51
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Os primeiros comandos que vimos foram os de entrada e saída de 
informações, o leia () e o escreva ().
Um programa, uma vez escrito, precisa ser testado, bem como ter 
verificados a sua funcionalidade e o correto funcionamentológico. Para isso, 
a ferramenta que nos acompanhará até o final do curso é o teste de mesa, em 
que nós assumimos o papel do computador e simulamos o processamento.
 exercícios
Questão 1. Considere que o número de uma placa de veículo é composto por quatro algarismos. 
Foram apresentadas três propostas de algoritmos em Portugol que leiam esse número e apresentem o 
algarismo correspondente à casa das dezenas.
Proposta A algoritmo “Placacarro”
// Seção de Declarações
Var
 a,d :inteiro
inicio
// Seção de Comandos
 escreva(“Entre com o numero de 4 dígitos”)
 leia(a)
 d<-a mod 100 div 10
 escreva(“O algarismo das dezenas é “,d)
fimalgoritmo
Proposta B algoritmo “Placacarro”
// Seção de Declarações
Var
 a,d :inteiro
inicio
// Seção de Comandos
 escreva(“Entre com o numero de 4 dígitos”)
 leia(a)
 d<-a mod 1000 div 100
 escreva(“O algarismo das dezenas é “,d)
fimalgoritmo
Proposta C algoritmo “Placacarro”
// Seção de Declarações
Var
 a,d :inteiro
inicio
// Seção de Comandos
 escreva(“Entre com o numero de 4 dígitos”)
 leia(a)
 d<-a div 1000
 escreva(“O algarismo dos dezenas é “,d)
fimalgoritmo
52
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Qual das afirmações a seguir é correta?
A) Somente a proposta A apresenta o algarismo das dezenas.
B) Somente a proposta B apresenta o algarismo das dezenas.
C) Somente a proposta C apresenta o algarismo das dezenas.
D) Mais de uma proposta apresenta o algarismo das dezenas.
E) Nenhuma das propostas apresenta o algarismo das dezenas.
Resposta correta: alternativa A.
Análise das alternativas
Considerando um número com quatro algarimos, 1234, por exemplo, o algarismo das dezenas é 3. A 
melhor solução para problemas que envolvem códigos é fazer o teste de mesa.
A) Alternativa correta.
Justificativa: somente essa proposta apresenta o algarismo das dezenas, conforme demonstrado a 
seguir.
algoritmo “Placacarro”
// Seção de Declarações
Var
 a,d :inteiro
inicio
// Seção de Comandos
 escreva(“Entre com o numero de 4 dígitos”)
 leia(a)
 d<-a mod 100 div 10
 escreva(“O algarismo das dezenas é “,d)
fimalgoritmo
a d Tela
1234
3
Entre com o número de 4 
dígitos
O algarismo das dezenas é 3
Figura 23
53
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
O coração do algoritmo é o cálculo d<-a mod 100 div 10
Assim:
1234 mod 100 resulta em 34
Ao efetuarmos 34 div 10
Temos 3
Portanto, a proposta A está correta.
B) Alternativa incorreta.
Justificativa: essa proposta apresenta o algarismo das centenas, conforme demonstrado a seguir.
algoritmo “Placacarro”
// Seção de Declarações
Var
 a,d :inteiro
inicio
// Seção de Comandos
 escreva(“Entre com o numero de 4 dígitos”)
 leia(a)
 d<-a mod 1000 div 100
 escreva(“O algarismo das dezenas é “,d)
fimalgoritmo
a d Tela
1234
2
Entre com o número de 4 dígitos
O algarismo das dezenas é 3
Figura 24
O coração do algoritmo é o cálculo d<-a mod 100 div 10
Assim:
1234 mod 1000 resulta em 234
Ao efetuarmos 234 div 100
54
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Temos 2
Portanto, a proposta B está incorreta, pois mostra o algarismo das centenas.
C) Alternativa incorreta.
Justificativa: essa proposta apresenta o algarismo dos milhares, conforme demonstrado a seguir.
algoritmo “Placacarro”
// Seção de Declarações
Var
 a,d :inteiro
inicio
// Seção de Comandos
 escreva(“Entre com o numero de 4 dígitos”)
 leia(a)
 d<-a div 1000
 escreva(“O algarismo das dezenas é “,d)
fimalgoritmo
a D Tela
1234
3
Entre com o número de 4 dígitos
O algarismo das dezenas é 3
Figura 25
O coração do algoritmo é o cálculo d<-a mod 100 div 10
Assim:
1234 div 1000 resulta em 1
Portanto, a proposta C está incorreta, pois mostra o algarismo dos milhares. 
D) Alternativa incorreta.
Justificativa: conforme demonstrado nas justificativas anteriores.
E) Alternativa incorreta.
Justificativa: conforme demonstrado nas justificativas anteriores.
55
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Questão 2. Com relação aos pseudocódigos a seguir, faça o teste de mesa.
Proposta A algoritmo “Exercício”
var
 a,b,c,d:inteiro
 resultado:logico
inicio
 a<-1
 b<-2
 c<-3
 d<-4
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
fimalgoritmo
Proposta B algoritmo “Exercício”
var
 a,b,c,d:inteiro
 resultado:logico
inicio
 a<-1
 b<-40
 c<-30
 d<-4
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
fimalgoritmo
Proposta C algoritmo “Exercício”
var
 a,b,c,d:inteiro
 resultado:logico
inicio
 a<-40
 b<-1
 c<-30
 d<-4
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
fimalgoritmo
Assinale a alternativa correta:
A) Somente na proposta A a variável resultado chega ao final do programa com o valor Verdadeiro.
B) Somente na proposta B a variável resultado chega ao final do programa com o valor Verdadeiro.
C) Somente na proposta C a variável resultado chega ao final do programa com o valor Verdadeiro.
D) Em mais de uma proposta a variável resultado chega ao final do programa com o valor Verdadeiro.
E) Em todas as propostas a variável resultado chega ao final do programa com o valor Falso.
56
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
Resposta correta: alternativa C.
Análise das alternativas
Conforme o enunciado do programa pede, é necessário fazer o teste de mesa das três propostas.
A) Alternativa incorreta.
Justificativa: na proposta A, temos:
algoritmo “Exercício”
var
 a,b,c,d:inteiro
 resultado:logico
inicio
 a<-1
 b<-2
 c<-3
 d<-4
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
fimalgoritmo
a b c d resultado Tela
1 2 3 4
F
Entre com o número de 
4 dígitos
O algarismo das 
dezenas é 3
Figura 26
O coração do algoritmo é o cálculo:
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
(1>2)e(1>3)ou((1+4*2)<(4-3*4))
 F e F ou (1+ 8) <(4- 12)
 F ou (9) < (8)
 F ou F
 F
B) Alternativa incorreta.
Justificativa: na proposta B, temos:
algoritmo “Exercício”
var
57
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 a,b,c,d:inteiro
 resultado:logico
inicio
 a<-1
 b<-40
 c<-30
 d<-4
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
fimalgoritmo
a b c d resultado Tela
1 40 30 4
F
Entre com o número de 
4 dígitos
O algarismo das 
dezenas é 3
Figura 27
Efetuando:
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
(1>40)e(1>30)ou((1+4*40)<(4-30*4))
 F e F ou (1+ 160)<(4- 120)
 F ou (161) < (-118)
 F ou F
 F
C) Alternativa correta.
Justificativa: uma vez feitos os testes de mesa, somente na proposta C a variável resultado termina 
com o valor Verdadeiro.
algoritmo “Exercício”
var
 a,b,c,d:inteiro
 resultado:logico
inicio
 a<-40
 b<-1
 c<-30
 d<-4
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
fimalgoritmo
58
Re
vi
sã
o:
 Ju
liana
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade I
a b c d resultado Tela
40 1 30 4
V
Entre com o número de 
4 dígitos
O algarismo das 
dezenas é 3
Figura 28
Efetuando:
 resultado<-(a>b)e(a>c)ou((a+d*b)<(d-c*4))
(40>1)e(40>30)ou((40+4*1)<(4-30*4))
 V e V ou (40+4) <(4- 120)
 V ou (161) < (-118)
 V ou F
 V
D) Alternativa incorreta.
Justificativa: conforme demonstrado nas justificativas anteriores.
E) Alternativa incorreta.
Justificativa: conforme demonstrado nas justificativas anteriores.
59
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Unidade II
A aplicação dos conceitos será feita utilizando a linguagem C++ padrão. Deve ficar claro que este 
não é um curso de linguagem C ou C++, portanto apenas os comandos e as técnicas que são aplicáveis à 
disciplina de Linguagem e Técnicas de Programação serão explicadas. Outras linguagens mais modernas, 
como Java, PHP ou mesmo o Interface Definition Language (IDL) do Common Object Request Broker 
Architecture (CORBA), usado em sistemas distribuídos, têm como base a linguagem C++. Portanto, esta 
será usada para mostrar como traduzir o pseudocódigo para uma linguagem de programação, e, na 
parte final da disciplina, as estruturas serão explicadas usando a própria linguagem C++.
2 Introdução à lInguagem C
A linguagem C pertence a uma família de linguagens cujas características são: portabilidade, 
modularidade, compilação separada, recursos de baixo nível, geração de código eficiente, confiabilidade, 
regularidade, simplicidade e facilidade de uso.
Essa linguagem é adequada para a programação estruturada, tendo aplicação, principalmente, no 
desenvolvimento de sistemas operacionais, planilhas eletrônicas e gerenciadores de bancos de dados 
(HICKSON, 2005). Assim, o programa usado para processar o texto deste livro foi escrito em linguagem C.
A linguagem C é considerada de médio nível. Não é uma linguagem de máquina que só os sistemas 
operacionais reconhecem, as chamadas de baixo nível, como o Assembly, nem de alto nível, em que a 
própria linguagem fornece todos os recursos para o desenvolvimento do programa, como o Visual Basic. 
Pertence à classe dos programas compilados, que são escritos em texto e passam por traduções para 
adequar-se ao sistema operacional.
Segundo Cocian (2004), os pontos positivos que tornaram a linguagem C popular são:
•	 a	portabilidade	do	compilador,	pois	existem	compiladores	para	todos	os	sistemas	operacionais;
•	 o	conceito	de	bibliotecas	padronizadas;
•	 a	quantidade	e	a	variedade	de	operadores	poderosos;
•	 a	sintaxe	elegante;
•	 o	fácil	acesso	ao	hardware,	quando	necessário;
•	 a	 facilidade	 com	 que	 as	 aplicações	 podem	 ser	 otimizadas,	 tanto	 na	 codificação	 quanto	 na	
depuração, pelo uso de rotinas isoladas e encapsuladas.
60
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
2.1 Histórico
No final da década de 1960, uma linguagem chamada Basic Combined Programming Language 
(BCPL) – Linguagem de Programação Básica Combinada, desenvolvida por Martin Richards, da 
Universidade	de	Cambridge,	em	1966	(POLLONI;	PERES;	FEDELI,	2009),	serviu	de	base	para	a	Linguagem	
B, desenvolvida por Ken Thompson para o computador PDP 7 e que funcionava no sistema operacional 
Unix. A linguagem B, em razão de problemas de velocidade e processamento, viria a ser corrigida na 
linguagem C (COCIAN, 2004), desenvolvida na Bell Laboratory por Dennis Ritchie, em 1972, e liberada 
para as universidades.
O fato de ser liberada para as universidades tornou essa linguagem popular, e havia diversos 
compiladores para os vários sistemas operacionais e computadores. Esse fato mostrou a necessidade de 
se padronizar a linguagem, o que aconteceu em 1983, quando a American National Standards Institute 
(ANSI) – correspondente à ABNT, no Brasil – estabeleceu esse padrão. Com o avanço do paradigma de 
programação orientada a objeto, foi desenvolvido o C++.
 observação
Como a linguagem C++ engloba totalmente a linguagem C e os recursos 
para esta disciplina são bem simples, a referência à linguagem C será válida 
para a linguagem C++.
 Saiba mais
Caso haja a necessidade de consultar a normatização da linguagem C, 
basta consultar o ISO/IEC (2014). Apesar de extremamente técnico, pode 
ajudar na implantação de uma linguagem de programação em novos 
dispositivos físicos. Acesse:
ISO/IEC. JTC1/SC22/WG21: The C++ Standards Committee. Open 
Standards, 4 mar. 2014. Disponível em: <http://www.open-std.org/jtc1/
sc22/wg21/>. Acesso em: 28 maio 2014.
2.2 regras da linguagem
Como toda linguagem de programação, a linguagem C é muito rígida na sua sintaxe. Sintaxe são 
regras detalhadas para que um programa possa ser executado.
As regras estão relacionadas com os tópicos a seguir:
•	 tipos:	definem	as	propriedades	dos	dados	manipulados	em	um	programa;
61
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 declarações:	definem	o	identificador, para alocar memória, definir conteúdo inicial e determinar 
funções;
•	 expressões:	fórmulas	que	atribuem	e	alteram	valores,	bem	como	fazem	chamada	de	funções	de	
entrada	e	saída;
•	 funções:	são	os	subprogramas	em	C,	que,	por	sua	vez,	são	chamados	por	outras	funções	executando	
tarefas específicas. Há funções básicas que estão definidas nas bibliotecas-padrão da linguagem, 
e outras que são desenvolvidas por terceiros, com rotinas mais específicas. As funções printf() 
e scanf(), por exemplo, que veremos ainda nesta unidade, as quais permitem, respectivamente, 
escrever na tela e ler os dados a partir do teclado, fazem parte da biblioteca básica. O programador 
também pode escrever as suas próprias funções, como veremos adiante.
A primeira função que o programa executa é o main(), portanto é obrigatória a sua declaração no 
programa principal.
Outras regras importantíssimas:
•	 A	linguagem	é	case sensitive;	 isso	quer	dizer	que	as	letras	maiúsculas	são	diferentes	das	letras	
minúsculas, na identificação de comandos, variáveis e funções.
Quadro 14 – A linguagem C é case sensitive
Abacaxi ≠ abacaxi
•	 Os	comandos	são	separados	por	ponto	e	vírgula	 (“;”),	que	deve	ser	usado	com	muito	cuidado,	
principalmente, antes de blocos de comandos.
 observação
O compilador ignora as quebras de linha, portanto os comandos 
escritos em linhas diferentes, mas separados apenas por esse recurso, para 
o compilador, estão na mesma linha.
Comando 1 = abcdefgh
Comando 2 = ijk
Comando 3 = lmn
abc
defgh; ijk;
lmn;
Figura	29	–	Para	o	compilador,	a	separação	dos	comandos	é	feita	pelo	‘;’
62
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
•	 A	linguagem	também	permite	o	uso	de	comentários,	que	são	colocados	no	texto	entre	“/*”	e	“*/”,	
quando	se	quer	escrever	mais	de	uma	 linha.	O	uso	do	“//”	 também	serve	como	comentário,	e,	
neste caso, o compilador ignorará tudo o que estiver escrito a partir dele até o fim da linha.
Comando 1 = abcdefgh
Comando 2 = mn
abc
defgh; / *ijk;
1*/mn; //opqrs
Figura	30 – O compilador ignora os comentários
•	 Pela	 definição	 padronizada	 pela	 ANSI,	 existem	 32	 palavras-chave	 (ou	 palavras	 reservadas)	
que formam a linguagem de programação C. Conforme o compilador, poderão existir mais 
palavras-chave, todas escritas em letras minúsculas.Nenhuma das palavras-chave poderá ser 
utilizada para dar nomes a variáveis e funções, pois isso gerará erro ao compilar.
Quadro 15 – Palavras reservadas pelo padrão ANSI
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Fonte:	Hickson	(2005,	p.	28).
•	 Os	identificadores	são	nomes	usados	para	se	fazer	referência	a	variáveis,	funções,	rótulos	e	vários	
outros objetos definidos pelo programador. Como norma, conforme vimos no pseudocódigo, o 
primeiro caractere deve ser uma letra ou um sublinhado, e o restante podem ser números, letras 
ou	sublinhado;	apenas	os	32	primeiros	caracteres	de	um	identificador	são	significativos.	Como	já	
foi dito, a linguagem C é case sensitive, ou seja, as letras maiúsculas diferem das minúsculas.
 lembrete
Sintaxe são regras detalhadas para que um programa possa ser 
executado.
63
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
2.2.1 Estrutura de um programa em C
Para programar em C partindo do zero, ou seja, de um texto totalmente vazio, é necessário apenas 
o bloco da função main(). Como há a necessidade de interações, é preciso colocar as bibliotecas no 
programa, e isso é feito em primeiro lugar.
Para termos uma ideia mais clara da estrutura, vamos elaborar o primeiro programa e compreender 
cada uma das linhas.
#include <stdio.h>
/*
Meu primeiro programa em C
*/
void main()
{
 printf(“meu primeiro programa em C\n”);
}
Ao	 executar	 o	 programa,	 teremos	 uma	 mensagem	 no	 console	 do	 DOS	 dizendo	 “Meu	 primeiro	
programa	em	C”.	Apesar	de	ser	um	programa	muito	simples,	temos	a	estrutura	mínima	de	um	programa	
nessa linguagem. Vamos analisar cada parte dessa estrutura a seguir:
#include <stdio.h>
O comando include informa ao compilador que ele deve incluir o arquivo-cabeçalho stdio.h. Nesse 
arquivo-cabeçalho há uma série de funções de entrada e saída úteis. Sempre que quiser usar funções 
relativas a entrada e saída, verifique se o arquivo stdio.h as contém. A linguagem C fornece dezenas 
de arquivos-cabeçalhos com milhares de funções úteis. Podemos chamar os arquivos-cabeçalhos de 
bibliotecas.
 observação
O compilador, ao encontrar o comando #include, antes de iniciar 
o processo de compilação, adiciona a listagem da biblioteca à escrita 
pelo programador, formando uma só listagem, e só então o programa é 
compilado.
/*
Meu primeiro programa em C
*/
64
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
 lembrete
Conforme vimos anteriormente, o compilador ignora os comentários.
void main()
Define o nome da função main. Todo programa em C precisa ter essa função, pois esta é premissa 
de funcionamento e é a função que o programa executa ao ser inicializado. A palavra void indica que a 
função não retorna valor, conforme veremos mais adiante.
{
Indica o início do bloco do programa principal, o ponto em que o processamento começará.
 printf(“meu primeiro programa em C\n”);
Função	que	mostra	na	tela	uma	informação	desejada.	Está	contida	no	arquivo-cabeçalho	stdio.h, e 
é por isso que este foi incluso no programa. Corresponde ao escreva do pseudocódigo.
}
Fecha	o	bloco	da	função	main(),	encerrando	o	programa.
O programa corresponde ao pseudocódigo:
algoritmo “PrimeiroPrograma”
//
// Meu primeiro programa em C
// Seção de Declarações
inicio
 escreva(“Meu primeiro programa em C”)
fimalgoritmo
2.3 tipos de informações, variáveis e constantes
Em pseudocódigo, vimos os tipos primitivos de dados: Inteiro, Real, Caractere e Lógico. Na linguagem 
C, os tipos primitivos sofreram modificações, visando aumentar a precisão ou adaptar a compatibilidade. 
A correspondência dos tipos está no Quadro 16.
65
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Quadro 16 – Correspondência dos tipos primitivos de dados
Pseudocódigo C
Inteiro Int
Real float ou Double
Caractere Char
Lógico bool (a partir do C++)
O nome da variável segue a nomenclatura das variáveis que vimos anteriormente nos pseudocódigos. 
O primeiro dígito deverá ser uma letra ou o caractere sublinhado, e o restante poderá ser letra, número 
ou o próprio sublinhado. O ANSI C não determina um limite no tamanho do nome, mas apenas os 32 
primeiros dígitos é que são significativos.
A sintaxe da declaração de uma variável será:
<Tipo de dado> <lista_de_nomes_de_variaveis> ;
Para declarar uma constante, acrescenta-se a palavra-chave const no início e atribui-se um valor a ela.
Sintaxe:
 const <Tipo de dado> <nome_da_variavel> = valor;
A tradução do pseudocódigo ficará assim:
algoritmo “declaracao”
const
 pi<-3.14159
var
 idade:inteiro
 saldo:real
 sexo:caracter
 matriculado:logico
inicio
// Seção de Comandos 
fimalgoritmo
void main () {
 const pi = 3.14159;
 int idade;
 double saldo;
 char sexo;
 bool matriculado;
// Seção de Comandos 
}
A linguagem permite também atribuir valor no momento da declaração da variável, assim como 
declarar muitas variáveis do mesmo tipo na mesma linha, ou realizar ambas as ações.
Exemplo:
int a; /* declara uma variável do tipo int */
float a; /* declara uma variável do tipo float */
66
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
int a = 5; /* cria e armazena o valor 5 em a */
int a,b,c; /* declara várias variáveis do tipo int */
int a,b=6,c; /* declara várias variáveis do tipo int 
atribuindo valor*/
Além dos tipos primitivos, temos modificações destes, e a faixa de números que são utilizáveis é 
determinada pelo número de bits de cada tipo modificado. Podemos ver essa precisão e a faixa numérica 
na Tabela 5.
Tabela 5 – Tipos primitivos com os modificadores
Tipo Nº de bits IntervaloValor inicial Valor final
Char 8 -128 127
Unsigned char 8 0 255
Signed char 8 -128 127
Int 16 -32,768 32,767
Unsigned int 16 0 65,535
Signed int 16 -32,768 32,767
Short 1nt 16 -32,768 32,767
Unsigned short int 16 0 65,535
Signed short int 16 -32,768 32,767
Long int 32 -2.147.483.648 2.147.483.647
Signed long int 32 -2.147.483.648 2.147.483.647
Unsigned long int 32 0 4.294.967.295
Float 32 3,4E-38 3,4E+38
Double 64 1.7 E-308 1.7 E308
Long Double 80 3.4E-4932 3.4E+4932
Fonte:	Hickson	(2005,	p.	30).
Conforme podemos ver, os tipos lógicos e as cadeias de caracteres não constam da tabela. Para esses 
tipos, a linguagem C tem um tratamento específico.
•	 Tipo	lógico:	a	linguagem	C	trata	como	verdadeiro	(true) o valor inteiro 1 e como falso (false) o 
valor	inteiro	0;	assim,	a	ausência	do	tipo	lógico	é	compensada	pelo	correspondente	numérico.	Na	
versão C++, a linguagem passa a incorporar o tipo bool.
Exemplo de aplicação
Para contornar a ausência do tipo lógico na linguagem C, são utilizados artifícios como o do código 
a seguir.
enum boolean {
67
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 true = 1, false = 0
};
// Permitindo a sua declaração como um tipo qualquer:
typedef enum boolean bool;
void main () {
 bool b = true;
 if (b) {
 b = false;
 }
}
•	 Tipos	caractere	e	cadeia:	a	 linguagem	C	não	trata	os	caracteres	como	tipos	 literais,	mas	como	
números. Assim, o tipo char, como podemosver na Tabela 5, usa 8 bits ou um byte, armazenando, 
portanto, um número cujo valor máximo é 255. Cada caractere tem um correspondente numérico, 
obedecendo a uma tabela. Normalmente, obedece à chamada Tabela ASCII (American Standard 
Code for Information Interchange – Código-Padrão Americano para o Intercâmbio de Informação). 
Podemos ver o padrão na Tabela 6.
Tabela 6 – Tabela ASCII
 0 1 2 3 4 5 6 7 8 9
30 branco ! “ # $ % & !
40 ( ) * + , - . / 0 1
50 2 3 4 5 6 7 8 9 ;
60 < = > ? @ A B C D E
70 F G H I J K L M N O
80 P Q R S T U V W X Y
90 Z [ \ ] A _ ` a b c
100 d E F G h i j k l m
110 n O P Q r S t u v w
120 x Y Z { | } ~ 
Fonte:	UFPA	(2013).
Conforme	essa	tabela,	ao	armazenarmos	a	letra	‘A’	em	uma	variável	do	tipo	char, o conteúdo será o 
número 65.
O armazenamento de cadeias de caracteres é feito em um conjunto de variáveis homogêneas 
(vetores) do tipo char. A principal característica é que existe um dígito que indica o final da cadeia, 
utilizando,	obrigatoriamente,	o	caractere	nulo	(‘\0’).	Assim,	caso	saibamos	quantos	dígitos	uma	variável	
do tipo cadeia irá armazenar, é necessário declarar mais um dígito, para o controle.
68
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
Exemplo de aplicação
Para armazenarmos quatro caracteres, devemos alocar cinco espaços.
char escola [5];
escola[0] = ‘U’;
escola[1] = ‘n’;
escola[2] = ‘i’;
escola[3] = ‘p’;
escola[4] = ‘\0’
Quando o tamanho for indefinido, será necessário colocar a indicação de fim de caractere.
 char escola[] = {‘U’, ‘n’, ‘i’, ‘p’, ‘\0’}; 
•	 Constantes	de	barra	invertida:	o	C	possui	algumas	constantes	para	facilitar	a	exibição	de	resultados	
na tela, a manipulação de cadeias ou a impressão. São caracteres que podem ser usados como 
quaisquer outros. A lista completa dos códigos de barra invertida é dada no Quadro 17.
Quadro 17 – Códigos de barra invertida
Código Significado 
\b Retrocesso (back) 
\f Alimentação de formulário (form feed) 
\n Nova linha (new line) 
\r Retorno de carro (carriage return) 
\t Tabulação horizontal (tab) 
\” Aspas 
\’ Apóstrofo 
\0 Nulo (0 em decimal) 
\\ Barra invertida 
\v Tabulação vertical 
\a Sinal sonoro (beep) 
\N Constante octal (N é o valor da constante) 
\xN Constante hexadecimal (N é o valor da constante)
Fonte:	Hickson	(2005,	p.	19).
2.4 operadores
A correspondência entre o pseudocódigo e a linguagem C, dos operadores matemáticos, é mostrada 
na Tabela 7.
69
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Tabela 7 – Correspondência entre operadores matemáticos
Pseudocódigo C Exemplo em pseudocódigo Exemplo em C
<- = A<-7 A=7;
+ + A<-3+5 A=3+5;
- - A<-3-5 A=3-5;
* * A<-3*5 A=3*5;
/ / A<-3/5 A=3.0/5;
DIV / entre operandos inteiros A<-3 div 5 A=3/5;
MOD % A<-7 mod 5 A=7 % 5;
** pow() da biblioteca math.h A<-4 ** 2 A=pow(4,2);
A linguagem C tem, ainda, algumas sintaxes específicas não presentes nos pseudocódigos.
•	 Atribuição	múltipla:	 nesse	 caso,	 o	 número	 cinco	 é	 atribuído,	 inicialmente,	 à	 variável	 x,	 e,	 em	
seguida, o conteúdo da variável x (número cinco) é atribuído à variável y.
y = x = 5;
•	 Operadores	de	 incremento	e	decremento:	autoincremento	ou	decremento	 são	operadores	não	
convencionais que atuam sobre a própria variável, aumentando ou diminuindo uma unidade. A 
sintaxe é:
<variável>++
ou
++<variável>
Exemplo de aplicação
 int a=5;
 a++;
Corresponde a:
 int a=5;
 a=a+1;;
A variável a, ao executar a operação a++, incrementa em uma unidade o valor guardado. As 
operações a++ ou ++a têm o mesmo resultado, porém o mecanismo do processamento trabalha de 
forma diferente.
Vamos supor que a variável a armazene o valor 5.
x = a++;
70
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
Esse código atribui 5 a x, trabalhando da seguinte forma: o conteúdo de a é atribuído a x e depois é 
feito o incremento. Contudo, veja outro caso:
x = ++a;
Nesse exemplo, atribuímos 6 a x, pois é feito o incremento na variável a, e depois o resultado é 
atribuído a x.
No final, ambos passam a valer 6, pois seu valor foi incrementado em uma unidade, mas o valor final 
de x é diferente em cada um dos casos.
Para entender melhor, veja a comparação a seguir.
Tabela 8 – Exemplo de comparação
A expressão Equivale a
b = a++ b = aa = a + 1
b = ++a a = a + 1b = a
Os	operadores	de	incremento	e	decremento	podem	ser	aplicados	somente	a	variáveis;	uma	expressão	
do tipo x = (i + 1)++ é ilegal.
•	 Operadores	 de	 atribuição:	 os	 operadores	 de	 atribuição	 (Tabela	 9)	 resultam	na	 substituição	 do	
conteúdo do termo à esquerda da expressão. Com exceção da igualdade, todos os operadores 
resultam em formas similares de execução.
Tabela 9 – Operadores unários
Operador Exemplo Pseudocódigo Ação
+= a+=b a<-a+b a recebe o resultado da soma de a com b
-= a-=b a<-a-b a recebe o resultado da subtração de a com b
*= a*=b a<-a*b a recebe o resultado da multiplicação de a com b
/= a/=b a<-a/b a recebe o resultado da divisão de a com b
%= a%=b a<-a%b a recebe o resto da divisão de a com b
Operador relacional: todos os operadores de comparação (Tabela 10) dos pseudocódigos têm o seu 
equivalente na linguagem C.
71
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Tabela 10 – Operadores relacionais em C
Pseudocódigo C Exemplo Exemplo em C
= == A=B A==B
> > A>B A>B
< < A<B A<B
>= >= A>=B A>=B
<= <= A<=B A<=B
<> != A<>B A!=B
Conforme a tabela anterior, a atenção deve ser dada aos operadores de igualdade e diferença que 
podem levar ao engano no processo de transcrição.
•	 Operador	lógico:	a	transcrição	dos	operadores	lógicos	requer	um	cuidado	especial,	pois	a	sintaxe	
é significativamente diferente (Tabela 11).
Tabela 11 – Operadores lógicos em C
Pseudocódigo C Exemplo Exemplo em C
E && A e B A && B
OU || A ou B A||B
Não ! Não A !A
•	 Conversão	de	tipo	(cast): o que acontece quando ocorre a divisão entre duas variáveis numéricas 
de tipos diferentes? Na linguagem C, ocorre uma avaliação automática da expressão, ajustando, 
antes, o resultado para o tipo de maior precisão. Assim, se dividirmos uma variável inteira com 
o número 5 por uma variável double com o valor 2,5, o programa converterá a primeira variável 
para double e realizará o cálculo, devolvendo um valor double.
Alguns compiladores não permitem a atribuição de tipos de dados diferentes. Para evitar essas 
incompatibilidades, a linguagem tem um modelador de tipo. Esse modelador se chama cast. O uso 
do cast consiste em colocar o novo tipo entre parênteses.
Exemplo de aplicação
Vejamos as seguintes situações:
int a; 
a = 3.5; 
Alguns compiladores irão gerar um aviso de incompatibilidade de tipo. Para evitar esse aviso, deve-se 
usar o cast.
72
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
int a; 
a = (int) 3.5;
A situação seguinte resulta em erro.
int a; 
a = 3.5 % 2;
Nesse caso, a operação mod (%) requer dois operandos inteiros, e, no caso, 3,5 não é inteiro. Nessa 
situação, o programa não será compilado. Para corrigir, será necessário utilizar o cast.
int a; 
a = (int) 3.5 % 2;
•	 Precedência	 na	 ordem	 de	 avaliação	 dos	 operadores:	 a	 precedência	 na	 ordem	 das	 operações	
obedece à mesma sequência vista no pseudocódigo,exceto pelos operadores característicos da 
linguagem C a seguir, que precedem a sequência já aprendida:
! ++ -- - (cast)
 lembrete
Na linguagem C, a operação de atribuição é =, e a de relacionamento 
é ==. Assim como em algoritmo, os operadores são diferenciados: ← para 
atribuição e = para relacionamentos.
2.5 entrada e saída de informações
A linguagem C não possui comandos de entrada e saída. Esses comandos são feitos por meio de 
funções. Para utilizar tais funções, existe uma biblioteca-padrão, o stdio.h, cujo nome é um mnemônico 
de Standard Input Output. A inclusão da biblioteca é feita no início do programa, por meio da instrução:
#include <stdio.h>
•	 Saída:	 a	 função	 que	 executa	 a	 visualização	 de	 informações	 pela	 tela	 é	 o	 printf,	 segundo	 um	
determinado formato. A sintaxe da função é:
printf(“ formato “,lista de variáveis/expressões)
A função é formada por duas partes. A primeira parte determina o formato da saída. Para cada 
valor contido em uma variável deve existir um especificador do formato de saída. As variáveis ficam 
listadas na segunda parte dos parâmetros da função. Os especificadores de formato determinam o 
73
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
tipo e a precisão dos valores que queremos mostrar na tela. Esses especificadores são precedidos do 
caractere % (Quadro 18).
Quadro 18 – Especificadores de formato
Especificador Característica
%c Especifica um char
%d Especifica um int
%u Especifica um unsigned int
%f Especifica um double (ou float)
%e Especifica um double (ou float) no formato científico
%g Especifica um double (ou float) no formato mais apropriado (%f ou %e)
%s Especifica uma cadeia de caracteres
Fonte:	Hickson	(2005,	p.	19).
Exemplo de aplicação
Considere este código:
#include <stdio.h>
void main(){
 printf (“%d %f\n”, 34, 5.6);
}
Ao ser executado, o programa resultará na seguinte saída:
Figura	31 – Saída formatada
Além dos especificadores, podemos incluir textos no formato, que são apresentados na saída junto 
com os dados. Essa saída é formada pela cadeia de caracteres do formato, em que os especificadores são 
substituídos pelos valores contidos nas variáveis correspondentes.
Exemplo de aplicação
Ao executar:
#include <stdio.h>
void main(){
74
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
 printf (“Inteiro = %d Real = %g\n”, 34, 5.6);
}
Resultará em:
Figura	32 – Saída formatada
Também é possível colocar os constantes de barra invertida na definição do formato.
No formato é possível, ainda, determinar a precisão e o tamanho dos campos em que os valores são 
mostrados.
Exemplo de aplicação
Considere o programa a seguir:
#include <stdio.h>
void main(){
 printf (“|%4d| |%7.2f|\n”, 34, 5.6);
}
Esse programa apresenta o seguinte resultado:
Figura	33 –Saída formatada
Os	caracteres	“|”	mostram	o	limite	dos	campos.
Alterando o programa:
#include <stdio.h>
void main(){
 printf (“|%10d| |%10.3f|\n”, 34, 5.6);
}
75
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Teremos a seguinte saída:
Figura	34 – Saída formatada
Notamos que o espaço ocupado pelo 34 ficou mais largo, e o ocupado pelo 5.6, além de estar mais 
largo, tem um zero a mais.
Para entender:
Figura	35 – Dimensionamento dos especificadores de formato
Nos	inteiros,	o	número	que	fica	entre	o	sinal	de	%	e	o	“d”	determina	a	quantidade	de	dígitos	que	
o valor ocupará. Na formatação de ponto flutuante, o número antes do ponto determina o total de 
dígitos, e o número depois da vírgula, a quantidade de dígitos após a vírgula. Note que a vírgula conta 
um dígito.
 lembrete
O nome da biblioteca-padrão de entrada e saída é stdio.h (standart 
input/output). Uma falha muito comum é usar a grafia incorreta studio.h, 
causando erro de compilação.
76
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
Exemplo de aplicação
Traduzir o seguinte pseudocódigo:
algoritmo “media”
var
 nota1,nota2,media:real
inicio
 nota1<-8
 nota2<-10
 media<-(nota1+nota2)/2
 escreva(“A media entre “,nota1,” e “,nota2, “ é “, media)
fimalgoritmo
Resolução:
#include <stdio.h>
void main(){
 double nota1,nota2,media;
 nota1=8;
 nota2=10;
 media=(nota1+nota2)/2;
 printf(“A media entre %4.1f e %4.1f é %4.1f\n”,nota1,nota2,media);
}
Resultando em:
Figura	36 – Saída com os especificadores de formatação
•	 Entrada:	os	valores	digitados	no	teclado	são	capturados	pela	função	scanf,	que	também	pertence	
à biblioteca stdio.h. Assim como o printf tem duas partes, uma que determina o formato de leitura 
e a segunda variável, que irá receber o valor digitado. A sintaxe da função é:
scanf(“ formato “,&variável)
Os especificadores de tipos do formato são similares aos utilizados na função printf. A função scanf 
utiliza especificadores diferentes para o tipo float e o tipo double (Quadro 19).
77
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Quadro 19 – Relação dos especificadores de formato na entrada
Especificador Característica
%c Especifica um char
%d Especifica um int
%u Especifica um unsigned int
%f,%e,%g Especifica um float
%lf, %le, %lg Especifica um double
%s Especifica uma cadeia de caracteres
Fonte:	Hickson	(2005,	p.	14).
A diferença é que o formato deve ser seguido por uma lista de endereços de variáveis (na função 
printf, passamos os valores de constantes, variáveis e expressões). No tópico sobre ponteiros, esse 
assunto será tratado em detalhes. De maneira mais ampla, para o scanf ler um valor e atribuí-lo a uma 
variável, é necessário passar o endereço da variável que receberá o valor digitado. O operador & retorna 
o endereço de uma variável. Assim, para ler um inteiro, devemos ter:
 int i;
 scanf(“%d”,&i);
O formato também pode obrigar a digitar entrada dentro de um dado padrão. Por exemplo, para 
obrigar a entrada de dois números inteiros separados por dois-pontos, a sintaxe é:
scanf(“%d:%d”, &hora, &min);
Um espaço em branco dentro do formato faz que sejam ignorados eventuais brancos da entrada.
Exemplo de aplicação
Faça	a	tradução	para	a	linguagem	C	e	teste	com	as	notas	4.0	e	7.0:
algoritmo “media”
var
 nota1,nota2,media:real
inicio
 escreva(“entre com a nota1 e nota2:”)
 leia(nota1,nota2)
 media<-(nota1+nota2)/2
 escreva(“A media entre “,nota1,” e “,nota2, “ é “, media)
fimalgoritmo
Tradução:
#include <stdio.h>
78
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
void main(){
 double nota1,nota2,media;
 printf(“Entre com nota1 nota2: “);
 scanf(“%lf %lf”,&nota1,&nota2);
 media=(nota1+nota2)/2;
 printf(“A media entre %4.1f e %4.1f = %4.1f\n”,nota1,nota2,media);
{
Executando:
Figura	37 – Saída do programa com leitura em uma linha
 Saiba mais
Para os usuários do sistema operacional Linux, a linguagem C++ pode 
ser encontrada no site dos desenvolvedores, o GCC:
<http://gcc.gnu.org/>.
 resumo
A Unidade II foi uma introdução à linguagem C, que será utilizada para 
executar os nossos programas pensados em Portugol. Vimos como o C se 
encaixa nas diversas linguagens de programação eum pequeno histórico.
Como toda linguagem de programação, a linguagem C é muito rígida 
quanto à sua sintaxe. Aprendemos as regras que definem os tipos de 
dados, os nomes de variáveis, as expressões, as palavras reservadas que não 
devem ser utilizadas como nomes de variáveis, a separação de comandos e 
principalmente o fato de ser case sensitive, ou diferenciar a letra maiúscula 
da minúscula.
Vistas as regras, passamos a abordar o funcionamento do programa, a 
estrutura que comportará a programação e a biblioteca básica de entrada e 
79
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
saída. Vimos também os tipos principais, como são declarados e a tradução 
do pseudocódigo para a linguagem de programação.
Como a linguagem C precisa de uma biblioteca para facilitar a entrada 
e a saída, e como trata os caracteres de modo dúbio, por exemplo, número 
e	letra,	vimos	os	comandos	‘\’,	que	permitem	a	formatação	do	valor,	tanto	
na saída (printf) quanto na entrada (scanf).
Além das operações aritméticas tradicionais de soma, subtração, 
multiplicação,	divisão	e	resto	(+,-,	*,	/,	mod),	vimos	os	operadores	unários,	
como os de incremento, decremento, acúmulo de soma e multiplicação, 
e	 redução	 de	 subtração	 e	 divisão	 (++,	 -	 -.	 +=	 -=,/=.*=),	 bem	 como	 os	
operadores lógicos e, ou, não (&&	,	||,	~	).
Vimos também como podemos transformar um tipo em outro, o 
importante comando do cast.
 exercícios
Questão 1.	Assinale	a	alternativa	que	traz	a	forma	correta	de	escrever	“Meu	nome	é	Roberto, tenho 
23 anos e meu aniversário é em 02/01”,	em	que	os	destacados	são	variáveis:
A) #include<stdio.h>
void main(){
 printf(“Meu nome é %s tenho %s anos o meu aniversario 
é %02s/%d”,Roberto,23,2,1);
}
B) #include<stdio.h>
void main(){
 printf(“Meu nome é %s tenho %02d anos o meu aniversa-
rio é %02d/%d”,”Roberto”,23,2,1);
}
C) #include<stdio.h>
void main(){
 printf(“Meu nome é %s tenho %d anos o meu aniversario 
é %s/%s”,”Roberto”,23,”02”,”01”) ;
}
D) #include<stdio.h>
void main(){
 printf(“Meu nome é %s tenho %d anos o meu aniversario 
é %02s/%s”,”Roberto”,23,2,1) ;
}
80
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
E) #include<stdio.h>
void main(){
 printf(“Meu nome é %s tenho %2 anos o meu aniversario 
é %02s/%s”,Roberto,23,2,1);
}
Resposta correta: alternativa C.
Análise das alternativas
A) Alternativa incorreta.
Justificativa:
printf(“Meu nome é %s tenho %s anos o meu aniversario é 
%02s/%d”,Roberto,23,2,1)
O primeiro parâmetro é Roberto. Como não está entre aspas, o programa o trata como uma variável, 
e como não existe nenhuma variável declarada como Roberto, o programa sequer compila.
B) Alternativa incorreta.
Justificativa:
printf(“Meu nome é %s tenho %02d anos o meu aniversario é 
%02d/%d”,”Roberto”,23,2,1);
O primeiro parâmetro é uma string, e sua mascara é %s, portanto está correto.
O segundo parâmetro é o número 23, e a máscara é %02d, um número inteiro com espaço para dois 
caracteres, que também está correto.
O terceiro parâmetro é o número inteiro 2, e a máscara é %02d portanto mostra 02.
O quarto parâmetro é o número inteiro 1, e a máscara é %d, portanto mostra 1.
Assim, a saída fica:
Meu nome é Roberto tenho 23 anos o meu aniversario é 02/1
A saída da data é 02/1, e não 02/01, como pedido no enunciado.
81
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
C) Alternativa correta.
Justificativa:
printf(“Meu nome é %s tenho %d anos o meu aniversario é 
%s/%s”,”Roberto”,23,”02”,”01”)
O primeiro parâmetro é uma string, e sua máscara é %s, portanto está correto.
O segundo parâmetro é o número 23, e a máscara é %d, um número inteiro mostrando 23, que 
também está correto.
O terceiro parâmetro é uma string	“02”,	e	a	máscara	é	%s,	portanto	mostra	02.
O	quarto	parâmetro	é	uma	string	“01”,	e	a	máscara	é	%s	portanto	mostra	02.
Assim, a saída fica:
Meu nome é Roberto tenho 23 anos o meu aniversario é 02/01
A saída está como pedido no enunciado.
D) Alternativa incorreta.
Justificativa:
printf(“Meu nome é %s tenho %d anos o meu aniversario é 
%02s/%s”,”Roberto”,23,2,1)
O primeiro parâmetro é uma string, e sua mascara é %s, portanto está correto.
O segundo parâmetro é o número 23, e a máscara é %d, um número inteiro mostrando 23, que 
também está correto.
O terceiro parâmetro é uma string	“02”,	e	a	máscara	é	%s,	portanto	mostra	02.
O	quarto	parâmetro	é	um	inteiro	1,	e	a	máscara	é	%s;	portanto,	ao	executar	o	programa,	acusa	erro.
E) Alternativa incorreta.
Justificativa:
printf(“Meu nome é %s tenho %2 anos o meu aniversario é 
%02s/%s”,Roberto,23,2,1);
82
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
Como	na	alternativa	A,	o	primeiro	parâmetro	é	Roberto;	como	não	está	entre	aspas,	o	programa	o	
trata como uma variável.
Questão 2. Dado o seguinte programa:
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
Qual a saída quando ele é executado?
A)
B)
C)
D)
E)
83
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Resposta correta: alternativa E.
Análise das alternativas
Justificativa geral: fazendo o teste de mesa:
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
a tela
5
Figura	38 
Criando e atribuindo a variável a:
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
a b tela
5
Figura	39 
Criando a variável b:
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
a b tela
5
6
6
Figura	40 
84
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade II
Como b = ++a é
a = a + 1
b = a
a fica com 6, e b fica com 6
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
a b tela
5 6 6 6
Figura	41 
Executando printf:
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
a b tela
5
6
7
6
6
6 6
Figura	42 
Como b = a++ é
b = a
a = a + 1
a fica com 7, e b fica com 6
85
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
#include <stdio.h>
void main()
{
 int a=5;
 int b;
 b=++a;
 printf(“%d %d\n”,a, b);
 b=a++;
 printf(“%d %d\n”,a, b);
}
a b tela
5
6
7
6
6
6 6
7 6
Figura	43 
Efetuando printf
Portanto, na tela, temos:
6 6
7 6
86
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Unidade III
3 Tomada de decisões
Na vida, tudo depende da tomada de decisões. Para tomarmos uma decisão, uma série de condições 
deverá ser avaliada, e, então, decidiremos se uma ação deveráou não ser realizada. A vida é repleta de 
tomadas de decisões: começar um namoro, estudar análise de sistemas, casar-se, pagar à vista, enfim, 
uma infinidade de situações necessita de uma análise anterior.
3.1 Teoria
Até agora, os programas foram executados em sequência, de cima para baixo, mas podem acontecer 
situações em que alguns comandos não sejam adequados e, por isso, não necessitem ser executados. 
Em outros casos, pode ser necessário optar por executar diferentes blocos de comandos, conforme a 
situação. Essas estruturas são chamadas de condicionais.
3.2 condicionais
As estruturas condicionais são utilizadas quando há a necessidade de tomar decisões, ou quando é 
preciso efetuar comparações.
Nesse tipo de estrutura, uma operação lógica (<condição>) é avaliada. Se o resultado dessa avaliação 
for verdadeiro (V), então um determinado conjunto de instruções será executado. Se o resultado da 
avaliação for falso (F), um comando diferente será executado.
3.2.1 Se então
A primeira situação é quando uma condição é testada e, caso seja verdadeira, um bloco de comando 
é executado. Essa estrutura se chama se então.
Sintaxe:
se <condição> então 
comando 1..... (neste caso a <condição> é verdadeira) 
fimse
Ao encontrar a condição se, o programa entende que virá uma expressão cujo resultado é lógico. 
Caso essa expressão resulte em Verdadeiro, é executado o bloco de comandos entre o então e o fimse. 
Caso a condição resulte em Falso, o bloco todo é ignorado, prosseguindo após o fimse.
87
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
A estrutura no fluxograma é representada da seguinte forma:
condição
<Condição> V
F
Figura 44 –Símbolo de condicional apenas com o então
Exemplo de aplicação
Faça um programa que leia um número e diga se é negativo.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 fimse
fimalgoritmo
O fluxograma ficará:
Início
Número
Número < 0
Negativo
Fim
Figura 45 – Programa para avisar se um número é negativo
88
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
3.2.1.1 Fazendo o teste de mesa
Simulando o papel do computador para duas possibilidades: inicialmente com a entrada 5 e depois 
com a entrada -5.
Primeiro, um espaço de memória é inicializado para o programa “negativo”.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
Figura 46 – Espaço de memória do programa “negativo”
As variáveis são separadas na memória. No caso, apenas a variável inteira numero.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
Fimalgoritmo
89
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:Negativo
numero tela
Figura 47 – Espaço de memória mostrando a variável numero
A primeira linha do programa mostra, na tela, o parâmetro do comando de saída escreva, no caso, 
escreva um numero.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero tela
escreva um numero
Figura 48 – Memória com tela mostrando o parâmetro do 
comando de saída
A seguir, é dada a entrada do valor 5, para testar a entrada de um número positivo.
Ao ser dada a entrada, o valor é atribuído na variável numero. Assim, o conteúdo de numero 
fica 5.
algoritmo “negativo”
Var
 numero:inteiro
90
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero
5
tela
escreva um numero
5
Figura 49 – Memória com tela mostrando a atribuição do 
valor 5 à variável numero
O comando seguinte é o que estamos estudando. Ao encontrar o se, o programa avaliará se a 
operação seguinte resultará em Verdadeiro. No caso, a operação numero<0 resulta em Falso; assim, o 
fluxo não executará as instruções contidas no bloco do então.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero
5
tela
escreva um numero
5
Figura 50 – Nesse caso, como a operação não resulta em 
Verdadeiro, as instruções no bloco do então não serão executadas
91
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
A seguir, o programa chega ao final, encerrando a simulação.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero tela
escreva um numero
5
Figura 51 – Fim da simulação
Como esperado, ao entrarmos com o valor positivo, o programa não mostra nenhum resultado, pois 
somente o fará se o valor for negativo.
A seguir, faremos o teste de mesa para a entrada -5. Como o processamento é o mesmo até a 
entrada do valor, iniciaremos a partir da linha da entrada desse valor (leia).
O valor -5 é digitado no teclado, e, ao aplicarmos a tecla do enter, a entrada será transferida para a 
variável numero.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
fimalgoritmo
92
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
Figura 52 – Atribuição do valor -5 à variável numero
Na condicional, o resultado de ‘numero<0’ é Verdadeiro, pois, como a variável contém -5, a 
comparação é -5<0, que é verdadeira. Como o resultado é Verdadeiro, o programa irá executar o bloco 
de comandos do então.
 Lembrete
Na comparação x<0, se o x valer 0, o resultado será falso; assim, o zero 
não será considerado negativo.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
fimalgoritmo
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
Figura 53 – Nesse caso, o bloco de comandos do então será 
executado, pois o resultado é Verdadeiro
No bloco do então há apenas um comando, no caso, a saída do texto “negativo”.
93
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimsefimalgoritmo
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
negativo
Figura 54 – Memória com tela mostrando o comando 
negativo no bloco do então 
A seguir, o programa é encerrado.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 Fimse
fimalgoritmo
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
negativo
Figura 55 – Fim do programa
94
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Assim, ao entrar com o valor -5, o programa mostra que o numero é negativo, indicando que a lógica 
do programa está de acordo com o proposto.
3.2.2 Se então senão
A segunda situação é quando uma condição é testada e, caso seja verdadeira, um bloco de comando 
é executado; e, caso seja falsa, um outro bloco de comando é executado. Essa estrutura se chama se 
então senão.
Sintaxe:
se <condição> então 
 comando 1..... (neste caso a <condição> é verdadeira) 
senão
 comando 2..... (neste caso a <condição> é falsa) 
fimse
O programa, ao encontrar a condição se, entende que virá uma expressão cujo resultado é lógico. 
Caso essa expressão resulte em Verdadeiro, é executado o bloco de comandos entre o então e o senão, 
passando a execução para o primeiro comando após o fimse. Caso a condição resulte em Falso, é 
executado o bloco entre o senão e o fimse.
A estrutura no fluxograma é representada da seguinte forma:
Comandos (V) Comandos (F)
<Condição>V F
Figura 56 – Fluxograma de decisão com então e senão
95
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Exemplo de aplicação
Faça um programa que leia um número e diga se é positivo ou negativo.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senão
 escreva(“ positivo “)
 fimse
fimalgoritmo
No fluxograma fica claro que, conforme o resultado do teste, o programa toma caminhos 
diferentes:
Início
Número
Número < 0 FV
Negativo Positivo
Fim
Figura 57 – Decisão com então e senão
96
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
3.2.2.1 Fazendo o teste de mesa
Simulando o papel do computador para duas possibilidades: inicialmente com a entrada 5 e depois 
com a entrada -5.
Primeiro, um espaço de memória é inicializado para o programa “negativo”.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
Figura 58 – Espaço de memória do programa negativo
As variáveis são separadas na memória. No caso, apenas a variável inteira numero.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
97
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:Negativo
numero tela
Figura 59 – Espaço de memória mostrando a variável numero
A primeira linha do programa apresenta, na tela, o parâmetro do comando de saída escreva, no caso, 
escreva um numero.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero tela
escreva um numero
Figura 60 – Memória com tela mostrando o parâmetro do 
comando de saída do programa
A seguir, é dada a entrada do valor 5, para testar a entrada de um número positivo.
Ao ser dada a entrada, o valor é atribuído na variável numero. Assim, o conteúdo de numero fica 5.
algoritmo “negativo”
Var
 numero:inteiro
98
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero
5
tela
escreva um numero
5
Figura 61 – Atribuição do valor 5 à variável numero
Ao encontrar o se, o programa avaliará se a operação seguinte resultará em Verdadeiro. No caso, 
a operação numero<0 resulta em Falso; assim, o fluxo executará as instruções contidas no bloco do 
senão.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero
5
tela
escreva um numero
5
Figura 62 – Como o resultado é Falso, serão executadas as 
instruções do bloco do senão 
99
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Executa-se o bloco do senão.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero
5
tela
escreva um numero
5
positivo
Figura 63 – Memória com tela mostrando o comando positivo 
no bloco do senão
A seguir, o programa chega ao final, encerrando a simulação.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
100
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria:Negativo
numero tela
escreva um numero
5
positivo
Figura 64 – Fim da simulação
Como esperado, ao entrar com o valor positivo, o programa mostra o resultado positivo, pois o bloco 
executado foi para a avaliação falsa no comando se.
A seguir, faremos o teste de mesa para a entrada -5. Como o processamento é o mesmo até a 
entrada do valor, iniciaremos a partir da linha da entrada do valor (leia).
O valor -5 é digitado no teclado, e, ao aplicarmos a tecla enter, a entrada é transferida para a variável 
numero.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
fimalgoritmo
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
Figura 65 – Atribuição do valor -5 à variável numero
Na condicional, o resultado de numero<0 é Verdadeiro, pois, como a variável contém -5, a comparação 
é -5<0, que é verdadeira. Como o resultado é Verdadeiro, o programa irá executar o bloco de comandos 
do então.
101
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
cio 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
fimalgoritmo
Memoria:Negativo
numero
-5
tela
escreva um 
numero
-5
Memoria: 
Negativo
Figura 66 – O bloco de comandos do então será executado, 
pois o resultado é Verdadeiro
No bloco do então há apenas um comando, no caso, a saída do texto negativo.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
fimalgoritmo
102
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
negativo
Figura 67 – Memória com tela mostrando o comando 
negativo, no bloco do então
A seguir, o programa é encerrado.
algoritmo “negativo”
Var
 numero:inteiro
Inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
Memoria:Negativo
numero
-5
tela
escreva um numero
-5 
negativo
Figura 68 – Encerramento do programa
Assim, ao entrar com o valor -5, o programa mostra que o numero é negativo, e ao entrar com o 
valor maior ou igual a zero, o programa mostra que o número é positivo, portanto a lógica do programa 
está de acordo com o proposto.
3.2.3 Estrutura condicional se aninhada
Num consultório médico, como se chega a um diagnóstico? O médico inicia fazendo uma série de 
perguntas; conforme a resposta, vai mudando o seu repertório de perguntas e, com base também nos 
exames, chega a uma decisão.
103
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Caso o paciente esteja com dor de cabeça, ele pergunta o tipo de dor. Caso seja na nuca, ele pede que o 
paciente abaixe a cabeça; se este não conseguir, o médico passará a suspeitar de meningite; caso consiga, passará 
a fazer outras perguntas. Caso a dor seja na região dos olhos, o médico suspeita de sinusite e passa a fazer 
outras perguntas. Assim, pelo aninhamento de uma série de condicionais, o médico chega a um diagnóstico.
Na programação, dentro de um bloco, os comandos (que, por enquanto, são executados entre o 
então e o senão, ou entre o senão e o fimse) podem ser quaisquer dos aprendidos até agora, inclusive, 
o próprio se.
O aninhamento das condicionais é muito comum e exige um nível maior de raciocínio, portanto uma 
lógica mais apurada no momento da programação.
Sintaxe:
se <condição> então
se <condição> então
se <condição> então
se <condição> então
.
.
.
Fimse
 senão
 .
 .
 fimse
 senão
 .
 .
 fimse
senão
se <condição> então
se <condição> então
 .
 .
 .
 fimse
 senão
 .
 .
 fimse
fimse
104
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
3.2.3.1 Os comandos se dentro de blocos de outros comandos se
Para ilustrar a estrutura do caso que foi apresentado no início, o do médico seria semelhante ao 
apresentado a seguir:
O paciente reclama de dor de cabeça
se dói a nuca então
se abaixa a cabeça então
se a boca está torta então
.
.
.
fimse
 senão
 .
 .
 fimse
 senão
 fazer exame de liquor.
 .
 .
 .
 fimse
senão
se dói a região dos olhos então
se já teve sinusite então
 .
 .
 .
 fimse
 senão
 .
 .
 fimse
fimse
Assim, a identação passa a ser fundamental para o entendimento do programa. A seguir, o mesmo 
código, desta vez, sem a identação:
O paciente reclama de dor de cabeça
se dói a nuca então
se abaixa a cabeça então
105
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
se a boca está torta então
.
.
.
fimse
senão
fimse
senão
fazer exame de liquor.
.
.
.
fimse
senão
se dói a região dos olhos então
se já teve sinusite então
.
.
.
fimse
senão
.
.
fimse
fimse
No caso de um fluxograma:
Condição
Condição Condição
CondiçãoCondiçãoCondição
Figura 69 – Fluxograma com condicionais aninhadas
106
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Exemplo de aplicação
Faça um programa que leia três números inteiros diferentes e mostre qual o maior.
algoritmo “o maior”
var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 fimse
fimalgoritmo
O fluxograma correspondente ao pseudocódigo será:
n1>n2
n1>n3 n2>n3
O maior 
é n1 O maior é n2
O maior 
é n3
O maior 
é n3
Início
Fim
n1, n2, n3
Figura 70 – Programa para encontrar o maior número, de três digitados
107
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Como para todo código é necessário fazer o teste de mesa, faremos os testes para todas as situações 
possíveis para n1, n2 e n3:
•	 n1	=	1,	n2	=	2	e	n3	=	3;
•	 n1	=	1,	n2	=	3	e	n3	=	2;
•	 n1	=	2,	n2	=	1	e	n3	=	3;
•	 n1	=	2,	n2	=	3	e	n3	=	1;
•	 n1	=	3,	n2	=	1	e	n3	=	2;
•	 n1	=	3,	n2	=	2	e	n3	=	1.
Iniciamos o teste com a memória do programa o maior limpa.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
Figura 71 – Início da memória do programa o maior
108
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
A seguir, criamos as variáveis na memória.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1 n2 n3 Tela
Figura 72 – Espaço de memória com as variáveis criadas
Com o processamento se iniciando, a primeira instrução é a leitura de n1, n2 e n3. No caso, como 
é o primeiro teste, o valor 1 é armazenado na variável n1, o valor 2, na n2, e o valor 3, na variável n3.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
109
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
árci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
Figura 73 – Atribuição de valores às variáveis
Em seguida é executado o comando condicional. Como o conteúdo de n1 (1) é menor que o 
conteúdo de n2 (2), a operação n1>n2 resulta em Falso, desviando o curso do programa para o senão 
correspondente ao se inicial.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
110
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
Figura 74 – Execução do comando condicional
Seguindo para o senão do primeiro se, acontece uma nova condicional. Como o conteúdo de n2 (2) 
é menor que o conteúdo de n3 (3), a operação n2>n3 resulta em Falso, desviando para o senão.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
Figura 75 – Execução do segundo comando condicional
No bloco que segue, é dada a saída do valor armazenado na variável n3, ou seja, o valor 3.
111
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
O valor maior 
e 3
Figura 76 – Saída do valor 3, armazenado na variável n3
Em seguida, o programa somente encontra finais de blocos, encerrando o processamento.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
112
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
O valor maior 
e 3
Figura 77 – Fim do processamento
Assim, ao encerrar o programa, foi mostrado o maior valor, conforme o proposto, porém o teste está 
incompleto, pois as sequências de entrada podem variar de acordo com o arranjo dos números digitados 
na entrada. Assim, são necessários outros testes.
Agora, fazendo o teste com n1 recebendo 1, n2 recebendo 3 e n3 recebendo 2, a entrada maior está 
na variável n2.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
1
n2
3
n3
2
Tela
1 3 2
Figura 78 – Programa com a entrada maior atribuída à variável n2
113
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
A primeira condicional resulta em Falso, pois o conteúdo de n1 é menor que o conteúdo da variável 
n2, portanto o fluxo é desviado para o senão.
algoritmo “o maior”
var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
1
n2
3
n3
2
Tela
1 3 2
Figura 79 – Como a primeira condicional resultou em Falso, o 
fluxo vai para o senão
No segundo se, como o conteúdo de n2 é maior que o de n3, a operação é verdadeira, executando 
o bloco do então.
114
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
1
n2
3
n3
2
Tela
1 3 2
O valor maior 
e 3
Figura 80 – Como a segunda condicional resultou em 
Verdadeiro, será executado o bloco do então
No bloco do então é executado o comando de saída, mostrando o conteúdo da variável n2, no caso, 
o número 3.
115
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
1
n2
3
n3
2
Tela
1 3 2
O valor maior 
e 3
Figura 81 – Memória com tela mostrando o valor 3, da variável n2
Ao encontrar o fim do bloco no senão, o programa é encaminhado apenas para os finais de 
blocos, encerrando-se. Ao final, o programa mostrou novamente o maior número digitado na 
entrada.
Alterando-se novamente a sequência de entrada, agora na ordem 2, 1 e 3, vamos fazer o teste de 
mesa. Assim, ao realizar a leitura, a variável n1 recebe o valor 2, a variável n2 recebe 1 e a variável n3 
recebe 3.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
116
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
2
n2
1
n3
3
Tela
2 1 3
Figura 82 – Atribuição de valores a cada variável
No primeiro se, o conteúdo de n1 é maior que o de n2; assim, desta vez, o bloco a ser executado 
será o então.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entaose n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
117
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:o maior
n1
2
n2
1
n3
3
Tela
2 1 3
Figura 83 – Execução do bloco do então
Com essa sequência de entrada, ao contrário dos testes anteriores, o bloco executado será o do 
primeiro então.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
2
n2
1
n3
3
Tela
2 1 3
Figura 84 – Execução do bloco do primeiro então
118
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
No primeiro bloco, o programa encontra a próxima condicional testando as variáveis n1 e n3. Como 
o conteúdo da variável n1 é maior que o da n2, agora é necessário testar com n3. No caso, o conteúdo 
de n3 (3) é maior que o de n1 (2), assim a operação n1>n3 é falsa, remetendo ao senão.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
2
n2
1
n3
3
Tela
2 1 3
O maior e 3
Figura 85 – O resultado Falso leva ao senão
Como o conteúdo da variável n3 é maior que o de n1, que, por sua vez, é maior que o de n2, o 
programa mostra o valor contido em n3, no caso, o número 3.
Ao escrever na tela, o bloco é encerrado no fimse, pulando do senão para o fimse e encerrando 
o programa.
119
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
2
n2
1
n3
3
Tela
2 1 3
O maior e 3
Figura 86 – Término do programa
O programa mostrou o conteúdo da variável n3 que tinha o maior valor digitado na entrada de dados.
O próximo teste será com as entradas 2, 3 e 1, respectivamente, para n1, n2 e n3.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
120
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
2
n2
3
n3
1
Tela
2 3 1
Figura 87 – Definição dos valores para as variáveis
Novamente, como o conteúdo de n1 (2) é menor que o conteúdo de n2 (3), gerando Falso na 
operação n1>n2, o programa desvia-se para o senão.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
fimalgoritmo
121
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:o maior
n1
2
n2
3
n3
1
Tela
2 3 1
Figura 88 – O resultado Falso remete ao senão
No bloco do senão, como n2 contém 3 e n3 contém 2, a operação n2>n3 fica verdadeira, passando 
a executar o bloco do então.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 senao 
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
2
n2
3
n3
1
Tela
2 3 1
Figura 89 – O resultado Verdadeiro leva à execução do bloco 
do então
122
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
No bloco do então é executado o comando para escrever que n2 é o maior número.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 Fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
2
n2
3
n3
1
Tela
2 3 1
O maior e 3
Figura 90 – Execução do comando no blo co do então
Revendo a sequência de condicionais, n2 é maior que n1 e n3, portanto n2 é o maior de todos.
123
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
fimalgoritmo
Memoria:o maior
n1
2
n2
3
n3
1
Tela
2 3 1
O maior e 3
Figura 91 – Memória com tela demonstrando que n2 é a 
variável com maior valor
Assim, o programa se encerra após todos os blocos serem fechados.
O penúltimo teste é para n1 valendo 3, n2 valendo 1 e n3 valendo 2.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
124
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
1
n3
2
Tela
3 1 2
Figura 92 – Definição dos valores para cada variável
Como n1 (3) é maior que n2 (1), a primeira condicional é verdadeira, prosseguindo no bloco do 
então.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senaoescreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
125
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:o maior
n1
3
n2
1
n3
2
Tela
3 1 2
Figura 93 – O resultado Verdadeiro da primeira condicional faz 
o programa prosseguir no bloco do então
A segunda condicional testa se n1 é maior que n3, o que é verdadeiro, pois temos 3 e 2, respectivamente, 
resultando em Verdadeiro, e o programa prossegue no então.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
1
n3
2
Tela
3 1 2
Figura 94 – O resultado Verdadeiro também na segunda 
condicional mantém o programa no bloco do então
126
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Assim, o programa mostra na tela que o maior é o conteúdo de n1, o número 3.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
1
n3
2
Tela
3 1 2
O maior e 3
Figura 95 – Tela mostrando que n1 é a variável de maior valor
O programa se fecha com o resultado mostrando que o maior número digitado é 3.
127
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
1
n3
2
Tela
3 1 2
O maior e 3
Figura 96 – Programa encerrado
O último teste é para testar a possibilidade de entrarmos com os valores 3, 2, e 1 nas variáveis n1, 
n2, e n3.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
Inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
128
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
2
n3
1
Tela
3 2 1
Figura 97 – Determinação de valores para as variáveis
A primeira condicional resulta em Verdadeiro, pois n1 é maior que n2, 3 > 2, passando para o bloco 
do então.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
129
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:o maior
n1
3
n2
2
n3
1
Tela
3 2 1
Figura 98 – Como o resultado é Verdadeiro para a primeira 
condicional, o programa segue no bloco do então
O segundo teste é feito verificando se n1 é maior que n3; nesse caso, é verdadeiro também, pois 3 
> 1.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
2
n3
1
Tela
3 2 1
Figura 99 – Como o resultado é Verdadeiro também para o 
segundo teste, o programa continua no bloco do então
130
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
O programa escreve então que o maior número é aquele contido na variável n1.
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
2
n3
1
Tela
3 2 1
O maior e 3
Figura 100 – Tela demonstrando que a variável n1 é a que 
possui maior valor 
O que acontece nesse teste e no anterior é que n1 é maior que n2 e n3; assim, essa variável é que 
deverá apresentar-se como a maior entrada.
131
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “o maior”
Var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 Senão
 escreva(“o maior e “,n3)
 Fimse
 Senão
 se n2>n3 entao
 escreva(“o maior e “, n2)
 Senão
 escreva(“o maior e “, n3)
 Fimse
 Fimse
Fimalgoritmo
Memoria:o maior
n1
3
n2
2
n3
1
Tela
3 2 1
O maior e 3
Figura 101 – Tela demonstrando que o valor 3 deverá ser a 
maior entrada
Assim, foram feitos os testes com todas as combinações possíveis para a entrada de dados. A conclusão 
é que, em cada uma das possibilidades, o programa tomou um caminho diferente, daí a importância de 
realizar cada um dos testes, pois pode ocorrer um erro na programação de um dos caminhos, e esse erro 
estar justamente num caminho que não foi testado.
3.2.4 Escolha-caso
Por enquanto, vimos somente um teste em que uma operação condicional apresenta apenas dois 
resultados possíveis. Se fosse necessário escolher um resultado dentre vários possíveis, teríamos de 
encadear várias condicionais.
132
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Existe uma estrutura que evita o encadeamento de condicionais. Essa estrutura é a chamada 
escolha-caso. A estrutura de decisão escolha-caso é utilizada quando é necessário testar uma única 
expressão que produz um resultado dentre vários possiveis, ou, então, testar o valor de uma variável em 
que está armazenada uma determinada informação. Compara-se o resultado, obtido opção a opção, 
testando-se com os valores individuais fornecidos de cada cláusula.
Sintaxe:
escolha (variável)
caso (opção 1) 
 Bloco de Instruções
caso (opção 2)
 Bloco de Instruções
_
_
_
caso (opção n) 
 Bloco de Instruções
fimescolha
Ou 
escolha (variável)
caso (opção 1) 
 Bloco de Instruções
caso (opção 2)Bloco de Instruções
.
.
outrocaso: 
 Bloco de Instruções
fimescolha
Na estrutura em formato de fluxograma, temos:
Variável
Instruções Instruções Instruções
VL 1 VL 2 VL n
Figura 102 – Escolha-caso
133
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
escolha (variável)
caso (opção 1), (opção 1.1), (opção 1.2):
 Bloco de Instruções
caso (opção 2), (opção 2.1):
 Bloco de Instruções
.
.
outrocaso: 
 Bloco de Instruções
fimescolha
Exemplo de aplicação
Fazer uma calculadora simples, que leia dois números e a operação.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
inicio
 escreva(“Digite: numero op numero “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 senao
 escreva(“divisao por zero”)
 fimse
 outrocaso
 escreva(“operacao invalida”)
 fimescolha
fimalgoritmo
134
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Início
num1, opção, 
num2
opção
num1+num2 num1–num2 num1*num2 Op inv
Div zero
Fim
num1/num2
num2=0
+ – * /
Figura 103 – Calculadora usando escolha-caso
Como sempre, é necessário fazer o teste de mesa.
O computador começa com a memória limpa, em que será executado o programa calc.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
135
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
Memoria Calc
Figura 104 – Memória iniciada para o programa calc
O passo seguinte é criar as variáveis que armazenarão as informações.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
136
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1 num2 opcao Tela
Figura 105 – Criação das variáveis
Iniciando a execução, o primeiro comando é a saída digite: num op num, apenas para dizer ao 
usuário as entradas.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
137
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1 num2 opcao Tela
Digite: num op 
num
Figura 106 – Execução do primeiro comando
Para testar a soma, será dada a entrada de 2 + 3, sendo o número 2 atribuído à variável num1, o 
caractere + atribuído à variável opção e o número 3 atribuído à variável num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
138
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
Figura 107 – Atribuição dos dados às variáveis
O comando escolha irá comparar cada uma das alternativas sequencialmente até encontrar o 
correspondente ao conteúdo da variável opção. Nessa situação, encontrará imediatamente no 
primeiro caso.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
√
139
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
Figura 108 – Comparação das alternativas
Uma vez encontrado o bloco correspondente, o programa executa a instrução de saída, a soma entre 
num1 e num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
140
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
5
Figura 109 – Execução da instrução de saída
Uma vez encerrado o bloco, o programa pula para o final do escolha e, se houvesse outros comandos, 
seguiria executando sequencialmente; como nesse caso é fimalgoritmo, encerra o processamento.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
141
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
5
Figura 110 – Término do processamento
Para testar a subtração, será dadaa entrada de 2 - 3, sendo o número 2 atribuído à variável num1, 
o caractere - atribuído à variável opção e o número 3 atribuído à variável num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
142
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
Figura 111 – Distribuição dos dados pelas variáveis
O comando escolha irá comparar cada uma das alternativas sequencialmente até encontrar o 
correspondente ao conteúdo da variável opção. O escolha comparará com o primeiro caso, +, e não 
corresponderá; depois, irá para o segundo caso e encontrará a correspondência.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
√
143
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
Figura 112 – Comparação das alternativas até encontrar 
correpondência
Uma vez encontrado o bloco correspondente, o programa executa a instrução de saída, a subtração 
entre num1 e num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
144
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
– 1
Figura 113 – Execução da instrução de saída no bloco 
correspondente
Uma vez encerrado o bloco, o programa pula para o final do escolha e, caso houvesse outros 
comandos, seguiria executando; como, no caso, é fimalgoritmo, encerra o processamento.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
145
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
– 1
Figura 114 – Finalização do programa
Para testar a multiplicação, será dada a entrada de 2 * 3, sendo o número 2 atribuído à variável 
num1, o caractere * atribuído à variável opção e o número 3 atribuído à variável num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
146
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
2
num2
3
opcao
*
Tela
Digite: num op 
num
2 * 3
Figura 115 – Atribuindo os dados a cada variável
O comando escolha irá comparar cada uma das alternativas sequencialmente até encontrar o 
correspondente ao conteúdo da variável opção. O escolha comparará com o primeiro caso, +, e não 
corresponderá; comparará com o segundo caso, -, que também não corresponderá; e encontrará a 
correspondência apenas no terceiro caso.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2) 
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-” 
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
√
147
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
2
num2
3
opcao
*
Tela
Digite: num op 
num
2 * 3
Figura 116 – Comparação das alternativas disponíveis
Uma vez encontrado o bloco correspondente, o programa executa a instrução de saída, a multiplicação 
entre num1 e num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
148
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
2
num2
3
opcao
*
Tela
Digite: num op 
num
2 * 3
6
Figura 117 – Execução da instrução de saída
Encerrado o bloco, o programa pula para o final do escolha e, caso houvesse outros comandos, 
seguiria executando; como, no caso, é fimalgoritmo, encerra o processamento.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
149
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
2
num2
3
opcao
*
Tela
Digite: num op 
num
2 * 3
6
Figura 118 – Término do programa
Na divisão existem duas situações possíveis: a primeira é com o divisor diferente de zero, pois, no 
caso de divisão por zero, o sistema deverá indicarerro. Para a divisão será dada a entrada de 8 / 2, sendo 
o número 8 atribuído à variável num1, o caractere / atribuído à variável opção e o número 2 atribuído 
à variável num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
150
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
Figura 119 – Distribuição dos dados pelas variáveis
O comando escolha irá comparar cada uma das alternativas sequencialmente até encontrar o 
correspondente ao conteúdo da variável opção. O escolha comparará com o primeiro caso, +, e não 
corresponderá; e comparará com o segundo caso, -, até encontrar o bloco com /.
algoritmo “calc”
Var
 num1, num2: real
 opcao:caracter
Inicio
 escreva (“Digite: num op num “)
 leia (num1, opção, num2) 
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-” 
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva (“divisao por zero”)
 Fimse
 Outrocaso
 escreva (“operacao invalida”)
 Fimescolha
Fimalgoritmo
√
151
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
Figura 120 – Comparação das alternativas até encontrar 
correspondência
Uma vez encontrado o bloco da divisão, o programa, inicialmente, verifica se o divisor, ou seja, 
a variável num2, é diferente de zero. Como no caso a operação resultará em Verdadeiro, pois num2 
contém o valor 2, será executado o bloco do então, nesse caso, a instrução de saída, a divisão entre 
num1 e num2.
algoritmo “calc”
Var
 num1, num2: real
 opcao:caracter
Inicio
 escreva (“Digite: num op num “)
 leia (num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva (“divisao por zero”)
 Fimse
 Outrocaso
 escreva (“operacao invalida”)
 Fimescolha
Fimalgoritmo
152
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
4
Figura 121 – Executando a instrução de saída
Uma vez encerrado o bloco do então, o programa pula para o fimse, prosseguindo para o final do 
escolha, e encerra o processamento.
algoritmo “calc”
Var
 num1, num2: real
 opcao:caracter
Inicio
 escreva (“Digite: num op num “)
 leia (num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
153
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
4
Figura 122 – Programa encerrado
A segunda possibilidade, na divisão, é o divisor igual a zero, caso em que o sistema deverá indicar 
erro. Para a divisão, será dada a entrada de 8 / 0, sendo o número 8 atribuído à variável num1, o 
caractere / atribuído à variável opção e o número 0 atribuído à variável num2.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
154
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
Figura 123 – Determinação de dados para as variáveis
O comando escolha irá comparar cada uma das alternativas sequencialmente até encontrar o 
correspondente ao conteúdo da variável opção. O escolha comparará com o primeiro caso, +, e não 
corresponderá; e comparará com o segundo caso, -, até encontrar o bloco com /.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2) 
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-” 
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
√
155
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
Figura 124 – Comparação buscando correspondência
Uma vez encontrado o bloco da divisão, o programa, inicialmente, verifica se o divisor, ou seja, a 
variável num2, é diferente de zero. Como no caso a operação resultará em Falso, pois num2 contém o 
valor 0, será executado o bloco do então, nesse caso, a instrução de saída, a mensagem de erro.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
156
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
Divisão por 
zero
Figura 125 – Exibição da mensagem de erro
Encerrado o bloco do então, o programa prossegue para o final do escolha e finaliza o processamento.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
157
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14Linguagem e Técnicas de Programação
Memoria Calc
num1
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
4
Figura 126 – Finalização do programa
Ainda falta um teste a ser realizado. O usuário pode digitar uma operação inválida, que não é nem 
soma, nem subtração, nem multiplicação, nem divisão. Vamos testar com %.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
158
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
8
num2
2
opcao
%
Tela
Digite: num op 
num
8 % 2
Figura 127 – Teste com %
O comando escolha irá comparar cada uma das alternativas sequencialmente até encontrar 
o correspondente ao conteúdo da variável opção. O escolha comparará com o primeiro caso, 
+, e não corresponderá; comparará com o segundo caso, -, e assim por diante; porém, como 
não encontrará o correspondente, o programa irá executar o bloco outrocaso, que é a saída da 
mensagem operação inválida.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2) 
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-” 
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
159
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria Calc
num1
8
num2
2
opcao
%
Tela
Digite: num op 
num
8 % 2
Operação 
invalida
Figura 128 – Exibição da mensagem “operação inválida”, por 
não haver correspondente entre as alternativas
Encerrado o bloco do então, o programa fecha o bloco do escolha, finalizando o processamento.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
Inicio
 escreva(“Digite: num op num “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 Senão
 escreva(“divisao por zero”)
 Fimse
 Outrocaso
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
160
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Memoria Calc
num1
8
num2
2
opcao
%
Tela
Digite: num op 
num
8 % 2
4
Figura 129 – Processamento encerrado
 saiba mais
No fim da década de 1970, surgiu uma nova linguagem de programação 
voltada para o ensino, principalmente, de crianças e adolescentes. Essa 
linguagem se chama Logo. Versões desse programa ainda podem ser 
encontradas gratuitamente na internet. Para aqueles que tiverem a 
curiosidade, o site xLogo oferece gratuitamente o manual e o programa:
<http://xlogo.tuxfamily.org/pt/>.
3.3 Laboratório
Na linguagem C, o comando correspondente ao se é o if.
Sintaxe:
if (expr) {
 bloco de comandos 1
}
A sintaxe corresponde à estrutura:
 se <condição> então
 bloco de comandos 1
fimse
Deve ficar claro que, na linguagem C, se a condição for verdadeira, o programa irá executar o próximo 
comando ou bloco.
161
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Assim:
if (true) 
{
 bloco de comandos 1
}
 observação
Na linguagem C, o inteiro 0 (zero), nas condicionais, é tratado como 
false. Normalmente, o 1 (um) é considerado true, mas, na realidade, a 
condicional considera verdadeiro qualquer valor diferente de zero.
Exemplo de aplicação
Converta o pseudocódigo do programa desenvolvido anteriormente, que mostrava na tela caso o 
número informado fosse negativo para a linguagem C++.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“O numero negativo “)
 fimse
fimalgoritmo
#include <stdio.h>
void main(){
..int numero;
..printf(“Entre com um numero: “);
 scanf(“%d”,&numero);
..if (numero<0){
....printf(“\nO numero negativo \n”);
 }
}
Ao executarmos o programa com a entrada 5, temos a seguinte saída:
Figura 130 – Saída do programa caso a entrada seja positiva
Executando com -5 na entrada, temos a seguinte saída:
162
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Figura 131 – Saída do programa com uma entrada negativa
 observação
Um erro comum é colocar o símbolo de fim de comando (;) após a 
condicional, anulando a estrutura do if.
if (true) ;
{
 bloco de comandos 1
}
if encerrado
No caso da estrutura se então senão, a sintaxe será:
if ( expr ) {
 bloco de comandos 1
}
else {
 bloco de comandos 2
}
Se o resultado expr for 1 (verdadeiro), o bloco de comandos 1 será executado. A inclusão do 
complemento else requisita a execução do bloco de comandos 2, ou seja, caso o resultado expr seja o 
valor 0 (Falso). Cada bloco de comandos deve ser delimitado por uma chave aberta e outra fechada. Se 
dentro de um bloco tivermos apenas um comando a ser executado, as chaves poderão ser omitidas (na 
verdade, deixaremos de ter um bloco).
A identação (recuo de linha) dos comandos é fundamental para uma maior clareza do código. O 
estilo de identação varia a gosto do programador. Além da forma ilustrada anteriormente, outro estilo 
bastante utilizado por programadores C é:
163
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
if ( expr )
{
bloco de comandos 1
}
else {
bloco de comandos 2
}
A estrutura corresponde, em pseudocódigo, a:
se <condição> entao
 bloco de comandos 1
senao 
 bloco de comandos 2
fimse
Vejamos mais um exemplo.
Exemplo de aplicação
Converta o pseudocódigo do programa que mostra caso um número digitado seja positivo ou 
negativo para a linguagem C++.
algoritmo “negativo”
var
 numero:inteiro
inicio
 escreva(“Entre com um número”)
 leia(numero)
 se numero<0 entao
 escreva(“ negativo “)
 senão
 escreva(“ positivo “)
 fimse
fimalgoritmo
#include <stdio.h>
void main(){
..int numero;
 printf(“Entre com um numero: “);
 scanf(“%d”,&numero);
 if (numero<0)
 {
 printf(“\nO numero negativo \n”);
 }
 else
 {
 printf(“\nO numero positivo \n”);
 }
}
Na saída para o valor 5 como entrada, teremos:
164
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Figura 132 – Saída do programa com else, e entrada positiva
Como saída para o valor -5, teremos:
Figura 133 – Saída do programa com else, e entrada negativa
Como os blocos do então e do senão, nesse programa, possuem apenas um comando, o programa 
pode ser escrito da seguinte maneira:
#include <stdio.h>void main(){
 int numero;
 printf(“Entre com um numero: “);
 scanf(“%d”,&numero);
 if (numero<0)
 printf(“\nO numero negativo \n”);
 else
 printf(“\nO numero positivo \n”);
}
Podemos aninhar comandos if. Um exemplo simples é ilustrado a seguir.
 if ( expr ) {
 if ( expr2 ) {
 .
 .
 .
 }
 else
 {
 .
165
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 .
 .
 }
}
else {
 if ( expr3 ) {
 .
 .
 .
 }
 else
 {
 .
 .
 .
 }
}
Assim, podemos tomar como exemplo o raciocínio desenvolvido nos pseudocódigos fazendo-se a 
simples tradução para a linguagem C.
Exemplo de aplicação
Converta o pseudocódigo do programa que mostra o maior número dentre os três digitados para a 
linguagem C++.
algoritmo “o maior”
var
 n1,n2,n3:inteiro
inicio
 leia(n1,n2,n3)
 se n1>n2 entao
 se n1>n3 entao
 escreva(“o maior e “,n1)
 senao
 escreva(“o maior e “,n3)
 fimse
 senao
 se n2>n3 entao
 escreva(“o maior e “, n2)
 senao
 escreva(“o maior e “, n3)
 fimse
 fimse
fimalgoritmo
#include <stdio.h>
void main(){
 int n1,n2,n3;
 scanf(“%d %d %d”,&n1,&n2,&n3);
 if (n1>n2)
 if (n1>n3)
 printf(“\no maior e %d\n”, n1);
 else
 printf(“\no maior e %d\n”, n3);
 else
 if (n2>n3)
 printf(“\no maior e %d\n”, n2);
 else
 printf(“\no maior e %d\n”, n3);
}
166
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Como foi feito nos testes de mesa, agora testaremos na prática as diversas entradas.
•	 Entradas	1,	2,	3:
Figura 134 – Saída do programa o maior número com entradas 1, 2, 3
•	 Entradas	1,	3,	2:
Figura 135 – Saída do programa o maior número com entradas 1, 3, 2
•	 Entradas	2,	1,	3:
Figura 136 – Saída do programa o maior número com entradas 2, 1, 3
•	 Entradas	2,	3,	1:
Figura 137 – Saída do programa o maior número com entradas 2, 3, 1
167
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 Entradas	3,	1,	2:
Figura 138 – Saída do programa o maior número com entradas 3, 1, 2
•	 Entradas	3,	2,	1:
Figura 139 – Saída do programa o maior número com entradas 3, 2, 1
3.3.1 Escolha-caso na linguagem C++
O comando (switch) para selecionar um dentre um conjunto de possíveis casos corresponde ao 
escolha do pseudocódigo. Sua forma geral é:
switch ( expr )
{
case op1:
... /* comandos executados se expr == op1 */
 break;
case op2:
... /* comandos executados se expr == op2 */
 break;
case op3:
... /* comandos executados se expr == op3 */
 break;
default:
... /* executados se expr for diferente de todos */
 break;
}
168
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Opcao1 deve ser um número inteiro ou uma constante caractere. Se expressao tiver o mesmo valor 
de opcao1, o bloco de comandos que se segue ao caso opcao1 será executado, até que seja encontrado 
o comando break. Caso o comando break seja omitido, a execução dos comandos do bloco do case 
continuará com os comandos do case seguinte. O caso default (nenhum dos outros) pode aparecer em 
qualquer posição, mas, para facilitar a leitura, é colocado por último.
Vamos tomar como exemplo o raciocínio desenvolvido nos pseudocódigos da construção de uma 
calculadora fazendo a simples tradução para a linguagem C.
Exemplo de aplicação
Fazer uma calculadora simples, que leia dois números e a operação.
algoritmo “calc”
Var
 num1,num2: real
 opcao:caracter
inicio
 escreva(“Digite: numero op nume-
ro “)
 leia(num1, opção, num2)
 escolha (opcao)
 caso “+”
 escreva(num1+num2)
 caso “-”
 escreva(num1-num2)
 caso “*”
 escreva(num1*num2)
 caso “/”
 se num2<>0 entao
 escreva(num1/num2)
 senao
 escreva(“divisao por zero”)
 fimse
 outrocaso
 escreva(“operacao invalida”)
 fimescolha
fimalgoritmo
#include <stdio.h>
void main ()
{
 float num1, num2;
 char op;
 printf(“Digite: numero op nume-
ro\n”);
 scanf (“%f %c %f”, &num1, &op, 
&num2);
 switch (op)
 {
 case ‘+’:
 printf(“ = %f\n”, num1+num2);
 break;
 case ‘-’:
 printf(“ = %f\n”, num1-num2);
 break;
 case ‘*’:
 printf(“ = %f\n”, num1*num2);
 break;
 case ‘/’:
 if (num2 != 0) 
 printf(“%10.5f\n”,num1/num2);
 else
 printf(“divisao por zero\n”);
 break;
 default:
 printf(“Operador invalido!\n”);
 break;
 }
}
Executando o programa para as diversas entradas.
169
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 Soma:
Figura 140 – Calculando 2 + 3
•	 Subtração:
Figura 141 – Calculando 2 - 3
•	 Multiplicação:
Figura 142 – Calculando 2 * 3
•	 Divisão:
Figura 143 – Calculando 8/2
170
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
•	 Divisão	por	zero:
Figura 144 – Calculando 8/0
•	 Operação	inválida:
Figura 145 – Calculando 8 % 2
Na linguagem C, temos mais dois casos de condicionais.
O primeiro caso é o chamado if-else-if, que é um complemento do if-else.
O funcionamento é idêntico ao do if-else, mas a estrutura é visualmente próxima à do switch-case.
if (condição1) {bloco de comandos 1};
else if (condição 2) bloco {bloco de comandos 2};
else if (condição 3) bloco {bloco de comandos 3};
.
.
else {bloco de default};
O segundo caso é o operador ?. Trata-se de uma condicional que devolve um valor e envolve três 
expressões:
condição?expressão 1:expressão 2;
O operador funciona da seguinte forma: se a condição resultar em Verdadeiro, retornará o resultado 
da expressão 1; se a condição for falsa, retornará o resultado da expressão 2.
171
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 Lembrete
Vimos a possibilidade de o programa seguir por caminhos diferentes 
de processamento, conforme decisões tomadas durante a execução. Com 
isso, não segue mais um caminho sequencial, abrindo a possibilidade 
de execuções alternativas que podem variar conforme a situação e a 
necessidade, considerando a lógica desenvolvida.
 saiba mais
Em 2008, o Massachussets Institute of Technology (MIT), o mesmo que 
desenvolveu a linguagem Logo, lançou o Scratch. Esse programa hoje é o 
padrão para o ensino da programação de computadores para crianças a 
partir dos oito anos. Com o Scratch, é possível desenvolver jogos, música, 
histórias, uma infinidade de programas que podem ser compartilhados 
na rede social dos usuários Scratch. É recomendável o conhecimento 
desse programa, que facilita muito a aprendizagem da programação de 
computadores.
O vídeo oficial da apresentação do Scratch pode ser visto no seguinte 
endereço:
<http://scratch.mit.edu/about/>.
 Resumo
Na Unidade III vimos as tomadas de decisão, como um programa pode 
seguir por um caminho ou por outro. Aprendemos que esse encaminhamento 
é feito conforme o resultado lógico de uma expressão.
O primeiro comando visto foi o se então, que pode também vir 
acompanhado de um senão. Abordamos que, conforme o resultado 
da expressão lógica que acompanhao se, o programa segue um fluxo 
diferente. Caso o resultado seja verdadeiro, o programa executa o bloco do 
então; caso seja falso, se tiver o senão, executará o bloco do senão, e, se 
não tiver, pulará o bloco do então e prosseguirá o programa.
Vimos que as condicionais podem ser encadeadas de forma que criem 
estruturas complexas, as quais podem resultar em várias possibilidades de 
172
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
execução. Vimos também um segundo modelo de condicional: aquele em 
que a decisão vai além das duas opções de Falso e Verdadeiro, podendo 
escolher o bloco a ser executado dentre muitos resultados. Esse tipo de 
funcional é o escolha-caso.
Por fim, estudamos a tradução das tomadas de decisão para a 
linguagem C, em que se (condição) é traduzido para if (condição); senão, 
para else; escolha, para switch; caso, para case; e outrocaso, para default. 
Lembrando que, na tradução, o case exige um break para encerrar o bloco 
em cada um dos casos.
 exercícios
Questão 1. Foi feito o seguinte programa para saber se um número é par ou ímpar, mas o programa 
tem um erro de lógica:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
Assinale a alternativa que mostra o que deve ser feito para corrigir esse programa:
A) Retirar a linha Resto<-0.
B)	Mudar	a	condição	para	Resto=0.
C) Mudar para Leia(Resto).
D) Retirar a declaração k:real.
E) O enunciado está incorreto, pois o programa não apresenta problemas.
173
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Resposta correta: alternativa B.
Análise das alternativas
Vamos fazer o teste de mesa com entradas para um número par e outro ímpar, por exemplo, 2 e 3.
Inicialmente:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
Figura 146
Criando as variáveis:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
174
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
I Resto K Tela
2 2
Figura 147
Lendo a entrada:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
2 0 2
Figura 148
Inicializando a varável Resto:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
175
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
2 0
0
2
Figura 149
A variável Resto recebe o resultado de i mod 2, no caso, 2 mod 2, resultando em zero.
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
2 0
0
2
Figura 150
Na condicional, o resto é igual a zero, portanto o programa desvia para o senão.
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
176
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
2 0
0
2
Impar
Figura 151
O programa escreve “ímpar” na tela e se encerra.
Obviamente o programa está incorreto, pois 2 é par, e a saída foi ímpar.
Para confirmar, vamos fazer o teste de mesa para a entrada 3.
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
3 3
Figura 152
177
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Lendo a entrada:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
3 0 3
Figura 153
Inicializando a variável Resto:
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
178
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
I Resto K Tela
3 0
1
3
Figura 154
A variável Resto recebe o resultado de i mod 2, no caso, 3 mod 2, resultando em 1.
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
 fimse
fimalgoritmo
I Resto K Tela
3 0
1
3
Figura 155
Na condicional, o resto é diferente de zero, e o programa segue no então.
algoritmo “parouimpar”
var
 i,Resto:inteiro
 k:real
inicio
 leia(i)
 Resto<-0
 Resto<-i mod 2
 se Resto<>0 entao
 escreva(“par”)
 senao
 escreva(“impar”)
179
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 fimse
fimalgoritmo
I Resto K Tela
3 0
1
3
Par
Figura 156
O programa escreve “Par” na tela e se encerra. 
Esse programa está invertendo os resultados, portanto o erro está na condicional.
A) Alternativa incorreta.
Justificativa: essa linha simplesmente inicializa a variável Resto. Se estivesse após o cálculo do resto, 
causaria um erro. Todos os resultados da condicional irão para o mesmo bloco. Portanto, essa alternativa 
não corrige o programa.
B) Alternativa correta.
Justificativa:	se	mudarmos	a	condição	de	Resto	<>	0	para	resto	=	0,	o	resultado	da	condicional	se	
inverterá, ou seja, na entrada com 2, mostrará que é par, e na entrada com 3, que é ímpar, corrigindo o 
programa.
C) Alternativa incorreta.
Justificativa: mudar para Leia(resto) causaria um problema, pois a variável que contém o número 
que está sendo testado é o i.
D) Alternativa incorreta.
Justificativa: a declaração de uma variável sem uso apenas ocupa espaço na memória, mas não 
provoca erro no processamento, ou lógica do programa.
E) Alternativa incorreta.
Justificativa: o programa está errado e não contraria o enunciado.
180
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
Questão 2. Foi feito um programa para a classificação etária.
#include <stdio.h>
void main(){
 int idade;
 printf(“Digite sua idade: “);
 scanf(“%d”,&idade);
 if (idade >= 0 && idade <= 2);
 printf(“Recém Nascido \n\n”);
 if (idade >= 3 && idade <= 10);
 printf(“Criança \n\n”);
 if (idade >= 11 && idade <= 17);
 printf(“Adolescente \n\n”);
 if (idade >= 18 && idade <= 60);
 printf(“Adulto \n\n”);
 if (idade > 60);
 printf(“Idoso \n\n”);
}
Foi dado como entrada 1, e o programa não classificou corretamente a faixa etária, mostrando a 
seguinte saída.
Figura 157
Qual o erro cometido?
A) A inclusão da biblioteca stdio.h.
B) As condicionais && estão erradas, deveriam ser ||.
C) É necessário retirar a sinalização de fim de comando logo após as condicionais.
181
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
D) O programa está correto.
E) O formato da leitura deve ser %s, e não %d.
Resposta correta: alternativa C.
Análise das alternativas
A) Alternativa incorreta.
Justificativa: a inclusão da biblioteca stdio.h não causa erros de lógica.
B) Alternativa incorreta.
Justificativa:	analisando	uma	das	condições:	idade	>=	11	&&	idade	<=	17.
Caso a idade seja 8, a expressão fica:
8 >= 11 && 8 <= 17
 F && V
 F
Portanto, 8 anos está fora da faixa entre 11 e 17; correto.
Caso a idade seja 28, a expressão fica:
28 >= 11 && 28 <= 17
 V && F
 F
Portanto, 28 anos está fora da faixa entre 11 e 17; correto.
Caso a idade seja 15, a expressão fica:
15 >= 11 && 15 <= 17
 V && V
 V
Portanto, 15 anos está dentro da faixa entre 11 e 17; correto.
Caso troquemos &&(e) por || (ou), trabalhando com idade de 8, a expressão fica:
182
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade III
8 >= 11 || 8 <= 17
 F || V
 V
Ou seja, o operador || não serve. A alternativa não justifica o erro.
C) Alternativa correta.
Justificativa: vimos que a condicional if, caso seja verdadeira, executa o comando ou o bloco 
imediatamente após a comparação até encontrar o fim de bloco ou comando, no caso, o ponto e vírgula.
No programa, todos os ifs estão:
if (idade >= 0 && idade <= 2);
Ou seja, se a condição for verdadeira, não executará comando algum, encerrando a comparação. 
Portanto, o ponto e vírgula deve ser retirado.
Retirando a sinalização de fim de comando após as condicionais, temos:
#include <stdio.h>
void main()
{
 int idade;
 printf(“Digite sua idade: “);
 scanf(“%d”,&idade);
 if (idade >= 0 && idade <= 2) 
 printf(“Recém Nascido \n\n”);
 if (idade >= 3 && idade <= 10) 
 printf(“Criança \n\n”);
 if (idade >= 11 && idade <= 17) 
 printf(“Adolescente \n\n”);
 if (idade >= 18 && idade <= 60) 
 printf(“Adulto \n\n”);
 if (idade > 60) 
 printf(“Idoso \n\n”);
}
Executando a saída, fica:
183
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Figura 158 – Saída do programa corrigido
Essa é a alternativa correta.
D) Alternativa incorreta.
Justificativa: o programa não está correto, pois, após as condicionais, há um ponto e vírgula 
encerrando o comando.
E) Alternativa incorreta.
Justificativa: o formato de leitura está correto.
184
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Unidade IV
Você gosta de fazer exatamente a mesma coisa centenas de vezes? Em algum momento, essa 
operação vai ficar muito monótona, se não levar à loucura.
4 Laços de repetição
Uma das funções do computador, entre outras, é fazer operações repetitivas, que para o ser humano seriam 
muito enfadonhas. São muito comuns, durante o processamento de um programa, situações em que pode 
existir a necessidade de repetir um determinado conjunto de comandos por um certo número de vezes. Por 
exemplo: durante o processamento da folha de pagamento de uma empresa, o mesmo cálculo do salário 
conforme as horas trabalhadas é efetuado para cada um dos funcionários. Para evitar a repetição desse cálculo, 
utiliza-se a estrutura de repetição. As estruturas de repetição são também denominadas laços (loops).
4.1 teoria
Existem três comandos que executam a estrutura dos laços de repetição: o enquanto, o repita e o 
para, que veremos detalhadamente. Apesar de todos terem a mesma funcionalidade, a de fazer repetições, 
conforme o problema a ser resolvido, cada um deles apresenta uma característica mais adequada. Conforme 
o conhecimento prévio e a quantidade de laços executados, ou se o número de vezes em que o conjunto de 
instruções será executado (iteração) for indeterminado, as estruturas de repetição poderão ser classificadas em:
•	 laços	contados:	quando	se	conhece	previamente	quantas	vezes	o	comando	composto	no	interior	
da construção será executado;
•	 laços	condicionais:	quando	não	se	conhece	o	número	de	vezes	em	que	o	conjunto	de	instruções	
no interior do laço será repetido, pois a condição testada é modificada pelas instruções do interior 
do laço.
É importante ter em mente que os laços de repetição têm um funcionamento automatizado, muito 
particular em cada uma das formas, e o entendimento desse mecanismo é fundamental para montar 
corretamente os programas.
A nomenclatura técnica para a execução de um laço completo é iteração.
4.1.1 Laços condicionais
Quando existem blocos de programas que necessitam ser repetidos, porém não sabemos quantas 
vezes isso ocorrerá, utilizamos o laço condicional. No caso, são dois: o laço do repita até que e o do 
enquanto faça.
185
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
4.1.1.1 Repita até que
No laço repita, o fluxo do programa encontra o comando propriamente dito e reconhece que é o 
início do bloco de repetição, seguindo o fluxo normal até encontrar o comando até que, no qual uma 
condição é testada. Se o resultado do teste for Falso, o fluxo será devolvido ao início do bloco. Se o 
resultado do teste for Verdadeiro, o programa seguirá o fluxo, abandonando a repetição do bloco. O 
importante é saber que, nessa estrutura, o processo será repetido enquanto a condição testada for falsa.
Sintaxe:
repita
<Comandos>
Até que <Condição>
comandos
condição F
V
Figura 159 – Fluxograma do comando repita até que
Exemplo de aplicação
Faça um algoritmo que processe a seguinte enquete: “Você tem computador em casa?”, mostrando 
o número de pessoas que não possuem e o das pessoas que possuem computador. Para sair, dê a opção 
de escolha.
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
186
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
início
fim
Cont_s <- Cont_s+1 Cont_s <- Cont_s+1Cont_s+1
Cont_s<-0
Cont_n<-0
A
A
Você tem 
computador 
em casa ?
Deseja 
continuar?
Total cont_s
Total cont_n
voto
resp
voto=s
resp=n
V
V
F
F
Figura 160 – Programa de pesquisa usando repita
Uma vezmontado o programa, o passo seguinte é verificar se está funcionando adequadamente. 
Para isso, vamos fazer o teste de mesa, com duas entradas positivas para ter computador em casa e uma 
entrada negativa, e encerrar o processamento.
187
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
Figura 161 – Início com memória vazia
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 Repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
188
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp Cont_s Cont_n Tela
Figura 162 – O espaço para as variáveis é criado
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 Repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp Cont_s
0
Cont_n
0
Tela
Figura 163 – As variáveis são inicializadas
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
189
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” então
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp Cont_s
0
Cont_n
0
Tela
Você tem computador em casa?
s/n
Figura 164 – A mensagem é mostrada na tela
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
190
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
resp Cont_s
0
Cont_n
0
Tela
Você tem computador em casa?
s/n
s
Figura 165 – Leitura do teclado
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Figura 166 – Condicional para a contagem da opção
191
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
Figura 167 – Exibição da pergunta
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 Repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” então
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
192
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
resp
s
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Figura 168 – Nova leitura do teclado
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp
s
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Figura 169 – Devolve ao início do laço
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 Repita
 escreva (“Você tem computador em casa? s/n”)
193
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp
s
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
Figura 170 – Mensagem na tela
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo 
194
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
n
resp
s
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
n
Figura 171 – Outra leitura doteclado
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
n
Figura 172 – Condicional para escolher em que variável acumulará os nãos
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
195
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
n
resp
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
Figura 173 – Display na tela
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
Fimalgoritmo
196
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
n
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Figura 174 – Mais uma leitura do teclado
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 Repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Figura 175 – Retorno ao início do laço
197
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
Fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
Figura 176 – Exibição da mensagem na tela
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
198
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
s
Figura 177 – Leitura do teclado
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 Repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
199
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: enquete
voto
s
n
s
resp
s
s
Cont_s
1
2
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
s
Figura 178 – Condicional para acumular na variável de contagem de sim
algoritmo “enquete”
Var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
Cont_s
1
2
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
Figura 179 – Mensagem exibida na tela
200
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
n
Cont_s
1
2
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
n
Figura 180 – Leitura do teclado: desta vez, a resposta para continuar é não
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
201
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)ate resp=”n”
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
n
Cont_s
1
2
Cont_n
1
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
N
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
S
Deseja continuar? s/n
N
total sim: 2 total não 1”
Figura 181 – Como a condição do fim das iterações foi alcançada, sai do laço
4.1.1.2 Enquanto faça
O laço enquanto funciona da seguinte maneira: ao início do bloco de repetição, uma condição é 
testada. Se o resultado do teste for Falso, então o bloco será ignorado, prosseguindo normalmente após 
o fimenquanto. Caso o resultado do teste seja Verdadeiro, o bloco será executado e, ao encontrar a 
instrução fimenquanto, o fluxo será devolvido à instrução enquanto, e a condição, testada novamente, 
até que se torne falsa. Resumindo, o processo será repetido enquanto a condição testada for verdadeira.
 observação
A variável deverá estar inicializada, pois a condição resultará em erro.
Sintaxe:
enquanto <Condição> faça
<Comandos>
fim enquanto
202
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
O fluxograma da estrutura enquanto é:
Comandos
CondiçãoF
V
Figura 182 – Estrutura do enquanto
Exemplo de aplicação
Faça um algoritmo, usando o laço enquanto, que receba a seguinte enquete: Você tem computador 
em casa? Levante o número de pessoas que não possuem e o das que possuem. Para sair, dê a opção 
de escolha.
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
203
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
início
fim
Cont_s<-0
Cont_n<-0
Resp<-s
A
A
Total cont_s
Total cont_n
Você tem 
computador 
em casa?
Deseja 
continuar?
voto
resp
Cont_s <- Cont_s+1 Cont_s <- Cont_s+1
voto=s
V
F
F
Vresp=s
Figura 183 – Programa da pesquisa versão enquanto
Vamos fazer o teste de mesa com duas entradas positivas para ter computador em casa e uma 
entrada negativa, encerrar o processamento e verificar o funcionamento do laço enquanto.
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
204
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
Figura 184 – Início com a memória vazia
algoritmo “enquete”
Var
 voto, resp: caractere
 cont_s, cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
205
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: enquete
voto resp Cont_s Cont_n Tela
Figura 185 – O espaço de memória das variáveis é criado
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp
S
Cont_s
0
Cont_n
0
Tela
Figura 186 – É preciso inicializar a variável resp
Nesse caso, a variável resp necessita ser inicializada, pois é uma condição necessária para a verificação 
do enquanto ser válida.
206
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
√
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp
S
Cont_s
0
Cont_n
0
Tela
Figura 187 – O comando enquanto, por encontrar a condição verdadeira, entra no laço
algoritmo “enquete”
Var
 voto, resp: caractere
 cont_s, cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
207
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp
S
Cont_s
0
Cont_n
0
Tela
Você tem computador em casa? 
s/n
Figura 188 – Display da mensagem
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
208
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
resp
S
Cont_s
0
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Figura 189 – Realização da leitura do teclado e atribuição à variável
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Figura 190 – A condicional atualiza a variável acumuladora das respostas sim
209
Re
visã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
Figura 191 – Ao chegar ao senão, passa para o fimse, mostrando a nova saída na tela
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
210
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
voto
s
resp
S
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
S
Figura 192 – Feita a leitura do teclado, o valor é armazenado na variável
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp
S
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
S
Figura 193 – O fimenquanto remete de volta para o início do laço
211
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
√
Memoria: enquete
voto
s
resp
S
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
S
Figura 194 – Como o resultado é Verdadeiro, mais uma iteração é realizada
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
212
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
resp
S
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
Figura 195 – A mensagem é mostrada na tela
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
voto
s
n
resp
S
Cont_s
1
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
S
Você tem computador em casa? 
s/n
n
Figura 196 – A leitura é feita
213
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Figura 197 – A condicional remete para a atualização da variável contador do não
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
214
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Figura 198 – O contador é atualizado
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
Figura 199 – A mensagem é exibida na tela
215
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
s
Cont_s
1
Cont_n
1
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computadorem casa? 
s/n
n
Deseja continuar? s/n
s
Figura 200 – A leitura é feita
216
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
s
Cont_s
1
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Figura 201 – O programa é remetido para o início do laço
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
217
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
resp
s
s
s
Cont_s
1
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Figura 202 – Mais um laço será realizado
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
218
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
n
resp
s
s
s
Cont_s
1
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
Figura 203 – Mensagem mostrada na tela
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
s
Cont_s
1
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Figura 204 – Realização da leitura
219
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
s
Cont_s
1
2
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Figura 205 – A condicional atualiza o contador
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
220
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto
s
n
s
resp
s
s
s
Cont_s
1
2
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Figura 206 – A contagem é feita
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
221
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: enquete
voto
s
n
s
resp
s
s
s
Cont_s
1
2
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Deseja continuar? s/n
Figura 207 – Mensagem para a continuidade
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
222
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
n
s
resp
s
s
s
n
Cont_s
1
2
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Deseja continuar? s/n
n
Figura 208 – É feita a leitura
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
223
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
cio 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: enquete
voto
s
n
s
resp
s
s
s
n
Cont_s
1
2
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Deseja continuar? s/n
n
Figura 209 – O fluxo é devolvido ao início do laço
algoritmo “enquete”
Var
 voto, resp: caractere
 cont_s, cont_n: inteiro
Inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 Senão
 cont_n<-cont_n+1
 Fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
224
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: enquete
voto
s
n
s
resp
s
s
s
n
Cont_s
1
2
Cont_n
1
w
Tela
Você tem computador em casa? 
s/n
s
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
n
Deseja continuar? s/n
s
Você tem computador em casa? 
s/n
S
Deseja continuar? s/n
n
total sim: 2 total não: 1”
Figura 210 – Como a condição não é satisfeita, o laço é encerrado
No exemplo que veremos a seguir, como não sabemos de antemão quantas pessoas irão reponder à enquete, 
utizamos o comando enquanto, que somente interromperá as iterações quando o valor de resp for ‘s’.
Exemplo de aplicação
Faça um programa que calcule o fatorial de um número inteiro.
Dada a definição de fatorial:
“O fatorial é uma propriedade matemática [...] na determinação do produto dos antecessores de um 
número maior que 1, ou seja, fatorial de um número n (designado por n!) é igual a n! = n(n – 1)(n – 2)
(n – 3)...” (ANÁLISE..., 2014).
Assim, o fatorial de 5, por exemplo, é 120, pois:
5!=5(5-1)(5-2)(5-3)(5-4)
5!=5.4.3.2.1
5!=120
Pela propriedade comutativa da multiplicação, a conhecida “A ordem dos fatores não altera o 
produto.”, podemos escrever que:
5!=1.2.3.4.5
5!=120
225
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Pela definição, também se aplica que 0! = 1.
Criar uma variável chamada fat inicializada por 1 e acumular nela o produto da multiplicação por 
um número sequencial.
Assim:
•	 Para	1!
Inicio
 fat<-1
 fat<-fat*1
fim
fat
1
1
Figura 211 – Cálculo de 1!
•	 Para	2!
Inicio
 fat<-1
 fat<-fat*1
 fat<-fat*2
fim
fat
1
1
2
Figura 212 – Cálculo para 2!
226
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
•	 Para	3!
Inicio
 fat<-1
 fat<-fat*1
 fat<-fat*2
 fat<-fat*3
fim
fat
1
1
2
6
Figura 213 – Cálculo de 3!
•	 Para	4!
Inicio
 fat<-1
 fat<-fat*1
 fat<-fat*2
 fat<-fat*3
 fat<-fat*4
fim
fat
1
1
2
6
24
Figura 214 – Cálculo para 4!
227
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
•	 Para	5!
inicio
 fat<-1
 fat<-fat*1
 fat<-fat*2
 fat<-fat*3
 fat<-fat*4
 fat<-fat*5
fim
fat
1
1
2
6
24
120
Figura 215 – Cálculo de 5!
Vamos então introduzir uma nova variável inteira i e utilizar o exemplo do 5!
inicio
 fat<-1
 i<-1
 fat<-fat*i
 i<-i+1
 fat<-fat*i
 i<-i+1
 fat<-fat*i
 i<-i+1
 fat<-fat*i
 i<-i+1
 fat<-fat*i
fim
fat
1
1
2
6
24
120
i
1
2
3
4
5
Figura 216 – Uso do exemplo 5! incluindo uma nova variável
228
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Nesse último programa, notamos que existem as linhas:
 fat<-fat*i
 i<-i+1
Estas se repetem algumas vezes; como os laços são estruturas de repetição, podemos escrever (no 
caso, usando o laço enquanto):
inicio
 fat<-1
 i<-1
 enquanto i<=5 faca
 fat<-fat*i
 i<-i+1
 fimenquanto
fimalgoritmo
Como a proposta do exercício é para qualquer número inteiro, e não apenas para 5, vamos colocar 
uma nova variável, em que será feita a leitura do número desejado pelo operador do programa, e 
também uma saída. Assim, o programa final será:
algoritmo “fatorial”
var
 fat, i, n: inteiro
inicio
 leia(n)
 fat<-1
 i<-1
 enquanto i<=n faca
 fat<-fat*i
 i<-i+1
 fimenquanto
 escreva(fat)
fimalgoritmo
Faça o teste de mesa para conferir a funcionalidade do código.
229
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 observação
No Scratch, o laço repita até que e o enquanto são comandados pelo 
bloco:
Figura 217 – Bloco que comanda o laço repita até que e o enquanto
4.1.2 Laços contados
Os laços contados serão utilizados quando existir o conhecimento prévio do número de 
iterações a ser executado. Essa estrutura é conhecida como o laço do para-até. O laço para 
utiliza uma variável que é contador, e a cada iteração se atualiza esse valor, verificando se 
chegou ao seu limite.
Forma:
para <varcontrole> de <vl inicial> até <vl final> passo <passo> faça
fimpara
O fluxograma da estrutura para é:
Comandos
<var>; <inicio>;
<fim>
<passo>
Figura 218 – Estrutura para...até
230
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
No caso de passo 1, pode-se omitir o comando passo.
Exemplo de aplcação
Para entender, passo a passo, um programa simples:
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 até 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
Fazendo o teste de mesa:
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 até 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i tela
Figura 219
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 até 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
tela
Figura 220 – Atribuição do valor inicial à variável de controle
231
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Ao encontrar o comando para i de 1, o programa atribui o valor inicial à variável de controle, no caso, 1. 
Feito isso, o comando para i de 1 não será mais executado.
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 até 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
I
1
tela
Figura 221– Teste da variável de controle
Feita a atribuição, o programa testa o conteúdo da variável de controle com o valor final <varcontrole> 
<= <vl final>, no caso, i<=7.
Como é verdadeiro, o programa entra no laço. Caso fosse falso, prosseguiria após o fimpara.
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
tela
1
Figura 222– Execução dos comandos dentro do laço
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
232
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
-02
/0
6/
20
14
Unidade IV
i
1
2
tela
1
Figura 223–Execução automática de uma nova instrução
Ao final da iteração, encontra o comando fimpara. Nesse momento, o programa faz, automaticamente, 
a seguinte instrução:
<varcontrole><-<varcontrole> + passo
No caso:
i<-i + 2
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
tela
1
Figura 224 – Retorno do programa à linha do para
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
tela
1
Figura 225 – Realização de teste pelo programa
O programa testa se chegou ao final das iterações, fazendo <varcontrole> <= <vl final>, no caso: i 
<= 7. Como aqui o i contém 3, a expressão é verdadeira, e o programa volta para dentro do laço.
233
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
tela
1
3
Figura 226 – O programa executa os comandos dentro do laço
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
5
tela
1
3
Figura 227 – Uma nova instrução é executada automaticamente pelo programa
Ao encontrar o comando fimpara, o programa faz, automaticamente, <varcontrole><-<varcontrole> 
+ passo. No caso, i<-i + 2.
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
5
tela
1
3
Figura 228 – Retorno do programa para a linha do para e execução do teste
234
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
O programa retorna para a linha do para e testa se chegou ao final das iterações, i <= 7. Como nesse 
caso o i contém 5, a expressão é verdadeira, e o programa volta para dentro do laço.
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
5
tela
1
3
5
Figura 229– Execução dos comandos dentro do laço
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
5
7
tela
1
3
5
Figura 230– Nova execução automática de instrução pelo programa
No fimpara, o programa faz, automaticamente, <varcontrole><-<varcontrole> + passo. No caso, 
i<-i + 2.
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
235
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
i
1
3
5
7
tela
1
3
5
Figura 231– Volta do programa para a linha do para e realização do teste
O programa retorna para a linha do para e faz o teste se chegou ao final das iterações, i <= 7. Como 
nesse caso o i contém 7, devemos prestar atenção, pois a expressão é verdadeira, já que a condição é 
menor ou igual; sete é igual a sete, e o programa volta para dentro do laço.
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
5
7
tela
1
3
5
7
Figura 232– O programa executa os comandos dentro do laço
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
I
1
3
5
7
9
tela
1
3
5
7
Figura 233– Execução automática de uma instrução pelo programa
No fimpara, o programa faz, automaticamente, <varcontrole><-<varcontrole> + passo. No caso, 
i<-i + 2, e o i passa a valer 9, voltando para a linha do para.
236
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
5
7
9
tela
1
3
5
7
Figura 234– O programa desconsidera o laço e prossegue
Quanto ao teste para verificar se chegou ao final das iterações, i <= 7, como no caso o i contém 9, 
resulta em Falso; assim, o programa pula o laço, passando a ser executado após a linha do fimpara.
Assim, vimos um exemplo do uso do passo no laço para. Abordaremos agora um exemplo mais 
prático, visto no tópico anterior desta unidade.
 observação
No Scratch, o laço para... até que é comandado pelo bloco:
Figura 235 – Laço para... até que no Scratch
No exemplo, o som do miado será repetido dez vezes.
Exemplo de aplicação
Faça um programa que calcule o fatorial de um número inteiro usando o laço para.
No caso do fatorial, pode não parecer, mas é um típico caso de laço contado, pois é claro quantas 
iterações vão acontecer. Esse número é determinado na leitura inicial, portanto não depende de o 
operador interromper ou não a execução do laço. Assim, o pseudocódigo será:
237
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
início
fim
fat<-1
fat<-1
fat
n
i;1;n
Figura 236 – Cálculo fatorial
Vamos fazer o teste de mesa para 4!
238
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
☻
Figura 237– Reserva de um espaço de memória para o programa fatorial
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat i n tela
Figura 238– São reservados espaços na memória para as variáveis
239
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat i n
4
tela
4
Figura 239– Leitura do valor de entrada
A leitura do valor de entrada é feita. Como a proposta é fazer o fatorial de 4, o valor será atribuído 
à variável n. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
i n
4
tela
4
Figura 240– Inicialização de fat
240
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 Lembrete
Uma das propriedades da multiplicação é a do elemento absorvente, 
segundo a qual a multiplicação de qualquer número por zero é zero.
A variável fat deverá ser inicializada com 1, e não com 0, pois, como essa variável irá acumular o 
produto de uma multiplicação, e em virtude da propriedade do elemento absorvente, o programa não 
funcionaria para o nosso propósitose começasse com 0. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
i
1
n
4
tela
4
Figura 241– Inicialização da variável de controle
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
V
241
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: fatorial
fat
1
i
1
n
4
tela
4
Figura 242– Realização do teste
O teste para verificar se já não foi atingida a condição de término do laço é realizado. Como essa 
condição é verdadeira, o programa segue para dentro do laço. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
i
1
n
4
tela
4
Figura 243– O programa faz a multiplicação
O produto da multiplicação entre o valor de fat já inicializado e o primeiro número é obtido. 
242
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
i
1
2
n
4
tela
4
Figura 244– Atualização do valor da variável de controle e devolução do fluxo à linha do para
Ao chegar ao fimpara, o valor contido na variável de controle é atualizado, nesse caso, acrescido de 
1, e o fluxo do programa é devolvido à linha do para. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
V
Memoria: fatorial
fat
1
1
i
1
2
n
4
tela
4
Figura 245– O programa entra no laço
243
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Como i<=n (2<=4), o programa entra novamente no laço. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
2
i
1
2
n
4
tela
4
Figura 246– O conteúdo do laço é executado
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
2
i
1
2
3
n
4
tela
4
Figura 247– Atualização da variável de controle
244
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Ao chegar ao fimpara, o valor da variável de controle é atualizado. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
V
Memoria: fatorial
fat
1
1
2
i
1
2
3
n
4
tela
4
Figura 248– O programa volta a entrar no laço
Como i<=n (3<=4), o programa entra novamente no laço. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
245
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: fatorial
fat
1
1
2
6
i
1
2
3
n
4
tela
4
Figura 249– O programa executa o conteúdo do laço
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
2
6
i
1
2
3
4
n
4
tela
4
Figura 250– Atualização do valor da variável de controle
Ao chegar ao fimpara, o valor da variável de controle é atualizado. 
algoritmo “fatorial”
Var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 Fimpara
 escreva(fat)
fimalgoritmo
V
246
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Memoria: fatorial
fat
1
1
2
6
i
1
2
3
4
n
4
tela
4
Figura 251– O programa entra no laço mais uma vez
Como i<=n (4=4), o programa entra novamente no laço. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
2
6
24
i
1
2
3
4
n
4
tela
4
Figura 252– O programa executa o conteúdo do laço
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
247
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: fatorial
fat
1
1
2
6
24
i
1
2
3
4
5
n
4
tela
4
Figura 253– O programa atualiza o valor da variável de controle
Ao chegar ao fimpara, o valor da variável de controle é atualizado. 
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
Memoria: fatorial
fat
1
1
2
6
24
i
1
2
3
4
5
n
4
tela
4
Figura 254– Como i<=n (5>4) é Falso, sai do laço
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
248
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
fat
1
1
2
6
24
i
1
2
3
4
5
n
4
tela
4
24
Figura 255– Exibição do resultado e encerramento do programa
Ao sair do laço, o programa mostra o resultado e é encerrado. 
Como fizemos o cálculo do fatorial utilizando duas técnicas diferentes, podemos comparar os 
programas para compreendermos como funciona a automação do para.
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
leia(n)
 fat<-1
 i<-1
 enquanto i<=n faca
 fat<-fat*i
 i<-i+1
 fimenquanto
 escreva(fat)
fimalgoritmo
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 
 fimpara
 escreva(fat)
fimalgoritmo
Assim, em verde, temos a inicialização da variável de controle; em azul, o teste do limite; e em 
marrom, o incremento e a devolução do fluxo.
4.2 Laboratório
Na linguagem C, temos os três tipos de estruturas de blocos, porém com algumas diferenças.
4.2.1 Repita até que
Como vimos no pseudocódigo no laço repita, o fluxo do programa encontra o comando propriamente 
dito, reconhece que é o início do bloco de repetição e segue o fluxo normal até encontrar o comando 
em que uma condição é testada. Na linguagem C, o comando que inicia o repita é o do segundo bloco 
demarcado pelas chaves.
249
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 observaçãoA diferença entre o pseudocódigo e a linguagem C é que nesta, ao final, 
o teste é feito com o comando while (condição), executando novamente o 
laço se o resultado for Verdadeiro. É o contrário do pseudocódigo, em que, 
caso o resultado do teste seja Falso, o fluxo é devolvido ao início do bloco.
Sintaxe:
do {
 Bloco
}while (condição);
Assim, a tradução do programa da enquete usando repita será:
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 repita
 escreva (“Você tem computador em 
casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 ate resp=”n”
 escreva(“total sim: “,cont_s, “to-
tal nao”, cont_n)
fimalgoritmo
#include <stdio.h>
void main ()
{
 char voto,resp;
 int cont_s,cont_n;
 cont_s=0;
 cont_n=0;
 do{
 printf(“\nVocê tem computador em 
casa? s/n “);
 scanf (“%c”, &voto);
 fflush(stdin);
 if (voto == ‘s’)
 cont_s++;
 else
 cont_n++;
 printf(“\Deseja continuar? s/n “);
 scanf (“%c”, &resp);
 fflush(stdin);
 }while (resp==’s’);
 printf(“\ntotal sim: %d total nao: 
%d”,cont_s, cont_n);
}
250
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 observação
O comando fflush serve apenas para limpar a área de leitura, pois, em 
alguns casos, quando ocorre a leitura de um caractere, podem acontecer 
erros. Existem outros comandos de leitura mais adequados, mas que ainda 
não fazem parte do conteúdo da matéria.
Ao executarmos, obtemos a seguinte tela:
Figura 256 – Saída do programa da enquete usando do...while
4.2.2 Enquanto faça
Estruturalmente, o laço enquanto faça não difere do pseudocódigo.
while (expr) {
 bloco de comandos
}
O laço realizará as iterações do bloco de comandos enquanto o resultado de expressao for verdadeiro. 
Quando expressao se tornar falsa, o bloco de comando parará de ser executado, e o programa prosseguirá 
no comando seguinte ao bloco.
A tradução do programa “enquete” usando o laço enquanto será:
251
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “enquete”
var
 voto, resp: caractere
 cont_s, cont_n: inteiro
inicio
 cont_s<-0
 cont_n<-0
 resp<-“s”
 enquanto resp=”s” faca
 escreva (“Você tem computador em 
casa? s/n”)
 leia (voto)
 se voto=”s” entao
 cont_s<-cont_s+1
 senao
 cont_n<-cont_n+1
 fimse
 escreva (“Deseja continuar? s/n”)
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total 
nao”, cont_n)
fimalgoritmo
#include <stdio.h>
void main ()
{
 char voto,resp;
 int cont_s,cont_n;
 cont_s=0;
 cont_n=0;
 resp=’s’;
 while (resp==’s’){
 printf(“\nVocê tem computador em 
casa? s/n “);
 scanf (“%c”, &voto);
 fflush(stdin);
 if (voto == ‘s’)
 cont_s++;
 else
 cont_n++;
 printf(“\Deseja continuar? s/n “);
 scanf (“%c”, &resp);
 fflush(stdin);
 };
 printf(“\ntotal sim: %d total nao: 
%d”,cont_s, cont_n);
}
Figura 257 – Saída do programa usando while
Fazendo a tradução do programa do fatorial utilizando o enquanto.
252
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
algoritmo “fatorial”
var
 fat,i,n:inteiro
inicio
 leia(n)
 fat<-1
 i<-1
 enquanto i<=n faca
 fat<-fat*i
 i<-i+1
 fimenquanto
 escreva(fat)
fimalgoritmo
#include <stdio.h>
void main ()
{
..int fat,i,n;
 
..scanf(“%d”,&n);
..fat=1;
..i=1;
..while (i<=n){
....fat*=i;
 ..i++;
 }
 ..printf(“%d\n”,fat);
}
Figura 258 – Saída do programa fatorial usando while (enquanto)
 Lembrete
Após a instrução do while (expressão), não se deve colocar o sinal de 
fim de comando (‘;’) Um dos erros mais comuns em programação é colocar 
ponto e vírgula antes do bloco de comandos.
4.2.3 Para até que
Na linguagem C, a estrutura do funcionamento é semelhante ao para do pseudocódigo, mas indicada 
de forma explícita.
Sintaxe:
for (expr inicial; expr booleana; expr de incremento)
{
 bloco de comandos
}
A expr inicial inicializa a variável de controle. Caso a expr booleana seja verdadeira, o laço 
será executado; expr de incremento é o cálculo feito quando o fluxo do programa chega ao 
fimpara.
253
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Para exemplificar e deixar claro o seu funcionamento, serão apresentados alguns casos de tradução.
•	 Caso	1
Pseudocódigo:
para i de 1 até 15 passo 2 faça
Linguagem C:
for( i = 1; i<=15; i=i+2)
ou
for( i = 1; i<=15; i+=2)
•	 Caso	2
Pseudocódigo:
para i de 3 até 15 faça
Linguagem C:
for( i = 3; i<=15; i++)
ou
for( i = 3; i<=15; i=i+1)
•	 Caso	3
Pseudocódigo:
para j de 20 até 10 passo -1 faça
Linguagem C:
for( j = 20; j>=10; i--)
ou
for( j = 20; j>=10; i=i-1)
254
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
A tradução do programa utilizado na explicação fica:
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
#include <stdio.h>
void main ()
{
..int i;
 
..for(i=1; i<=7; i+=2){
 ..printf(“%d\n”,i);
 }
}
A saída do programa fica:
Figura 259 – Saída do programa usado como exemplo
 Lembrete
Vimos anteriormente que .i++ é equivalente a i=i+1, e i+=2 corresponde 
a i=i+2
A tradução do programa do fatorial utilizando para fica:
algoritmo “fatorial”
var
 fat, i, n:inteiro
inicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 escreva(fat)
fimalgoritmo
#include <stdio.h>
void main ()
{
 int fat,i,n;
 scanf(“%d”,&n);
 fat=1;
 for(i=1;i<=n;i++){
 fat*=i;
 }
 printf(“%d\n”,fat);
}
255
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
A saída desse exemplo é:
Figura 260 – Saída do programa fatorial
 resumo
Os laços de repetição foram o assunto da Unidade IV. Vimos inicialmente 
os laços condicionais, aqueles em que um bloco é repetido inúmeras 
vezes, porém não sabemos quando será interrompido. Nessa categoria se 
encaixam os laços repita até que e enquanto faça. A grande diferença 
entre ambos é que o teste da condição do primeiro acontece no final do 
bloco; assim, a primeira iteração (ou ciclo) é sempre realizada. No segundo, 
como a condição é testada no início, ao entrar no laço, se a condição não 
for satisfeita, a iteração sequer será realizada, e assim sucessivamente, 
sempre com o teste feito no início do bloco.
Depois, vimos o laço contado, aquele que é utilizado quando sabemos com 
antecedência quantas iterações serão necessárias. Esse laço se chama para até 
e, usando uma variável de controle, automaticamente, controla o incremento 
das execuções do bloco e testa a condição de término das iterações.
Compreendidos os conceitos de laços e vistos os comandos, passamos à 
tradução para a linguagem C. A estrutura do repita até que, na linguagem C, 
muda um pouco na verificação da condição de fim de laço. Em algoritmo, o laço 
acontece até que um certo evento ocorra,e na linguagem C o laço acontece 
enquanto um evento é executado. Em C, esse comando é: do { } while (condição).
A estrutura do enquanto funciona exatamente da mesma forma, tanto 
no algoritmo quando na linguagem C. O enquanto (condição fimenquanto) 
é traduzido em while (condição) { };.
O laço contado em C é escrito com três parâmetros: o primeiro inicializa 
a variável de controle, o segundo é a expressão lógica que determinará 
o encerramento do laço e o terceiro é a expressão do incremento a ser 
realizado. Assim, o comando que faz o laço contado fica: for (<início de 
controle>; <condição de encerramento>; <incremento>).
256
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
 exercícios
Questão 1. O programa a seguir é o protótipo para a implementação de uma lista de opções.
#include <stdio.h>
void main(){
 int opcao;
 do{
 printf(“Informe a opção 1, 2 ou 3 (-1 para sair): “);
 scanf(“%d”,&opcao);
 switch (opcao){
 case 1: printf(“Executando a opção 1”);
 break;
 case 2: printf(“Executando a opção 2”);
 break;
 case 3: printf(“Executando a opção 3”);
 break;
 }
 }while(_________________);
}
Seguindo as instruções que serão mostradas na tela, assinale a alternativa que contém a instrução 
que deverá ser colocada na condição do laço para que o programa execute corretamente:
A) opcao<>-1
B) opcao==-1
C) opcao==1
D) opcao=1
E) opcao!=-1
Resposta correta: alternativa E.
Análise das alternativas
No laço repita da linguagem C, o laço acontecerá enquanto a condição for verdadeira. É necessário 
que a condição seja verdadeira para 1, 2 e 3, a fim de permanecer no laço, e que seja falsa para -1, a fim 
de sair do laço.
A) Alternativa incorreta.
257
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Justificativa: na linguagem C não existe o operador <>.
B) Alternativa incorreta.
Justificativa: no caso da condição opcao==-1, o laço somente continuará se a condição for igual a 
-1, ou seja, o inverso do que esperamos.
C) Alternativa incorreta.
Justificativa: com a opcao==1, o programa somente continuará no laço se for 1, saindo para qualquer 
outro número.
D) Alternativa incorreta.
Justificativa: opcao=1 é uma operação de atribuição, e não de comparação; assim, o programa 
sequer compila, acusando erro.
E) Alternativa correta.
Justificativa: o laço somente será encerrado quando opcao for igual a -1, retornando para executar 
para qualquer valor diferente de -1. Lembrando também que o operador diferente de é !=.
Questão 2. Considere o trecho a seguir:
para K de 1 ate I passo 5 faça
 . <instruções>
Fimpara
Esse trecho pode ser substituído por:
A) I <- 1;
enquanto (K <=I)
 <instruções>
 K<-K+1
fimenquanto
B) K = 1;
enquanto (I <=K)
 <instruções>
 I<-I+5
fimenquanto
C) K = 5;
enquanto (K <=I)
 <instruções>
 K<-K+1
Fimenquanto
258
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
D) K = 1;
enquanto (I <K)
 <instruções>
 k<-k+5
fimenquanto
E) K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
Resposta correta: alternativa E.
Análise das alternativas
Em primeiro lugar, vamos fazer o teste de mesa para o laço proposto.
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
Figura 261 
Passo 1: I recebe 6.
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
Figura 262 
259
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Passo 2: a variável de controle K é inicializada.
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
Figura 263 
Passo 3: é feita a comparação K<=I, 1<=6 – Verdadeiro. 
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
Figura 264 
Passo 4: as instruções são executadas.
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
6
Figura 265 
260
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
Passo 5: é feito o incremento na variável de controle K; como o passo é 5, K<-K+5. 
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
6
Figura 266 
Passo 6 : é feita a comparação K<=I, 6<=6 – Verdadeiro. 
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
6
Figura 267 
Passo 7: as instruções são executadas. 
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
6
11
Figura 268 
261
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Passo 8: é feito o incremento na variável de controle K; como o passo é 5, K<-K+5. 
I<-6
para K de 1 ate I passo 5 faça
 . <instruções>
fimpara
I
6
K
1
6
11
Figura 269 
Passo 9 : é feita a comparação K<=I, 11<=6 – Falso, e o laço é encerrado. 
Vamos comparar cada alternativa com o teste de mesa, colocando a inicialização para a variável I, 
conforme fizemos com o problema proposto.
A) Alternativa incorreta.
Justificativa:
I<-6
I <- 1;
enquanto (K <=I)
 <instruções>
 K<-K+1
fimenquanto
I
6
K
Figura 270 
Passo 1: I recebe 6. 
I<-6
I <- 1;
enquanto (K <=I)
 <instruções>
 K<-K+1
fimenquanto
262
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
I
6
1
K
Figura 271 
Passo 2: I recebe 1. Não confere com o teste de mesa. 
B) Alternativa incorreta.
Justificativa:
I<-6
K = 1;
enquanto (I <=K)
 <instruções>
 I<-I+5
fimenquanto
I
6
K
Figura 272 
Passo 1: I recebe 6.
I<-6
K = 1;
enquanto (I <=K)
 <instruções>
 I<-I+5
fimenquanto
I
6
K
1
Figura 273 
263
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Passo 2: I recebe 6. 
I<-6
K = 1;
enquanto (I <=K)
 <instruções>
 I<-I+5
fimenquanto
I
6
K
1
Figura 274 
Passo 3: é feita a comparação I<=K. No teste de mesa da proposição, a comparação é co K<=I, 
portanto essa opção está incorreta. 
C) Alternativa incorreta.
Justificativa:
I<-6
K = 5;
enquanto (K <=I)
 <instruções>
 K<-K+1
Fimenquanto
I
6
K
Figura 275 
Passo 1: I recebe 6.
I<-6
K = 5;
enquanto (K <=I)
 <instruções>
 K<-K+1
Fimenquanto
264
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
I
6
K
5
Figura 276 
Passo 2: K recebe 5; não confere com o teste, pois no Passo 2 a variável recebe 1. 
D) Alternativa incorreta.
Justificativa:
I<-6
K = 1;
enquanto (I <K)
 <instruções>
 k<-k+5
fimenquanto
I
6
K
Figura 277 
Passo 1: I recebe 6. 
I<-6
K = 1;
enquanto (I <K)
 <instruções>
 k<-k+5
fimenquanto
I
6
K
1
Figura 278 
265
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Passo 2: K recebe 1.
I<-6
K = 1;
enquanto (I <K)
 <instruções>
 k<-k+5
fimenquanto
I
6
K
1
Figura 279 
Passo 3: é feita a comparação I<K; no teste, a comparação é I<=K, portanto não confere. 
E) Alternativa correta.
Justificativa:
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
I
6
K
Figura 280 
Passo 1: I recebe 6. 
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
266
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
I
6
K
1
Figura 281 
Passo 2: a variável de controle K é inicializada.
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
I
6
K
1
Figura 282 
Passo 3: é feita a comparação K<=I, 1<=6 – Verdadeiro. 
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
I
6
K
1
Figura 283 
Passo 4: as instruções são executadas. 
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
267
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
I
6
K
1
6
Figura 284 
Passo 5: é feito o incremento na variável de controle K; como o passo é 5, K<-K+5.
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
I
6
K
1
6
Figura 285 
Passo 6: é feita a comparação K<=I, 6<=6 – Verdadeiro. 
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
I
6
K
1
6
Figura 286 
Passo 7: as instruções são executadas. 
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
268
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade IV
I
6
K
1
6
11
Figura 287 
Passo 8: é feito o incremento na variável de controle K; como o passo é 5, K<-K+5. 
I<-6
K = 1;
enquanto (K<=I)
 <instruções>
 K<-K+5
fimenquanto
I
6
K
1
6
11
Figura 288 
Passo 9: é feita a comparação K<=I, 11<=6 – Falso, e o laço é encerrado. 
A alternativa E segue exatamente os mesmos passos do enunciado proposto, portanto está correta.
269
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Unidade V
Até aqui, vimos os comandos que permitem desenvolver a lógica da programação. Essa lógica só 
é desenvolvida pela experiência de resolver desafios cada vez mais complexos. As ferramentas foram 
apresentadas. A partir desta unidade, passaremos a estudar o uso dessa lógica de forma que otimize a 
programação e manipule os dados. Será praticamente um processo de estudo de casos. Gradualmente, 
deixaremos de utilizar o pseudocódigo para nos aprofundarmos na linguagem C, pois será necessário o 
entendimento técnico das situações que serão apresentadas.
5 Estrutura dE dados
Como as informações estão organizadas dentro do computador, dentro das pastas, dentro dos 
arquivos? Os dados, de alguma forma, deverão estar dispostos para que seja possível realizar a escrita e 
a sua posterior recuperação de forma íntegra. Assim, as estruturas de dados são formas otimizadas de 
armazenamento e tratamento das informações eletronicamente.
5.1 dados homogêneos
Uma estrutura de dados que utiliza somente um tipo de dado é conhecida como de dados homogêneos. 
Variáveis compostas homogêneas são aquelas em que as posições de memória são identificadas por um 
mesmo nome e individualizadas por índices, e todos os conteúdos são compostos pelo mesmo tipo. Assim 
como vimos anteriormente os vetores (também conhecidos como estruturas de dados unidimensionais) 
e as matrizes (estruturas de dados bidimensionais), segue a estrutura dos dados homogêneos.
5.1.1 Vetores, strings e matrizes
A forma mais simples de estruturar um conjunto de dados é por meio de vetores. Utilizamos os vetores 
quando temos muitas variáveis do mesmo tipo em um programa. Podemos imaginar o vetor como uma 
“fila” de variáveis do mesmo tipo e do mesmo nome que são identificadas por um número sequencial. Assim, 
podemos definir um vetor como um conjunto de variáveis exatamente do mesmo tipo que armazena, cada 
um associado a um número, que se refere à posição de armazenamento e é conhecido como índice.
Cada posição do vetor pode ser acessada individualmente de forma direta, podendo ser lida ou 
escrita diretamente, como uma variável, conforme vimos aprendendo, e sem obedecer a nenhuma regra 
ou ordem preestabelecida. Assim, os vetores podem ter acesso aleatório.
Segundo Laureano (2008):
O vetor é uma estrutura de dados linear que necessita de somente um índice 
para que seus elementos sejam endereçados. É utilizado para armazenar uma 
270
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
lista de valores do mesmo tipo, ou seja, o tipo vetor permite armazenar mais de 
um valor em uma mesma variável. Um dado vetor é definido como tendo um 
número fixo de células idênticas (seu conteúdo é dividido em posições). Cada 
célula armazena um e somente um dos valores de dados do vetor. Cada uma 
das células de um vetor possui seu próprio endereço, ou índice, através do qual 
pode ser referenciada. Nessa estrutura todos os elementos são do mesmo tipo, e 
cada um pode receber um valor diferente. Algumas características do tipo vetor:
•	 alocação	estática	(devem-se	conhecer	as	dimensões	da	estrutura	no	
momento da declaração)
— estrutura homogênea;
•	 alocação	sequencial	(bytes contíguos)
— inserção/exclusão;
— realocação dos elementos;
— posição de memória não liberada (LAUREANO, 2008, p. 2).
5,5 6,0 7,0 2,5 10,0 9,5 8,0
1 2 3 4 5 6 7
elementos
índices
Vetor: notas
Figura 289 – Vetor contendo notas
Nessa figura, temos um vetor de sete posições preenchido com notas. Assim, por exemplo, no 
elemento de índice 4, temos como conteúdo a nota 2,5; num outro caso, o elemento de índice 6, temos 
a nota 9,5. Assim, no pseudocódigo, declaramos o vetor conforme segue.
Sintaxe:
<nome>:vetor[inicio..fim] de tipo
A declaração do vetor ilustrado anteriormente fica:
algoritmo “classe”
var
 notas:vetor[1..7] de real
inicio
.
.
fimalgoritmo
271
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Para fazermos uma atribuição de um elemento do vetor a uma variável, utilizamos a seguinte sintaxe:
<variável> <- <nome>[índice]
Assim, se fizermos a atribuição NotaPedro<-notas[3], a variável NotaPedro passará a armazenar 
o valor 7,0.
Para fazermos a atribuição de um valor a um elemento do vetor, utilizamos a seguinte sintaxe:
<nome>[índice]<-valor
Se fizermos a atribuição notas[4]<-8,0, o vetor será:
5,5 6,0 7,0 8,0 10,0 9,5 8,0
1 2 3 4 5 6 7
elementos
índices
Vetor: notas
Figura 290 – Nova situação do vetor
Exemplo de aplicação
Faça um programa que leia três temperaturas. Em seguida, calcule a temperatura média e a diferença 
de temperatura de cada uma delas em relação à média.
Resolução:
Caso fosse pedido um programa para calcular somente a temperatura média, teríamos apenas de 
fazer uma soma simples e dividir por 3.
soma<-0
para i de 1 até 3 faça
 leia(t)
 soma<-soma+t 
fimpara
media<-soma/3
O problema, contudo, pede para mostrar a diferença de cada temperaturaem relação 
à média. Não temos como fazer a diferença em apenas um laço, pois a média somente será 
calculada após a digitação da última temperatura. Assim, já na primeira entrada, é impossível 
saber a temperatura média, e, se calcularmos a diferença após a última entrada, a informação da 
primeira temperatura já terá sido apagada. Para solucionarmos esse problema, precisamos usar 
o vetor, pois dessa forma temos como armazenar e recuperar cada uma das temperaturas dadas 
como entrada.
272
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
var
 t: vetor[1..3] de real
inicio
soma<-0
para i de 1 até 3 faça
 leia(t[i])
 soma<-soma+t[i] 
fimpara
media<-soma/3
.
.
.
Uma vez calculada a média, poderemos calcular a diferença de cada temperatura com relação à média.
para i de 1 até 3 faça
 escreva(“diferença “,i,” e “,media-t[i])
fimpara
O pseudocódigo inteiro será:
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
273
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Fazendo o teste de mesa para as temperaturas 9° C, 18° C e 21° C:
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
Figura 291 – A memória do programa Temperatura é 
inicializada
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
274
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
Figura 292 – Colocação das variáveis na memória
As variáveis são colocadas na memória. A variável t tem três posições, pois é um vetor.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
0
Figura 293 – Iniciando a variável soma
Ao iniciar o programa, a variável soma é inicializada com zero, pois ele irá totalizar as 
temperaturas digitadas.
275
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
1 0
Figura 294 – Início do laço
O laço se inicia atribuindo o valor inicial à variável de controle i.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
V
276
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Memoria:Temperatura
t i soma media tela1 2 3
1 0
Figura 295 – Execução do laço
Como i<=3, o laço é executado.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
1 0 digite a 
temperatura 1
Figura 296 – Nova execução do laço
Como i <=3, o laço é executado novamente.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
277
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 1 0 digite a 
temperatura 1
9
Figura 297 – Realização da primeira leitura
A primeira leitura é feita. O valor digitado será atribuído à variável t[i]. Como o conteúdo de i é 1, 
será armazenado na posição t[1].
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
278
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Memoria:Temperatura
t i soma media tela1 2 3
9 1 9 digite a 
temperatura 1
9
Figura 298 – Exibição do valor da soma
A soma acumula o valor de t[i].
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 1
2
9 digite a 
temperatura 1
9
Figura 299 – Atualização da variável de controle 
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna parao controle 
do laço.
279
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
V
Memoria:Temperatura
t i soma media tela1 2 3
9 1
2
9 digite a 
temperatura 1
9
Figura 300 – Continuação do fluxo no laço
Como i vale 2, então o fluxo prossegue dentro do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
280
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Memoria:Temperatura
t i soma media tela1 2 3
9 18 1
2
0 digite a 
temperatura 9
digite a 
temperatura 2
18
Figura 301 – Leitura da segunda temperatura
A leitura da segunda temperatura é feita e armazenada na posição t[2], pois a variável i vale 2.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 1
2
9
27
digite a 
temperatura 1
9
digite a 
temperatura 2
18
Figura 302 – A variável soma acumula o segundo dado
281
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 1
2
3
9
27
digite a 
temperatura 1
9
digite a 
temperatura 2
18
Figura 303 – Atualização da variável de controle
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna para o controle 
do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
V
282
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Memoria:Temperatura
t i soma media tela1 2 3
9 18 1
2
3
9
27
digite a 
temperatura 1
9
digite a 
temperatura 2
18
Figura 304 – Mais uma iteração é realizada
Como 3<=3, é feita mais uma iteração.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
9
27
digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Figura 305 – Armazenamento do valor digitado
O valor digitado é armazenado na posição t [3].
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
283
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
9
27
48
digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Figura 306 – Acumulação do valor digitado
O valor digitado é acumulado na variável soma.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
284
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
9
27
48
digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Figura 307 – Atualização da variável de controle
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna para o controle 
do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
F
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
9
27
48
digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Figura 308 – O fluxo sai do laço.
285
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Como 4>3, o fluxo do programa sairá do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21Figura 309 – O programa executa o próximo comando
Ao sair do laço, o programa prossegue executando o comando seguinte, no caso, o cálculo da média 
(48/3).
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
286
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Figura 310 – Atualização da variável de controle
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna para o controle 
do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
287
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Figura 311 – Abertura de um novo laço
Uma vez calculada a média, temos condição de calcular as diferenças de temperatura uma a uma. 
Para isso, novo laço é aberto, utilizando a mesma variável de controle (i).
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
Fimalgoritmo
V
 
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Figura 312 – Como i é menor ou igual a 3, o laço é executado
288
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Figura 313 – A primeira diferença é mostrada
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
289
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Figura 314 – Atualização da variável de controle
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna para o controle 
do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
Fimalgoritmo
V
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Figura 315 – Nova execução do laço
290
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Como 2<3, o laço é novamente executado.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Diferença 2 eh -2
Figura 316 – Apresentação do resultado
O programa apresenta o resultado de media	–	t[2],	ou	seja,	16	-	18.
291
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
3
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Diferença 2 eh -2
Figura 317 – Atualização da variável de controle
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna para o controle 
do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
292
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])fimpara
fimalgoritmo
V
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
3
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Diferença 2 eh -2
Figura 318 – Como a condição é Verdadeira, o laço será executado novamente
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
293
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
3
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Diferença 2 eh -2
Diferença 3 eh 5
Figura 319 – A terceira diferença de temperatura é exibida
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
3
4
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Diferença 2 eh -2
Diferença 3 eh 5
Figura 320 – Atualização da variável de controle
294
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Ao encontrar o fimpara, o programa atualiza a variável de controle, e o fluxo retorna para o controle 
do laço.
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura “,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
F
Memoria:Temperatura
t i soma media tela1 2 3
9 18 21 1
2
3
4
1
2
3
4
9
27
48
16 digite a 
temperatura 1
9
digite a 
temperatura 2
18
digite a 
temperatura 3
21
Media das 
temperaturas 16
Diferença 1 eh 7
Diferença 2 eh -2
Diferença 3 eh 5
Figura 321 – Encerramento do laço e passagem para a próxima instrução
Como o conteúdo da variável de controle é maior que o limite, o laço é encerrado, e o fluxo do 
programa executa a instrução seguinte, no caso, a informação do final de programa.
5.1.2 Vetores em C
Definimos um vetor em C da seguinte forma:
int v[10];
295
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 observação
Devemos tomar cuidado, pois o índice do vetor na linguagem C sempre 
se inicia em zero.
Assim, na declaração anterior, os elementos vão de v[0] até v[9].
Outra característica é que os vetores também podem ser inicializados na declaração:
 int v[8] = { 15, 1,0,3, 5, 7, 8, 59 };
Ou simplesmente:
int v[] = { 15, 1,0, 3, 5, 7,8, 59 };
Assim, o programa aloca, automaticamente, cinco espaços de inteiros na memória.
Traduzindo o programa que lê três temperaturas e mostra a diferença de cada uma delas em relação 
à média:
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
 soma,media:real
inicio
 soma<-0
 para i de 1 ate 3 faca
 escreva(“digite a temperatura 
“,i)
 leia(t[i])
 soma<-soma+t[i]
 fimpara
 media<-soma/3
 escreva(“Media das temperaturas”, 
media)
 para i de 1 ate 3 faca
 escreva(“diferença “,i,” eh 
“,media-t[i])
 fimpara
fimalgoritmo
#include<stdio.h>
void main(){
 float t[3];
 int i;
 float soma, media;
 soma=0;
 for(i=0;i<=2;i++){
 printf(“digite a temperatura %d 
“,i);
 scanf(“%f”,&t[i]);
 soma=soma+t[i];
 }
 media=soma/3;
 printf(“\nMedia das temperaturas 
%10.2f \n”, media);
 for(i=0;i<=2;i++)
 printf(“diferença %d eh %10.2f 
\n”, i, media-t[i],i);
}
296
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Executando o programa, temos:
Figura 322 – Saída do programa de cálculo da diferença de temperatura com relação à média
5.1.3 Matrizes
Matrizes são vetores multidimensionais; os mais comuns são os bidimensionais. Assim, a matriz 
bidimensional é uma estrutura de dados que necessita de um índice para referenciar a linha e o outro 
para referenciar a coluna e localizar o elemento da informação.
Sintaxe:
 <nome>:matriz[inicio..fim] [inicio..fim] de tipo
1 2 3 4
1 8,5 7,0 8,5 10
2 3,0 4,0 6,0 5,5
3 7,0 7,5 6,0 5,0
índices
elementos
Figura 323 – Representação de uma matriz bidimensional
A declaração da matriz ilustrada é:
algoritmo “classe”
var
 classe:matriz[1..3] [1..4] de real
inicio
.
.
.
297
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Para fazermos uma atribuição de um elemento da matriz a uma variável, utilizamos a seguinte sintaxe:
<variável> <- <nome>[indice] [indice]
Assim, se fizermos a atribuição Aluno1<-notas[1][2], a variável Aluno1 passará a armazenar o 
valor 7,0.
Para fazermos a atribuição de um valor a um elemento da matriz, utilizamos a seguinte sintaxe:
<nome>[indice] [indice]<-valor
Se fizermos a atribuição notas[3] [4]<-8,0:
1 2 3 4
1 8,5 7,0 8,5 10
2 3,0 4,0 6,0 5,5
3 7,0 7,5 6,0 8,0
índices
elementos
Figura 324 – Matriz com o elemento alterado
5.1.4 Matrizes em C
Na linguagem C, podem ser criadas matrizes bidimensionais. Assim, para declararmos uma matriz de 
valores reais com três linhas e quatro colunas, fazemos:
float classe[3][4];
Ao declararmos a matriz, o C reserva um espaço de memória para armazenar os 12 elementos da 
matriz, de maneira contínua, organizados linha a linha. Podemos então preencher a matriz na declaração:
float classe[3][4] = {{ 8.5, 7.0,8.5,10.0},{ 3.0, 4.0, 6.0, 5.5},{ 7.0, 
7.5, 6.0, 5.0}};
Como a linguagem C ignora os caracteres de quebra de linha, para ficar mais fácil de visualizar 
durante a programação, podemos escrever da seguinte forma:
float classe[3][4] = {{ 8.5, 7.0, 8.5,10.0}
,{ 3.0, 4.0, 6.0, 5.5}
,{ 7.0, 7.5, 6.0, 5.0}};
298
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Outra maneira que a linguagem C permite é declararmos sequencialmente:
float classe[3][4] = { 8.5, 7.0, 8.5, 10.0, 3.0, 4.0, 6.0, 5.5, 7.0, 7.5, 
6.0, 5.0};
Em razão da particularidade da administração da memória, também podemos escrever da 
seguinte forma:
float classe[][4] = { 8.5, 7.0, 8.5, 10.0, 3.0, 4.0, 6.0, 5.5, 7.0, 7.5, 
6.0, 5.0};
 Lembrete
Como as matrizes são um caso particular de vetores, os índices também 
se iniciam em zero.
 saiba mais
O uso típicode matrizes é o jogo da Batalha Naval. No site C Progressivo, 
é apresentado um exemplo simples do jogo numa matriz 5 x 5.
Acesse:
JOGO: Batalha Naval em C. C Progressivo, 2012. Disponível em: <http://
www.cprogressivo.net/2012/09/batalha-naval-em-c.html>.	Acesso	em:	28	
maio 2014.
5.1.5 Cadeias de caracteres em C
As cadeias de caracteres em C (strings) são representadas por vetores do tipo char terminadas, 
obrigatoriamente, pelo caractere nulo (‘\0’). Sempre que ocorrer o armazenamento de uma cadeia, 
será necessário reservar um elemento adicional para o caractere de fim da cadeia. Todas as 
funções que manipulam strings (dos quais veremos alguns) recebem como parâmetro um vetor 
de char e processam caractere por caractere, até encontrarem o caractere nulo, que sinaliza o 
final da cadeia.
Para imprimirmos uma cadeia pela função printf, é necessário o especificador de formato %s. 
A função, na verdade, recebe um vetor de char e imprime elemento por elemento, até encontrar o 
caractere nulo (‘\0’).
299
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
O exemplo a seguir ilustra a representação de uma string. Como queremos representar a palavra 
Unip, composta por quatro caracteres, declaramos um vetor com dimensão 5 (um elemento adicional 
para armazenarmos o caractere nulo no final da cadeia). O código preenche os elementos do vetor, 
incluindo o caractere ‘\0’, e imprime a palavra na tela.
#include<stdio.h>
void main ()
{
 char faculdade[5];
 faculdade [0] = ‘U’;
 faculdade [1] = ‘n’;
 faculdade [2] = ‘i’;
 faculdade [3] = ‘p’;
 faculdade [4] = ‘\0’;
 printf(“%s \n”, faculdade);
}
Ao executarmos, obtemos o seguinte resultado:
Figura 325 – Saída do programa com uma string montada em um vetor
Se o ‘\0’ não fosse colocado, a função printf não encontraria o fim da cadeia, e o programa mostraria 
os caracteres que eventualmente restam na memória até encontrar um ‘\0’.
Figura 326 – A função de impressão não reconhece o fim de caractere
5.1.6 Caracteres em C
A linguagem C não oferece especialmente um tipo caractere. Os caracteres são representados 
por números inteiros que são convertidos em caracteres no momento da exibição. O tipo char 
armazena valores inteiros do tamanho de 1 byte, 8 bits, podendo então representar valores que 
variam	de	-128	a	127.
300
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 Lembrete
A correspondência entre os caracteres e seus códigos numéricos é feita 
por uma tabela de códigos, a tabela ASCII, vista anteriormente (Tabela 6).
A diferença entre caracteres e inteiros, em C, acontece apenas no tratamentos destes. Assim, 
podemos imprimir um mesmo valor de duas formas diferentes, desde que os formatos sejam diferentes. 
Por exemplo:
#include<stdio.h>
void main ()
{
 char c = 97; 
 printf(“%d %c\n”,c,c);
}
Resulta em:
Figura 327 – Diferença entre %c e %d na saída
Como o número 97 corresponde ao caractere a, o printf, ao mostrar na tela a variável c no formato 
%d, exibe o conteúdo numérico, pois o formato é de número inteiro, e, para a letra a, quando encontra 
o formato %c, exibe o caractere correspondente ao número 97.
5.1.7 Manipulação de strings
A linguagem C, para manipular strings e caracteres, fornece algumas bibliotecas. Essas bibliotecas 
dão algumas funções extras, além do scanf e do printf, para entrada e saída de caracteres e cadeias.
•	 Função	putchar(): a função putchar() (put character) da biblioteca stdio.h imprime um caractere 
na	saída-padrão	(em	geral,	o	monitor	de	vídeo).
•	 Função	getchar(): a função getchar() (get character) da biblioteca stdio.h lê um caractere do 
teclado, ou arquivo. Se ocorrer um erro ou uma condição de “fim de arquivo” durante a leitura, 
a função retornará o valor da constante simbólica end of file (EOF) definida na biblioteca stdio.h, 
permitindo facilmente a detecção de finais de arquivos. Essa função não retorna valores até que o 
caractere de controle enter (\n) seja lido. Exemplo: o programa a seguir mostra o uso das funções 
301
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
getchar() e putchar() em um programa que lê caracteres do teclado e os reimprime convertidos 
para maiúsculos.
#include <stdio.h>
void main(){
 char c; 
 printf(“\nDigite uma frase:\n”);
 do{ 
 c = getchar(); // leitura do ‘buffer’
 if(c >= 97 && c <= 122){ // se c e’ minusculo...
 c -= 32; // ...transforma em maiusculo
 }
 putchar(c); // impressao dos caracteres maiusculos
 }while (c != ‘\n’);
}
Figura 328 – Uso do getchar e do putchar
•	 Funções	getch() e getche(): A função getch() (get character) da biblioteca stdio.h lê os códigos 
de teclado. Isso envolve não só os caracteres ASCII, mas também as teclas de comandos ([enter], 
[delete], [Page Up], [F1] etc.) ou combinações de teclas ([Alt] + [A], [Shift] + [F1], [Ctrl] + [Page 
Down] etc.). A função getch() aguarda que uma tecla, ou combinação de teclas, seja pressionada, 
recebe do teclado o código correspondente e retorna esse valor. A função getche() (get character 
and echoes), além de receber o código, ecoa, no dispositivo de saída, o caractere correspondente. 
Quando nos códigos especiais são pressionadas certas teclas, ou combinações destas, que não 
são caracteres ASCII, o teclado envia ao buffer de entrada do computador dois códigos, sendo o 
primeiro sempre 0, seguido do código correspondente. Por exemplo, se a tecla F1 for pressionada, 
os valores 0 e 59 serão armazenados, e a função deverá ser chamada duas vezes para ler os 
dois códigos. Exemplo: um programa para a leitura de teclado que usa a função getch() para 
reconhecer teclas e combinações de teclas.
#include <conio.h>
#include <stdio.h>
void main(){
 int c,d; 
 printf(“\n Pressione uma tecla ou combinacao de teclas:”);
 printf(“\n Pressione [esc] para terminar! \n”);
302
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 do{ // faz...
 c = getch(); // leitura do primeiro codigo.
 if(c == 0){ // se for codigo extendido...
 d = getch(); // le segundo codigo.
 printf(“%3d %3d codigo extendido\n”,c,d);
 }
 else{ 
 printf(“%3d codigo normal\n”,c);
 };
 }while (c != 27); // ...enquanto nao for [esc]
}
Ao	digitarmos	Ctrl-Alt-x	e	depois	o	caractere	u	e	a	tecla	Esc,	teremos	o	seguinte	resultado:
Figura 329 – Uso do getch
•	 Função	puts (): a função puts () (put string) da biblioteca stdio.h mostra uma string na tela 
acrescentando um enter (\n) ao final.
•	 Função	gets(): a função gets()(get string) da biblioteca stdio.h lê uma string do teclado até o 
operador digitar o enter. Exemplo:
#include <stdio.h>
void main()
{
 char cadeia[256];
 printf (“Escreva o seu nome: “);
 gets(cadeia);
 puts(cadeia);
}.
Testando com o exemplo Joaquim Santos, temos:
303
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Figura 330 – Saída usando gets e puts
•	 Função	strlen(): a função strlen() (string length), da biblioteca string.h, retorna o tamanho de uma 
cadeia. Conta a quantidadede caracteres até encontrar um nulo (\0) e não o conta. Exemplo: o 
programa retorna o tamanho da cadeia digitada.
#include <stdio.h>
#include <string.h>
void main(){
 int tam;
 char str[100];
 printf(“Digite string:”);
 gets(str);
 tam=strlen(str);
 printf(“Tamanho da string eh: %d\n”, tam);
}
A biblioteca usada é a string.h. O resultado é:
Figura 331 – Contando a quantidade de caracteres
•	 Função	strcat(): a função strcat() (string concatenate), da biblioteca string.h, tem duas cadeias 
concatenadas (unidas uma após a outra). A função recebe duas strings como argumento e copia 
a segunda string no final da primeira. Exemplo: fazer um programa que junte duas cadeias.
#include <string.h>
#include <stdio.h>
void main(){
 char cadeia1[100], cadeia2[50];
 puts (“Digite String1: “);
 gets(cadeia1);
 puts(“Digite String2”);
304
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 gets(cadeia2);
 strcat(cadeia1, cadeia2);
 puts(cadeia1);
}
Figura 332 – Fazendo a concatenação de caracteres
•	 Função	strcpy(): O strcpy (string copy) é uma função da biblioteca string.h que copia uma string 
em uma variável. Ao contrário da função strcat, que faz a concatenação, essa função sobrescreve 
a cadeia caso esta já tenha um valor armazenado. Exemplo:
#include <string.h>
#include <stdio.h>
void main(){
 char str1[100], str2[100], str3[100];
 puts (“Digite string: “);
 gets(str1);
 strcpy(str2, str1);
 strcpy(str3, “Você digitou string:”);
 printf(“%s %s\n”, str3, str2);
}
Nesse programa, a saída é dada por duas variáveis, e nenhuma delas foi a variável em que foi dada 
a entrada. O resultado do programa é:
Figura 333 – Saída da função strcpy
•	 Função	strcmp(): na função strcmp() (string compare), da biblioteca string.h, duas cadeias são 
comparadas. A comparação é feita caractere a caractere, até encontrar a primeira diferença entre 
eles; conforme a diferença, a função devolve um valor diferente, usando o seguinte critério:
305
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
— < 0, se cadeia1 < cadeia2;
— = 0, se cadeia1 = cadeia2;
— >0, se cadeia1 > cadeia2.
Exemplo de aplicação
Executar o programa a seguir:
#include <stdio.h>
#include <string.h>
void main(){
 printf(“%d \n”, strcmp (“A”, “A”));
 printf(“%d \n”, strcmp (“A”, “B”));
 printf(“%d \n”, strcmp (“B”, “A”));
 printf(“%d \n”, strcmp (“C”, “A”));
}
Resultado:
Figura 334 – Comparações entre caracteres
5.2 dados heterogêneos
Uma estrutura de dados é chamada de heterogênea quando envolve a utilização de mais de um tipo 
básico de dado, que é chamado de registro, em certos casos.
Segundo Laureano (2008),
um registro é uma estrutura de dados que agrupa dados de tipos distintos. 
Um registro de dados é composto por certo número de campos de dados, 
que são itens de dados individuais. Registros são conjuntos de dados 
logicamente relacionados, mas de tipos diferentes (numéricos, lógicos, 
caractere etc.) [, 1, 4] (LAUREANO, 2008, p. 16).
306
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Assim como existem tipos predefinidos, como inteiro, real, cadeia e lógico, podemos dizer que, ao 
usarmos registros, estamos criando um novo tipo de dado. Assim, antes da declaração das variáveis, 
temos de definir os novos tipos que estão sendo criados para depois serem declarados como variáveis.
Sintaxe:
Tipo IDENTIFICADOR = registro
 campo1 : tipo;
 campo2 : tipo;
 campoN : tipo;
fimregistro;
var
 variável : IDENTIFICADOR;
Onde:
•	 IDENTIFICADOR:	representa	o	nome	associado	ao	tipo	registro	construído;
•	 campo1,	campo2,	campoN:	são	os	nomes	associados	a	cada	campo	do	registro.
Da mesma forma que na declaração de vetores e matrizes, primeiro, devemos criar um tipo, para 
então declararmos as variáveis desse tipo.
Para	atribuirmos	ou	recebermos	valores,	referimo-nos	às	variáveis	na	forma:
 variável.campo
Por exemplo:
Algoritmo ”classe”
Tipo ficha = registro
 Nome : cadeia;
 sexo : Caracter;
 Idade : inteiro;
fimregistro;
var
 Aluno, Professor : Ficha;
inicio
 Aluno.nome<-”Elomar”;
 Professor.Nome<-”Olavo”;
 escreva(professor.nome,aluno.nome);
fimalgoritmo.
307
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
5.2.1 Estrutura em C
Em C, o tipo registro é conhecido como estrutura. Uma estrutura em C serve basicamente para agrupar 
diversas variáveis em um único contexto. A sintaxe para a definição de uma estrutura é mostrada a seguir:
struct <nome> {
 tipo <nome1>;
 tipo <nome2>;
 tipo <nome3>;
 tipo <nome4>;
};
Exemplo de aplicação
Definir um tipo que represente um ponto no plano cartesiano:
struct ponto {
 float x;
 float y;
};
A estrutura, uma vez criada, passa a ser utilizável dentro do programa, atuando como variáveis.
 typedef struct <nome da estrutura> <var1>, <var2> ... ;
Utilizando a estrutura do ponto, fazer um triângulo com os pontos p1 = (0,0), p2 = (1,1) e p3 = (1,0) 
no plano cartesiano.
#include <stdio.h>
struct ponto {
 float x;
 float y;
};
void main(){
 typedef struct ponto p1,p2,p3;
 p1.x=0;
 p1.y=0;
 p2.x=1;
 p2.y=1;
 p3.x=1;
 p3.y=0;
}
308
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 observação
Em razão da forma pela qual a linguagem C processa o programa, a 
criação e a declaração de um registro e de suas variáveis podem ser feitas 
da seguinte maneira:
typedef truct ponto {
 float x;
 float y;
}p1, p2, p3;
5.2.2 Tipo união
As uniões são usadas quando armazenamos valores de tipos diferentes compartilhando um mesmo 
espaço de memória.
union exemplo {
 int i; 
 char c;
}
Assim como na declaração da estrutura, a declaração da união não declara nenhuma variável, apenas 
define o tipo união. Assim, uma vez definida a união, é necessário declaramos variáveis do tipo união:
 union exemplo v;
Na variável v, os campos i e c usam o mesmo espaço de memória.
O	operador	ponto	(.)	é	usado	para	acessar	diretamente	a	variável,	e	o	operador	seta	(->),	para	acessá-
los por meio de um ponteiro (que veremos mais adiante).
 v.i = 10;
ou
 v.c = ‘x’;
5.3 Modularização
Quando	temos	um	programa	muito	grande,	muitas	vezes,	torna-se	difícil	acompanharmos	a	lógica	
ali empregada. Com o uso das funções, podemos dividir grandes tarefas de computação em tarefas 
menores. A criação de funções evita a repetição de código. Quando um procedimento é repetido 
309
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
diversas vezes, deve ser transformado numa função, que será chamada diversas vezes. Um programa 
bem-estruturado	deve	ser	pensado	no	que	se	refere	a	funções	fora	do	corpo	principal	do	programa.	Tal	
processo se chama modularização.
5.3.1 Teoria
Imaginemos um programa que repete várias vezes uma sequência que limpa a tela, desenha um 
logotipo nessa tela e apresenta o nome do usuário em um canto da mesma tela durante a execução de 
um programa.
Programa principal
.
.
Limpa a tela
Desenha imagens
Mostra o nome do Usuario
.
.
Limpa a tela
Desenhaimagens
Mostra o nome do Usuario
.
.
Limpa a tela
Desenha imagens
Mostra o nome do Usuario.
.
.
Como existe constante repetição, podemos fazer o processo de modularização, criando um pequeno 
programa com a sequência de limpar a tela, desenhar as imagens e mostrar o nome do usuário, e 
chamá-lo	do	programa	principal.
310
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Procedimento MontaTela
 Limpa a tela
 Desenha as margens
 Mostra o nome do usuario
Programa principal
 .
 .
 .
 Montatela
 .
 .
 .
 Montatela
 .
 .
 .
 Montatela
Dessa forma, o programa principal fica mais limpo, pois as instruções repetitivas e desnecessárias 
estão no procedimento.
5.3.2 Funções e procedimentos
A diferença entre uma função e um procedimento é o fato de a função retornar um valor, e o 
procedimento, não.
No pseudocódigo o procedimento é declarado antes do início do programa principal.
Algoritmo “<nome do algoritmo>”
Var 
 <declaração de variáveis do algoritmo>
procedimento <nome> (<lista de parâmetros>:<tipos dos parâmetros>)
inicio 
 comandos
fimprocedimento
Inicio 
 comandos
fimalgoritmo
Veja o algoritmo a seguir, que utiliza um procedimento que calcula a área de um triângulo:
311
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
algoritmo “Procedimentos”
var
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Assim, para fazermos o teste de mesa:
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Pilha Tela
Memoria Procedimentos Pilha
Figura 335 – Início do fluxo do programa
312
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
O fluxo do programa se inicia no algoritmo principal. Existe uma nova coluna chamada pilha. 
Nesse programa, ela não terá tanta importância, mas será muito importante em programas futuros, 
mais complexos.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Pilha Tela
Memoria Procedimentos Pilha
Figura 336 – Execução da primeira instrução
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
313
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Pilha Tela
Memoria Procedimentos Pilha
areatri (2,6)
Figura 337 – Estabelecimento dos parâmetros
O programa chama o procedimento, passando 2 como primeiro parâmetro e 6 como segundo 
parâmetro.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri
h b
2 6
Pilha Tela
Memoria Procedimentos Pilha
areatri (2,6)
Figura 338 – Abertura da área de memória
314
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
O programa abre uma área de memória criando as variáveis que recebe como parâmetros do 
programa que o chama e passa a executar o procedimento.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri
h b area
2 6
Pilha Tela
Memoria Procedimentos Pilha
areatri (2,6)
Figura 339 – Criação das variáveis na memória
Como em qualquer programa, as variáveis declaradas no procedimento são criadas na memória.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
315
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria areatri
h b area
2 6 6
Pilha Tela
Memoria Procedimentos Pilha
areatri (2,6)
Figura 340 – O procedimento executa o primeiro comando
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri
h b area
2 6 6
Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
Figura 341 – Escrita do resultado
O fluxo segue para o segundo comando, escrevendo o resultado na tela.
316
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
Figura 342 – Liberação da memória e eliminação da 
chamada do programa principal
Com o fim do procedimento, a memória é liberada, e a chamada do programa principal é eliminada 
da pilha.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
317
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria areatri Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 343 – Chamada do procedimento e mudança dos parâmetros
No comando seguinte do programa principal, novamente, o procedimento areatri é chamado, 
passando como parâmetros 4 e 6.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri
h b
4 6
Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 344 – Criação da memória e estabelecimento de parâmetros
318
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
O programa cria a memória areatri e as suas variáveis, que vieram como parâmetros.
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri
h b area
4 6
Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 345 – A variável área é criada no procedimento areatri
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
319
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria areatri
h b area
4 6 12
Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 346 – O cálculo é executado
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Memoria areatri
h b area
4 6 12
Pilha Tela
6
12
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 347 – O resultado é exibido na tela
320
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
procedimento areatri (h,b : real) //declaração do procedimento
var
 area:real
inicio
 area <- (b*h)/2
 escreva(area)
fimprocedimento
algoritmo “Procedimentos”
var
inicio
 areatri(2,6) //chamada ao procedimento
 areatri(4,6) //chamada ao procedimento
fimalgoritmo
Pilha Tela
6
12
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 348 – O programa é encerrado
 observação
Muitas	vezes,	já	tínhamos	usado	funções	e	procedimentos	sem	nomeá-
los. Assim, comandos como leia() e escreva() são, na verdade, procedimentos 
em que a programação já vem feita na biblioteca básica de uma linguagem.
 Lembrete
A diferença entre função e procedimento é o fato de a função retornar 
um valor.
É importante a declaração do tipo de valor que uma função retorna. Uma função não pode ora 
retorna um número, ora retornar uma cadeia. Em virtude desse fato, é obrigatório declarar no cabeçalho 
da função qual o tipo que esta retorna.
321
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Sintaxe:
Algoritmo “<nome do algoritmo>”
Var
 <declaração de variáveis do algoritmo>
Função <nome> (<parâm1>:<tipo>,<parâm2>:<tipo>): <tipo de retorno>
Var
 <declaração das variáveis locais da função>
Inicio
 <comandos>
 retorne <valor de retorno>
fimfuncao
Inicio
 <corpo do algoritmo>
fimalgoritmo
No fim do cabeçalho da função, é feita a declaração do tipo de retorno. Esse tipo de retorno deve 
corresponder ao tipo do valor de retorno.
O uso da função a partir desse ponto passará a ser crucial no curso, pois esta passará a fazer parte 
da estrutura de quase todos os programas.
Exemplo de aplicação
Fazer um programa para calcular a quantidade de combinações simples.
A fórmula matemática da combinação é:
C
a,b
 = a! 
 b!(a – b)!
Assim, tomando a combinação de três elementos dois a dois, temos:
C3,2 = 3! = 3
 2!(3 – 2)!
Se	 considerarmos	 o	 conjunto	 de	 combinações	 de	 três	 letras	 (a,	 b,	 c)	 tomando-as	 duas	 a	 duas,	
independentemente da ordem, teremos (a, b), (a, c) e (b, c), ou seja, três.
322
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Para montarmos o programa, como já vimos em laços, podemos montar os três fatoriais (a!, b! e 
(a-b)!)	e	fazer	as	operações	entre	eles.
O programa montado da forma tradicional ficará:
algoritmo “Combinacao”
var
 a,b,fat,fata,fatb,fatab,i:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 fat<-1
 para i de 1 ate a faca
 fat<-fat*i
 fimpara
 fata<-fat
 fat<-1
 para i de 1 ate b faca
 fat<-fat*i
 fimpara
 fatb<-fat
 fat<-1
 para i de 1 ate a-b faca
 fat<-fat*i
 fimpara
 fatab<-fat
 combinacao<-fata/(fatb*fatab)
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Em caso de dúvida, a proposta é fazer um teste de mesa. Supondo que o programa esteja certo, 
podemos observar que o seguinte trecho se repete durante esse programa:
 fat<-1
 para i de 1 ate ? faca
 fat<-fat*i
 fimpara
 fata<-fat
É	interessante,	portanto,	transformá-lo	em	uma	função.
Como o retorna será fat, um número inteiro, e onde está a interrogação, um número que será o 
fatorial a ser calculado, podemos montar a seguinte função:
323
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
Tipo de saida
Parâmetro de entrada
De agora em diante, sempre que necessitarmos calcular o fatorial, poderemos utilizar a função criada.
x<-fatorial(6)
x receberá o valor 720.
ou:
Escreva(fatorial(5))
O número 120 será exibido na tela. Dessa forma, podemos utilizar a função para resolver de uma 
maneira elegante o programa proposto.
algoritmo “Combinacao”
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
324
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
O programa principal é apenas:
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Isso deixa claro que o cálculo é fatorial(a)/(fatorial(b)*fatorial(a-b)), ou seja, a 
linearização de:
 a! 
 b!(a – b)!
Fazendo o teste de mesa para 3 e 2, temos:
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fatfimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
325
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Pilha Tela
Memoria: Combinação Pilha
Figura 349 – O programa principal se inicia separando a memória para ele
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Pilha Tela
Memoria: Combinação
a b combinação
Pilha
Figura 350 – As variáveis do programa principal são criadas
326
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
Figura 351 – Os valores de entrada são lidos do dispositivo de entrada
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
327
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 352 – A função fatorial é chamada com o parâmetro 3
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
328
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
Memoria fatorial
n
3
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 353 – A função fatorial reserva o seu espaço na memória e recebe o 
parâmetro de entrada
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Memoria fatorial
n i fat
3
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 354 – A função fatorial cria as suas variáveis internas
329
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Memoria: fatorial
n i fat
3 1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 355 – Na função fatorial, a variável fat é inicializada
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
330
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Memoria: fatorial
n i fat
3 1 1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 356 – A variável de controle é inicializada e, como é menor que n, o 
laço será executado
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
331
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Linguagem e Técnicas de Programação
Memoria: fatorial
n i fat
3 1 1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 357 – Fat recebe o seu próprio conteúdo multiplicado por 1
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Memoria: fatorial
n i fat
3 1
2
1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 358 – A variável de controle é incrementada
332
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/0
6/
20
14
Unidade V
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
 combinacao:real
inicio
 leia(a)
 leia(b)
 combinacao<-fatorial(a)/(fatorial(b)*fatorial(a-b))
 escreva(“combinação e “,a, “ e “,b, “ eh “, combinacao)
fimalgoritmo
Memoria: fatorial
n i fat
3 1
2
1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 359 – Como i<=n, o laço é executado
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca