Linguagem e Técnicas de Programação

Prévia do material em texto

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.
488 p., il.
Nota: este volume está publicado nos Cadernos de Estudos e 
Pesquisas da UNIP, Série Didática, ano XX, 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 ................................................................................................................. 53
2.1 Histórico ................................................................................................................................................... 54
2.2 Regras da linguagem .......................................................................................................................... 54
2.2.1 Estrutura de umprograma em C ...................................................................................................... 57
2.3 Tipos de informações, variáveis e constantes ........................................................................... 58
2.4 Operadores .............................................................................................................................................. 62
2.5 Entrada e saída de informações ..................................................................................................... 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 III
3 TOMADA DE DECISõES.................................................................................................................................. 76
3.1 Teoria ......................................................................................................................................................... 76
3.2 Condicionais ........................................................................................................................................... 76
3.2.1 Se então ...................................................................................................................................................... 76
3.2.2 Se então senão......................................................................................................................................... 84
3.2.3 Estrutura condicional se aninhada .................................................................................................. 92
3.2.4 Escolha-caso ...........................................................................................................................................121
3.3 Laboratório ............................................................................................................................................150
3.3.1 Escolha-caso na linguagem C++ .................................................................................................. 157
Unidade IV
4 LAçOS DE REPETIçãO ..................................................................................................................................165
4.1 Teoria .......................................................................................................................................................165
4.1.1 Laços condicionais ............................................................................................................................... 165
4.1.2 Laços contados ..................................................................................................................................... 208
4.2 Laboratório ............................................................................................................................................227
4.2.1 Repita até que ....................................................................................................................................... 227
4.2.2 Enquanto faça ....................................................................................................................................... 229
4.2.3 Para até que ............................................................................................................................................231
Unidade V
5 ESTRUTURA DE DADOS ...............................................................................................................................237
5.1 Dados homogêneos ...........................................................................................................................237
5.1.1 Vetores, strings e matrizes ............................................................................................................... 237
5.1.2 Vetores em C .......................................................................................................................................... 262
5.1.3 Matrizes ................................................................................................................................................... 264
5.1.4 Matrizes em C ....................................................................................................................................... 265
5.1.5 Cadeias de caracteres em C ............................................................................................................. 266
5.1.6 Caracteres em C .................................................................................................................................... 267
5.1.7 Manipulação de strings ..................................................................................................................... 268
5.2 Dados heterogêneos..........................................................................................................................273
5.2.1 Estrutura em C ...................................................................................................................................... 275
5.2.2 Tipo união ............................................................................................................................................... 276
5.3 Modularização .....................................................................................................................................276
5.3.1 Teoria ........................................................................................................................................................ 277
5.3.2 Funções e procedimentos ................................................................................................................. 278
5.3.3 Funções e procedimentos em C ......................................................................................................319
5.3.4 Variáveis locais e variáveis globais ................................................................................................321
Unidade VI
6 ALOCAçãO DINâMICA DA MEMóRIA ...................................................................................................326
6.1 O uso da memória ..............................................................................................................................326
6.2 Ponteiro de variáveis .........................................................................................................................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
6.3 Passagem de valores por valor e por referência ....................................................................334
6.4 Passagem de vetores para funções .............................................................................................347
6.5 Funções da biblioteca-padrão .......................................................................................................348
6.6 Recursividade .......................................................................................................................................353
Unidade VII
7 ESTRUTURA UNIDIMENSIONAL, LISTAS ...............................................................................................370
7.1 Listas ligadas ........................................................................................................................................371
7.1.1 Função de inicialização ..................................................................................................................... 373
7.1.2 Função de inserção ............................................................................................................................. 374
7.1.3 Função de remoção .............................................................................................................................384
7.1.4 Função de busca, função de impressão e função de liberação de memória ............... 395
7.2 Pilhas .......................................................................................................................................................398
7.2.1 Implementação de pilha com lista – representação encadeada ...................................... 399
7.2.2 Criação da pilha com lista ................................................................................................................ 400
7.2.3 Inserção na pilha com lista ...............................................................................................................402
7.2.4 Remoção da pilha .................................................................................................................................407
7.2.5 Função de impressão e função de liberação de memória ....................................................414
7.3 Filas ..........................................................................................................................................................417
7.3.1 Implementação de fila com lista – representação encadeada ...........................................418
7.3.2 Criação da fila com lista ....................................................................................................................419
7.3.3 Inserção na pilha com lista .............................................................................................................. 420
7.3.4 Remoção de nó da fila ....................................................................................................................... 429
7.3.5 Função de impressão e função de liberação de memória ................................................... 432
Unidade VIII
8 ÁRVORES ..........................................................................................................................................................440
8.1 Árvores binárias ...................................................................................................................................441
8.2 Percurso em árvores binárias .........................................................................................................442
8.2.1 Percurso em pré-ordem ou prefixo (busca em profundidade) .......................................... 442
8.2.2 Percurso em ordem ou infixo (ordem simétrica)..................................................................... 450
8.2.3 Percurso em pós-ordem ou posfixo ............................................................................................. 454
8.3 Árvores binárias de busca ...............................................................................................................459
8.3.1 Operação de busca ...............................................................................................................................461
8.3.2 Operação de inserção ......................................................................................................................... 462
8.3.3 Operação de remoção ........................................................................................................................ 463
8.3.4 Remoção de folha ............................................................................................................................... 464
8.4 Estrutura de árvores binárias em C .............................................................................................467
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 
que osprogramas 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, descreva a sequência de instruções conformeas 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 com o 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 de 9 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 feitoslinha 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 primitiva de entrada de dados
No algoritmo do exemplo anterior, a interação com o computador ainda não está completa. O 
programafaz 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 com o elemento N”)
 leia(n)
 an<-a1+(n-1)*razão
 escreva(“O elemento”,n,” é “,an)
Fimalgoritmo
46
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
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.
Os primeiros comandos que vimos foram os de entrada e saída de 
informações, o leia () e o escreva ().
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
Um programa, uma vez escrito, precisa ser testado, bem como ter 
verificados a sua funcionalidade e o correto funcionamento ló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 oprocessamento.
 exercícios
Questão 1. Em uma sequência de ação, procura-se atingir certo objetivo com recursos de tomadas 
de decisões e escolhas entre várias alternativas, segundo as experiências adquiridas. No entanto, um 
computador para atingir seu objetivo precisa ser instruído através de algoritmos, utilizando-se lógicas 
corretas para que suas tarefas possam ser executadas. Com base nessas informações, escolha a alternativa 
que contém a afirmação correta:
A) O algoritmo é um conjunto infinito de instruções, comandos e ações que têm como objetivo a 
resolução de uma tarefa, ou a solução de um problema.
B) 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.
C) Algoritmo é uma sequência de passos que visam atingir um objetivo bem definido. Portanto, um 
algoritmo é a descrição de um conjunto de comandos que, obedecidos, resultam numa sucessão 
infinita de ações.
D) Algoritmo são regras formais para a obtenção de um resultado ou da solução de vários problemas, 
englobando fórmulas de expressões aritméticas.
E) Algoritmo é a descrição de uma sequência de passos que deve ser seguida para a realização de 
uma ou mais tarefas.
Resposta correta: alternativa B.
Análise das alternativas
A) Alternativa incorreta.
Justificativa: uma vez que tem como objetivo a solução de um problema, um algoritmo deve conter 
um conjunto finito de instruções, além de permitir que estas sejam executadas pelo computador.
B) Alternativa correta.
Justificativa: uma solução computacional deve ser apresentada através de um algoritmo que possua 
sequências de instruções, operações e lógicas corretas para que possam ser executadas por uma máquina.
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
C) Alternativa incorreta.
Justificativa: um algoritmo deve conter um conjunto de comandos de forma sequencial para que 
suas ações possam ser executadas por um computador e atingir seu objetivo. 
D) Alternativa incorreta.
Justificativa: uma regra deve ser obedecida para que seja possível a realização de uma tarefa. A sua 
solução envolve fórmulas e expressões matemáticas para solucionar um problema.
E) Alternativa incorreta.
Justificativa: a descrição da solução de um problema deve ser realizada através da descrição de um 
algoritmo, de forma sequencial, para a solução de apenas uma tarefa.
Questão 2. Utilizamos o pseudocódigo para desenvolver o raciocínio que será utilizado para criar 
um programa, e não nos preocuparmos se estamos escrevendo dentro das normas rígidas como as 
exigidas por uma linguagem de programação. Podemos classificar os tipos de informações a serem 
processadas pelo computador em dados e instruções. Os dados são as informações a serem processadas 
por um computador, e as instruções são os comandos que orientam o processamento feito por um 
computador. Conforme as afirmações descritas, escolha a alternativa que contém a afirmação correta:
A) Os algoritmos e as linguagens de programação trabalham com dados bem definidos. Estes dados 
são classificados em tipos. Conforme o tipo de dado, o computador trabalha de forma igual no 
tratamento deles durante o processamento.
B) Por princípio, os computadores trabalham com quatro tipos de dados. Partindo destes tipos, as 
linguagens de programação derivam em outros tipos mais genéricos, ou com precisão maior, tais 
como: inteiros, reais, caracteres e lógicos.
C) Quando um dado não sofre nenhuma variação durante a execução do programa é chamado 
constante. O seu valor deverá ser o mesmo do início ao fim da execução do programa, assim como 
para execuções iguais. 
D) As variáveis são espaços reservados na memória principal do computador, na qual os dados 
são armazenados para uma posterior reutilização. Elas são especialmente úteis quando temos 
operações mais complexas ou expressões com parênteses.
E) Para batizar uma variável é recomendável dar-lhe um nome que lembre a informação que ela irá 
armazenar. Os nomes das variáveis são atribuídos pelo usuário e obedecem a certas regras, como 
variáveis – são as nomenclaturas.
Resolução desta questão na plataforma.
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
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.
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 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çãoorientada 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;
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
• 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 23 – Para o compilador, a separação dos comandos é feita pelo ‘;’
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 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 24 – 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.
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
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
*/
58
Re
vi
sã
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.
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
Quadro 16 – Correspondência dos tiposprimitivos 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 */
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
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 {
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
 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 podemos ver 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.
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
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.
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
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++;
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
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ímos6 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.
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
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.
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; 
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 
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
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 25 – 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(){
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
 printf (“Inteiro = %d Real = %g\n”, 34, 5.6);
}
Resultará em:
Figura 26 – 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 27 –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);
}
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
Teremos a seguinte saída:
Figura 28 – 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 29 – 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.
70
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/06/
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 30 – 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).
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
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>
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
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 31 – 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 e um 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 
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.
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
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. As questões abaixo são referentes às aplicações das linguagens de programação C e 
C++. Podemos considerar que a linguagem C é adequada para a programação estruturada; é usada 
principalmente para o desenvolvimento de sistemas operacionais, planilhas eletrônicas e gerenciadores 
de bancos de dados (HICKSON, 2005). É uma linguagem considerada de “médio nível”. As chamadas de 
“baixo nível” (que só os sistemas operacionais reconhecem, como o Assembler) não são linguagens de 
máquina e nem são de “alto nível” (linguagens que fornecem seus próprios recursos de desenvolvimento 
de programa). Com base nessas informações, escolha a alternativa com as afirmações consideradas 
corretas:
A) Alguns dos pontos positivos da linguagem C são: a escalabilidade do compilador, as bibliotecas 
padronizadas, a grande variedade de operadores, a facilidade na sintaxe, o acesso ao hardware e 
a otimização de aplicações.
B) A linguagem C não é rígida na sua sintaxe. A sintaxe são regras detalhadas para que um programa 
possa ser executado. Essas regras são elencadas como: tipos, declarações, expressões e funções.
C) A linguagem C não permite atribuir valores no momento da declaração da variável, tais como 
declarar várias variáveis do mesmo tipo na mesma linha.
D) Na linguagem C, o incremento ou decremento automático são operadores considerados 
convencionais que atuam sobre a própria variável, aumentando ou diminuindo uma unidade.
E) A linguagem C não possui comandos de entrada e saída; estes comandos são feitos através de 
funções. A utilização dessas funções está contida na biblioteca-padrão, o stdio.h. 
Resposta correta: alternativa E.
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
Análise das alternativas
A) Alternativa incorreta.
Justificativa: os principais pontos positivos da linguagem C são a portabilidade do compilador, 
as bibliotecas padronizadas, a grande variedade de operadores, a facilidade na sintaxe, o acesso ao 
hardware e a otimização de aplicações.
B) Alternativa incorreta.
Justificativa: quanto à rigidez da linguagem C, ela é considerada bastante rígida em sua sintaxe. 
Sintaxe são regras detalhadas para que um programa possa ser executado. Essas regras são elencadas 
como: tipos, declarações, expressões e funções.
C) Alternativa incorreta.
Justificativa: a linguagem C permite atribuir valor no momento da declaração de suas variáveis, tais 
como declarar várias variáveis do mesmo tipo na mesma linha.
D) Alternativa incorreta.
Justificativa: na linguagem C, o incremento ou decremento automáticos são operadores 
considerados não convencionais que atuam sobre a própria variável, aumentando ou diminuindo 
uma unidade.E) Alternativa correta.
Justificativa: a linguagem C não possui comandos de entrada e saída; estes comandos são feitos 
através de funções, da biblioteca padrão, o stdio.h. 
Questão 2. 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 o problema proposto. O objetivo principal 
da lógica de programação é demonstrar técnicas para resolução de problemas, e consequentemente, 
automatização de tarefas. Analise as afirmativas abaixo:
I – Na linguagem computacional temos três tipos de algoritmos mais utilizados: descrição narrativa, 
fluxograma e pseudocódigo ou portugol.
II – A descrição narrativa consiste em entender o problema proposto e escrever sua solução através 
da linguagem específica, ou seja, a língua portuguesa.
III – No fluxograma, os passos para a resolução de um problema são feitos através de um símbolo padrão.
IV – O foco do pseudocódigo é a lógica e a rigidez sintática.
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
É correto apenas o que se afirma em:
A) I.
B) IV.
C) I e III.
D) II e III.
E) II e IV.
Resolução desta questão na plataforma.
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 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.
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
A estrutura no fluxograma é representada da seguinte forma:
condição
<Condição> V
F
Figura 32 –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 33 – Programa para avisar se um número é negativo
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 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 34 – 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
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
Memoria:Negativo
numero tela
Figura 35 – 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 36 – 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
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 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 37 – 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 38 – Nesse caso, como a operação não resulta em 
Verdadeiro, as instruções no bloco do então não serão executadas
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
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 39 – 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 teclado 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
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 III
Memoria:Negativo
numero
-5
tela
escreva um numero
-5
Figura 40 – 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 41 – 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”.
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
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 42 – 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 43 – Fim do programa
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 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 44 – Fluxograma de decisão com então e senão
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
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 45 – Decisão com então e senão
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
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 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 “)
 senao
 escreva(“ positivo “)
 Fimse
Fimalgoritmo
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
Memoria:Negativo
numero tela
Figura 47 – 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 48 – 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
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
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 49 – 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 50 – Como o resultado é Falso, serão executadas as 
instruções do bloco do senão 
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
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 51 – Memória com tela mostrando o comando positivo 
no bloco do senão
Aseguir, 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
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
Memoria:Negativo
numero tela
escreva um numero
5
positivo
Figura 52 – 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 53 – 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.
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
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 54 – 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
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
negativo
Figura 55 – 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 56 – 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.
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
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
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
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
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
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 57 – Fluxograma com condicionais aninhadas
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
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 58 – Programa para encontrar o maior número, de três digitados
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
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 59 – Início da memória do programa o maior
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
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 60 – 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
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
 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 61 – 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
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:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
Figura 62 – 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 63 – 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.
101
Re
vi
sã
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 64 – 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
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:o maior
n1
1
n2
2
n3
3
Tela
1 2 3
O valor maior 
e 3
Figura 65 – 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 66 – Programa com a entrada maior atribuída à variável n2
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
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 67 – 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.
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
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 68 – 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.
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
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 69 – 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
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
 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 70 – 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 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
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
Memoria:o maior
n1
2
n2
1
n3
3
Tela
2 1 3
Figura 71 – 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 72 – Execução do bloco do primeiro então
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
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 73 – 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.
109
Re
vi
sã
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 74 – 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
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
 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 75 – 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
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
Memoria:o maior
n1
2
n2
3
n3
1
Tela
2 3 1
Figura 76 – 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 77 – O resultado Verdadeiro leva à execução do bloco 
do então
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
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 78 – 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.
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çãoalgoritmo “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 79 – 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
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
 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 80 – 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)
 senao
 escreva(“o maior e “, n3)
 fimse
 Fimse
Fimalgoritmo
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
Memoria:o maior
n1
3
n2
1
n3
2
Tela
3 1 2
Figura 81 – 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 82 – O resultado Verdadeiro também na segunda 
condicional mantém o programa no bloco do então
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
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 83 – 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.
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
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 84 – 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
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
 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 85 – 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
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
Memoria:o maior
n1
3
n2
2
n3
1
Tela
3 2 1
Figura 86 – 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 87 – Como o resultado é Verdadeiro também para o 
segundo teste, o programa continua no bloco do entã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
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 88 – 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.
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
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 89 – 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.
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
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 90 – Escolha-caso
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
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
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
Início
num1, opção, 
num2
opção
num1+num2 num1–num2 num1*num2 Op inv
Div zero
Fim
num1/num2
num2=0
+ – * /
Figura 91 – 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
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
 escreva(“operacao invalida”)
 Fimescolha
Fimalgoritmo
Memoria Calc
Figura 92 – 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
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
Memoria Calc
num1 num2 opcao Tela
Figura 93 – 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
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
Memoria Calc
num1 num2 opcao Tela
Digite: num op 
num
Figura 94 – 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
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
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
Figura 95 – 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
√
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 Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
Figura 96 – 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: numop 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
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
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
5
Figura 97 – 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
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
Memoria Calc
num1
2
num2
3
opcao
+
Tela
Digite: num op 
num
2 + 3
5
Figura 98 – Término do processamento
Para testar a subtraçã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
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
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
Figura 99 – 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
√
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
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
Figura 100 – 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
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
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
– 1
Figura 101 – 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
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
Memoria Calc
num1
2
num2
3
opcao
–
Tela
Digite: num op 
num
2 – 3
– 1
Figura 102 – 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
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
2
num2
3
opcao
*
Tela
Digite: num op 
num
2 * 3
Figura 103 – 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
√
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
2
num2
3
opcao
*
Tela
Digite: num op 
num
2 * 3
Figura 104 – 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
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
6
Figura 105 – 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
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
6
Figura 106 – 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á indicar erro. 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
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
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
Figura 107 – 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
√
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
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
Figura 108 – 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
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
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
4
Figura 109 – 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
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
8
num2
2
opcao
/
Tela
Digite: num op 
num
8 / 2
4
Figura 110 – 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
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
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
Figura 111 – 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
√
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
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
Figura 112 – Comparação buscando correspondência
Uma vez encontrado o bloco da divisão, o programa, inicialmente, verifica se o divisor, ou seja, a 
variávelnum2, é 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
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
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
Divisão por 
zero
Figura 113 – 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
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
8
num2
0
opcao
/
Tela
Digite: num op 
num
8 / 0
4
Figura 114 – 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
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
8
num2
2
opcao
%
Tela
Digite: num op 
num
8 % 2
Figura 115 – 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
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
8
num2
2
opcao
%
Tela
Digite: num op 
num
8 % 2
Operação 
invalida
Figura 116 – 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
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
4
Figura 117 – 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.
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
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 118 – Saída do programa caso a entrada seja positiva
Executando com -5 na entrada, temos a seguinte saída:
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
Figura 119 – 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 gostodo programador. Além da forma ilustrada anteriormente, outro estilo 
bastante utilizado por programadores C é:
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
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:
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
Figura 120 – Saída do programa com else, e entrada positiva
Como saída para o valor -5, teremos:
Figura 121 – 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
 {
 .
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
 .
 .
 }
}
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);
}
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
Como foi feito nos testes de mesa, agora testaremos na prática as diversas entradas.
• Entradas 1, 2, 3:
Figura 122 – Saída do programa o maior número com entradas 1, 2, 3
• Entradas 1, 3, 2:
Figura 123 – Saída do programa o maior número com entradas 1, 3, 2
• Entradas 2, 1, 3:
Figura 124 – Saída do programa o maior número com entradas 2, 1, 3
• Entradas 2, 3, 1:
Figura 125 – Saída do programa o maior número com entradas 2, 3, 1
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
14
Linguagem e Técnicas de Programação
• Entradas 3, 1, 2:
Figura 126 – Saída do programa o maior número com entradas 3, 1, 2
• Entradas 3, 2, 1:
Figura 127 – 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;
}
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
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.
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
• Soma:
Figura 128 – Calculando 2 + 3
• Subtração:
Figura 129 – Calculando 2 - 3
• Multiplicação:
Figura 130 – Calculando 2 * 3
• Divisão:
Figura 131 – Calculando 8/2
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
• Divisão por zero:
Figura 132 – Calculando 8/0
• Operação inválida:
Figura 133 – 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çãoresultar em Verdadeiro, retornará o resultado 
da expressão 1; se a condição for falsa, retornará o resultado da expressão 2.
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
 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 acompanha o 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 
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
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. Para se tomar uma decisão, uma série de condições deve ser avaliada para se decidir se 
uma ação deverá ou não ser realizada. As estruturas condicionais são utilizadas quando é preciso tomar 
decisões, ou quando são necessárias comparações. Com base nessas informações, escolha a alternativa 
que contém a afirmação considerada correta:
A) Nestas estruturas condicionais uma operação lógica (<condição>) é avaliada; se o resultado 
desta avaliação for verdadeiro (V), então um determinado conjunto de instruções é executado. 
Caso contrário, ou seja, quando o resultado da avaliação for falso (F), um comando diferente é 
executado.
B) O programa, ao deparar-se com a condição se, entende que encontrará uma expressão cujo 
resultado é um valor numérico. Caso esta expressão resulte em verdadeiro, será 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, será executado o bloco entre o 
senão e o fimse.
C) Ao encontrar o se, o programa irá avaliar se a operação seguinte irá resultar em verdadeiro. Caso 
a operação seja diferente do valor lógico, resulta em falso. Sendo assim, o fluxo executará as 
instruções contidas no bloco do senão, e em seguida as contidas no bloco se.
D) Quando for necessário escolher um resultado apenas, temos que encadear várias condicionais; no 
entanto, existe uma estrutura que evita o encadeamento de condicionais: a escolha-caso.
E) A estrutura de decisão escolha-caso é utilizada principalmente quando se precisa testar várias 
expressões que produzem um resultado entre várias possibilidades, ou então testar o valor de uma 
variável, em que está armazenado um determinado conteúdo. Compara-se o resultado obtido 
opção a opção, testando-se com os valores fornecidos individuais de cada cláusula.
Resposta correta: alternativa A.
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
Análise das alternativas
A) Alternativa correta.
Justificativa: na estrutura condicional uma operação lógica (<condição>) é avaliada; se o resultado 
desta avaliação for verdadeiro (V), então um determinado conjunto de instruções é executado, e quando 
o resultado da avaliação for falso (F), um comando diferente é executado.
B) Alternativa incorreta.
Justificativa: o programa, ao deparar-se com a condição se, entende que encontrará uma expressão 
cujo resultado é lógico. Se a expressão resulta em verdadeiro será 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, será executado o bloco entre o senão e o fimse.
C) Alternativa incorreta.
Justificativa: ao encontrar o se, o programa irá avaliar se a operação seguinte irá resultar em 
verdadeiro. Caso a operação seja diferente do valor lógico, resulta em falso. Sendo assim, o fluxo 
executará as instruções contidas no bloco do senão.
D) Alternativa incorreta.
Justificativa: quando é necessário escolher um resultado entre vários possíveis, temos que encadear 
várias condicionais; no entanto, existe uma estrutura que evita o encadeamento de condicionais. Esta 
estrutura é a chamada escolha-caso.
E) Alternativa incorreta.
Justificativa: a estrutura de decisão escolha-caso é utilizada principalmente quando se precisa testar 
uma única expressão que produz um resultado entre várias possibilidades, ou então testar o valor de 
uma variável em que está armazenado um determinado conteúdo.
Questão 2. Existem várias estruturas que auxiliam a tomada de decisões em lógica de programação. 
Analise as afirmativas abaixo.
I – Na linguagem computacional temos três tipos de algoritmos mais utilizados: descrição narrativa, 
fluxograma e pseudocódigo ou portugol.
II – A descrição narrativa consiste em entender o problema proposto e escrever sua solução através 
de uma linguagem genérica, ou seja, a língua portuguesa.
III – No fluxograma, os passos para a resolução de um problema são feitos através de vários símbolos 
padrão.
IV – O foco do pseudocódigo é a lógica e a rigidez semântica.
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
É correto apenas o que se afirma em:
A) I.
B) IV.
C) I e III.
D) II e III.
E) II e IV.
Resolução desta questão na plataforma.
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
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 deum 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.
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 IV
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 134 – 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)
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
 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_n <- Cont_n+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 135 – Programa de pesquisa usando repita
Uma vez montado 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.
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 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
Figura 136 – 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”
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
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
voto resp Cont_s Cont_n Tela
Figura 137 – 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 138 – As variáveis são inicializadas
algoritmo “enquete”
var
 voto,resp: caractere
 cont_s,cont_n: inteiro
inicio
 cont_s<-0
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 IV
 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 139 – 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
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
Memoria: enquete
voto
s
resp Cont_s
0
Cont_n
0
Tela
Você tem computador em casa?
s/n
s
Figura 140 – 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 141 – Condicional para a contagem da opção
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 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
resp Cont_s
1
Cont_n
0
Tela
Você tem computador em casa?
s/n
S
Deseja continuar? s/n
Figura 142 – 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
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
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 143 – 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 144 – 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”)
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 IV
 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 145 – 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 
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
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 146 – Outra 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
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 147 – 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
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 IV
 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 148 – 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
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
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 149 – 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 150 – Retorno ao início do laço
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 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
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 151 – 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
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
 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 152 – 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
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 IV
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 153 – 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 154 – Mensagem exibida na tela
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
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 155 – 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
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 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
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 156 – 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
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
O fluxograma da estrutura enquanto é:
Comandos
CondiçãoF
V
Figura 157 – 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
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
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_n <- Cont_n+1
voto=s
V
F
F
Vresp=s
Figura 158 – 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”)
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
 leia (resp)
 fimenquanto
 escreva(“total sim: “,cont_s, “total nao”, cont_n)
fimalgoritmo
Memoria: enquete
Figura 159 – 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
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
Memoria:enquete
voto resp Cont_s Cont_n Tela
Figura 160 – 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 161 – É 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.
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
 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 162 – 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
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
 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 163 – 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
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
Memoria: enquete
voto
s
resp
S
Cont_s
0
Cont_n
0
Tela
Você tem computador em casa? 
s/n
s
Figura 164 – 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 165 – A condicional atualiza a variável acumuladora das respostas sim
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
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 166 – 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
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
 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 167 – 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 168 – O fimenquanto remete de volta para o início do laço
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
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 169 – 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
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
 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 170 – 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 171 – A leitura é feita
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
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 172 – 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”)
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
 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 173 – 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 174 – A mensagem é exibida na tela
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
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 computador em casa? 
s/n
n
Deseja continuar? s/n
s
Figura 175 – A leitura é feita
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
 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 176 – 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
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
 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 177 – 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
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
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 178 – 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 179 – Realização da leitura
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
 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 180 – 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
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
 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 181 – 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
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
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 182 – 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
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
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 183 – É 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
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
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 184 – 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
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
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 185 – 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
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
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 186 – Cálculo de 1!
• Para 2!
Inicio
 fat<-1
 fat<-fat*1
 fat<-fat*2
fim
fat
1
1
2
Figura 187 – Cálculo para 2!
• Para 3!
Inicio
 fat<-1
 fat<-fat*1
 fat<-fat*2
 fat<-fat*3
fim
fat
1
1
2
6
Figura 188 – 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 189 – Cálculo para 4!
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
• 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 190 – 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 191 – Uso do exemplo 5! incluindo uma nova variável
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<=5faca
 fat<-fat*i
 i<-i+1
 fimenquanto
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
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.
 observação
No Scratch, o laço repita até que e o enquanto são comandados pelo 
bloco:
Figura 192 – 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
209
Re
vi
sã
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 fluxograma da estrutura para é:
Comandos
<var>; <inicio>;
<fim>
<passo>
Figura 193 – Estrutura para...até
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 194
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
algoritmo “exemplo”
var
 i:inteiro
inicio
 para i de 1 até 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
tela
Figura 195 – Atribuição do valor inicial à variável de controle
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 196– 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
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
i
1
tela
1
Figura 197– 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
2
tela
1
Figura 198–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 199 – Retorno do programa à linha do para
algoritmo “exemplo”
var
 i:inteiro
inicio
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
 para i de 1 ate 7 passo 2 faca
 escreva(i)
 fimpara
fimalgoritmo
i
1
3
tela
1
Figura 200 – 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.
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 201 – 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 202 – 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.
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 “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 203 – Retorno do programa para a linha do para e execução do teste
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 204– 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 205– Nova execução automática de instrução pelo programa
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
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
i
1
3
5
7
tela
1
3
5
Figura 206– 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 207– 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
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
I
1
3
5
7
9
tela
1
3
5
7
Figura 208– 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.
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
35
7
Figura 209– 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 210 – Laço para... até que no Scratch
No exemplo, o som do miado será repetido dez vezes.
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
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á:
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 211 – Cálculo fatorial
Vamos fazer o teste de mesa para 4!
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
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 212– 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 213– São reservados espaços na memória para as variáveis
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
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 214– 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 215– Inicialização de fat
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
 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ósito se 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 216– 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
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
Memoria: fatorial
fat
1
i
1
n
4
tela
4
Figura 217– 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 218– O programa faz a multiplicação
O produto da multiplicação entre o valor de fat já inicializado e o primeiro número é obtido. 
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
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 219– 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 220– O programa entra no laço
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
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 221– 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 222– Atualização da variável de controle
223
Re
vi
sã
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 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 223– 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
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: fatorial
fat
1
1
2
6
i
1
2
3
n
4
tela
4
Figura 224– 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 225– 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:inteiroinicio
 leia(n)
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 Fimpara
 escreva(fat)
fimalgoritmo
V
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
Memoria: fatorial
fat
1
1
2
6
i
1
2
3
4
n
4
tela
4
Figura 226– 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 227– 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
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
Memoria: fatorial
fat
1
1
2
6
24
i
1
2
3
4
5
n
4
tela
4
Figura 228– 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 229– 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
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
fat
1
1
2
6
24
i
1
2
3
4
5
n
4
tela
4
24
Figura 230– 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.
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
 observação
A 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);
}
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
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 231 – 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á:
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
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 232 – Saída do programa usando while
Fazendo a tradução do programa do fatorial utilizando o enquanto.
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
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 233 – 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 formaexplí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.
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
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)
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
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 234 – 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);
}
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
A saída desse exemplo é:
Figura 235 – 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>).
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
 exercícios
Questão 1. Uma das funções do computador é realizar operações repetitivas, o que para o ser 
humano seria muito enfadonho. É muito comum durante o processamento a existência de situações em 
que há a necessidade de se repetir um determinado trecho de um programa certo número de vezes. Com 
base nessas informações, escolha a alternativa com a informação considerada correta:
A) A estrutura dos laços de repetição é composta por três comandos: o enquanto, o repita e o 
para. Entretanto, o problema a ser resolvido não depende do laço de repetição, e cada um deles 
apresenta uma característica mais adequada ou não para a sua solução.
B) As estruturas de repetição podem ser classificadas em laços contados e laços condicionais. Ambas 
possuem um funcionamento mecanizado, muito particular em cada uma das formas. 
C) Laços condicionais ocorrem quando existem blocos de programa que necessitam ser repetidos; 
porém, não se sabe quantas vezes ele será repetido.
D) No laço repita, o fluxo do programa encontra o comando propriamente dito e reconhece que é o início 
do bloco de repetição; segue o fluxo normal até encontrar o comando até que, pelo qual uma condição 
é testada. Se o resultado do teste for falso, o fluxo não é devolvido ao início do bloco. Se o resultado do 
teste for positivo, o programa segue o fluxo abandonando a repetição do bloco.
E) O laço enquanto testa uma condição no final do programa, e 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 positivo, 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 a condição se torne falsa.
Resposta correta: alternativa C.
Análise das alternativas
A) Alternativa incorreta.
Justificativa: a estrutura dos laços de repetição é composta por três comandos: o enquanto, o repita e 
o para. Entretanto, dependendo do problema a ser resolvido, cada um deles apresenta uma característica 
mais adequada. 
B) Alternativa incorreta.
Justificativa: as estruturas de repetição podem ser classificadas em laços contados e laços condicionais. 
Ambos possuem funcionamento automatizado, muito particular em cada uma das formas.
C) Alternativa correta.
Justificativa: os laços condicionais ocorrem no caso de existirem blocos de programa que necessitem 
ser repetidos; porém não se sabe quantas vezes será a repetição.
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
D) Alternativa incorreta.
Justificativa: no laço repita, o fluxo do programa encontra o comando propriamente dito e reconhece 
que é o início do bloco de repetição; segue o fluxo normal até encontrar o comando até que, onde 
uma condição é testada. Se o resultado do teste for falso, o fluxo é devolvido ao início do bloco. Se o 
resultado do teste for positivo, o programa segue o fluxo, abandonando a repetição do bloco
E) Alternativa incorreta.
Justificativa: o laço enquanto testa uma condição no início do programa e 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 positivo, 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 a condição se torne falsa.
Questão 2. Na linguagem C existem três tipos de estruturas de blocos, porém com algumas 
diferenças:repita até que, enquanto faça e para até que. Com base nessas informações, escolha a 
alternativa com a informação correta:
I – Na linguagem C, a estrutura do funcionamento é semelhante à do para do pseudocódigo, mas 
não é indicada de forma explícita.
II – A estrutura do repitaatéque na linguagem C altera-se um pouco na verificação da condição de 
fim de laço.
III – Em algoritmo, o laço acontece até que um certo evento ocorra, e na linguagem C o laço 
acontece enquanto um evento é executado.
IV – O laço contado em C é escrito com três parâmetros: o primeiro inicializa a variável de controle, 
o segundo parâmetro é a expressão lógica que determinará o encerramento do laço e o terceiro é a 
expressão do decremento a ser realizado.
É correto apenas o que se afirma em:
A) I.
B) IV.
C) I e III.
D) II e III.
E) II e IV.
Resolução desta questão na plataforma.
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
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 
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 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 236 – 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
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
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 237 – 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 temperatura em 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.
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 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
241
Re
vi
sã
o:
 Ju
lia
na
 -
 D
ia
gr
am
aç
ão
: J
ef
er
so
s /
 M
ár
ci
o 
- 
02
/06/
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 238 – 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
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 V
 escreva(“diferença “,i,” eh “,media-t[i])
 fimpara
fimalgoritmo
Memoria:Temperatura
t i soma media tela1 2 3
Figura 239 – 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 240 – Iniciando a variável soma
Ao iniciar o programa, a variável soma é inicializada com zero, pois ele irá totalizar as 
temperaturas digitadas.
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
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 241 – 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
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 V
Memoria:Temperatura
t i soma media tela1 2 3
1 0
Figura 242 – 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 243 – 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
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
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 244 – 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
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 V
Memoria:Temperatura
t i soma media tela1 2 3
9 1 9 digite a 
temperatura 1
9
Figura 245 – 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 246 – 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.
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
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 247 – 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
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 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 248 – Leitura da segunda temperatura
A leitura da segundatemperatura é 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 249 – A variável soma acumula o segundo dado
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
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 250 – 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
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 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 251 – 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 252 – Armazenamento do valor digitado
O valor digitado é armazenado na posição t [3].
algoritmo “Temperatura”
var
 t:vetor[1..3] de real
 i:inteiro
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
 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 253 – 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
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 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 254 – 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 255 – O fluxo sai do laço.
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
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
21
Figura 256 – 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
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 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 257 – 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
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
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 258 – 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 259 – Como i é menor ou igual a 3, o laço é executado
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 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 260 – 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
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
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 261 – 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 262 – Nova execução do laço
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 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 263 – Apresentação do resultado
O programa apresenta o resultado de media – t[2], ou seja, 16 - 18.
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
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 264 – 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
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 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 265 – 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
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
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 266 – 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 267 – Atualização da variável de controle
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 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 268 – 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];
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
 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);
}
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 V
Executando o programa, temos:
Figura 269 – 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 270 – Representação de uma matriz bidimensional
A declaração da matriz ilustrada é:
algoritmo “classe”
var
 classe:matriz[1..3] [1..4] de real
inicio
.
.
.
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
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 271 – 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}};
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 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ípico de 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’).
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
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>
voidmain ()
{
 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 272 – 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 273 – 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.
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 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 274 – 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 
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
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 275 – 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”);
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
 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 276 – 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:
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
Figura 277 – 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 quantidade de 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 278 – 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”);
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
 gets(cadeia2);
 strcat(cadeia1, cadeia2);
 puts(cadeia1);
}
Figura 279 – 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 280 – 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:
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
— < 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 281 – 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).
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
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.
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
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;
}
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
 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 
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
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
Desenha imagens
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.
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
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:
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çãoalgoritmo “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 282 – Início do fluxo do programa
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
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 283 – 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
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
Pilha Tela
Memoria Procedimentos Pilha
areatri (2,6)
Figura 284 – 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 285 – Abertura da área de memória
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
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 286 – 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
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
Memoria areatri
h b area
2 6 6
Pilha Tela
Memoria Procedimentos Pilha
areatri (2,6)
Figura 287 – 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 288 – Escrita do resultado
O fluxo segue para o segundo comando, escrevendo o resultado na tela.
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
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 289 – 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
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
Memoria areatri Pilha Tela
6
Memoria Procedimentos Pilha
areatri (2,6)
areatri (4,6)
Figura 290 – 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 291 – Criação da memória e estabelecimento de parâmetros
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
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 292 – 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
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 areatri
h b area
4 6 12
Pilha Tela
6
Memoria ProcedimentosPilha
areatri (2,6)
areatri (4,6)
Figura 293 – 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 294 – O resultado é exibido na tela
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
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 295 – 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.
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
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.
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
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:
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
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
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
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 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
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
Pilha Tela
Memoria: Combinação Pilha
Figura 296 – 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 297 – As variáveis do programa principal são criadas
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
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 298 – 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
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
 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 299 – 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
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
Memoria fatorial
n
3
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 300 – 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 301 – A função fatorial cria as suas variáveis internas
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
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 302 – 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
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
 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 303 – 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
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
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 304 – 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 305 – A variável de controle é incrementada
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
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 306 – 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
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
var
 a,b:inteiro
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
 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
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 307 – Fat recebe o seu próprio conteúdo multiplicado por i
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
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
Memoria: fatorial
n i fat
3 1
2
3
1
1
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 308 – A variável de controle é incrementada
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*ifimpara
 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
3
1
1
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 309 – Como i<=n, ou seja, 3<=3, o laço é executado
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
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
3
1
1
2
6
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 310 – Novo cálculo de fat é efetuado
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
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
 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
3
4
1
1
2
6
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)
Figura 311 – Incremento da variável de controle
A variável de controle é incrementada, e, como i<=n é Falso, o programa prossegue após o laç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
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
Memoria: fatorial
n i fat
3 1
2
3
4
1
1
2
6
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
Figura 312 – A função retorna o conteúdo da variável fat 
para o programa principal
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
fatorial(a)6
fatorial(b)
Figura 313 – O programa principal chama a função fatorial, passando o valor 2
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
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
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 314 – Reserva de espaço na memória e recebimento do 
parâmetro de entrada
A função fatorial reserva o seu espaço na memória e recebe o parâmetro de entrada 2.
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
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
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
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 315 – A função fatorial cria as suas variáveis internas
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
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
Memoria: fatorial
n i fat
2 1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 316 – 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
 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
2 1 1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 317 – A variável i de controle é inicializada e, 
como é menor que n, entra no laço 
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
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
2 1 1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 318 – A variável fat é atualizada
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
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/
2014
Unidade V
 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
2 1
2
1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 319 – A variável de controle é incrementada
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
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
Memoria: fatorial
n i fat
2 1
2
1
1
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)
Figura 320 – Como i<=n (2=2), a atualização da variável fat é realizada
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
2 1
2
3
1
1
2
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
Figura 321 – Incremento da variável de controle e retorno 
do conteúdo da fat para o programa principal
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
A variável de controle é incrementada e, como é maior que n, a função sai do laço, retornando o 
conteúdo da variável fat para o programa principal.
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
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 322 – A função fatorial é chamada pelo programa principal
O programa principal chama a função fatorial, passando o valor de a-b, ou seja, 1.
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca
 fat<-fat*i
 fimpara
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
 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
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 323 – A função é inicializada, recebendo o valor do parâmetro
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
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
Memoria: fatorial
n i fat
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 324 – As variáveis da função são criadas
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
1 1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 325 – A variável fat é inicializada
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
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
1 1 1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 326 – Inicialização da variável de controle e execução do laço
A variável de controle é inicializada, e, 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
 fat<-fat*i
 fimpara
 retorne fat
fimfuncao
algoritmo “Combinacao”
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
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
1 1 1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 327 – Fat é atualizada
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
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: fatorial
n i fat
1 1
2
1
1
Pilha Tela
3
2
Memoria: Combinação
a b combinação
3 2
Pilha
fatorial(a)6
fatorial(b)2
fatorial(a–b)
Figura 328 – A variável de controle é atualizada, e a função sai do laço
A variável de controle é atualizada, e, como a condição é falsa, a função sai do laço.
funcao fatorial(n:inteiro):inteiro
var
 i,fat:inteiro
inicio
 fat<-1
 para i de 1 ate n faca