algoritmos_e_logica_de_programacao

Prévia do material em texto

Algoritmos e Lógica de Programação
CARLOS ALEXANDRE GONÇALVES DE ARAÚJO
CARLA CORRÊA TAVARES DOS REIS
1ª Edição
Brasília/DF - 2020
Autores
Carlos Alexandre Gonçalves de Araújo
Atualização
Carla Corrêa Tavares dos Reis
Produção
Equipe Técnica de Avaliação, Revisão Linguística e 
Editoração
Sumário
Organização do Livro Didático........................................................................................................................................4
Introdução ..............................................................................................................................................................................6
Capítulo 1
Algoritmo ..........................................................................................................................................................................9
1.1. Conceito de Algoritmo .........................................................................................................................................9
1.2. Fluxogramas ......................................................................................................................................................... 12
1.3. Pseudocódigos ..................................................................................................................................................... 13
1.4. Representação de Dados .................................................................................................................................. 14
1.5. Comandos de Entrada e Saída ....................................................................................................................... 18
Capítulo 2
Estruturas de Decisão ............................................................................................................................................... 24
2.1. Estruturas de Condição ..................................................................................................................................... 24
Capítulo 3
Estruturas de Repetição ........................................................................................................................................... 35
3.1.Estrutura de Repetição ...................................................................................................................................... 35
3.2. Determinação do Maior e Menor Valor ....................................................................................................... 45
3.3. Contadores e Acumuladores ........................................................................................................................... 46
Capítulo 4
Estruturas de Dados ................................................................................................................................................... 49
4.1. Estruturas de Dados Homogêneas ............................................................................................................... 49
Capítulo 5
Procedimentos e Funções ........................................................................................................................................ 59
5.1. Procedimentos de modularização ............................................................................................................... 60
5.2. Ferramentas de modularização .................................................................................................................... 61
5.3. Função ................................................................................................................................................................... 63
Capítulo 6
Exercícios de Fixação e Utilização da Ferramenta VisualG ......................................................................... 65
6.1. Exemplos da Aula 1 .......................................................................................................................................... 65
6.2. Exemplos da Aula 2 .......................................................................................................................................... 67
6.3. Exemplos da Aula 3 .......................................................................................................................................... 70
6.4. Exemplos da Aula 4 .......................................................................................................................................... 72
6.5. Exemplos da Aula 5 .......................................................................................................................................... 74
6.6. Ferramenta de Edição de Algoritmos .......................................................................................................... 75
Referências ........................................................................................................................................................................ 82
5
Organização do Livro Didático
Para facilitar seu estudo, os conteúdos são organizados em capítulos, de forma didática, objetiva e 
coerente. Eles serão abordados por meio de textos básicos, com questões para reflexão, entre outros 
recursos editoriais que visam tornar sua leitura mais agradável. Ao final, serão indicadas, também, 
fontes de consulta para aprofundar seus estudos com leituras e pesquisas complementares.
A seguir, apresentamos uma breve descrição dos ícones utilizados na organização do Livro Didático.
Atenção
Chamadas para alertar detalhes/tópicos importantes que contribuam para a 
síntese/conclusão do assunto abordado.
Cuidado
Importante para diferenciar ideias e/ou conceitos, assim como ressaltar para o 
aluno noções que usualmente são objeto de dúvida ou entendimento equivocado.
Importante
Indicado para ressaltar trechos importantes do texto.
Observe a Lei
Conjunto de normas que dispõem sobre determinada matéria, ou seja, ela é origem, 
a fonte primária sobre um determinado assunto.
Para refletir
Questões inseridas no decorrer do estudo a fim de que o aluno faça uma pausa 
e reflita sobre o conteúdo estudado ou temas que o ajudem em seu raciocínio. 
É importante que ele verifique seus conhecimentos, suas experiências e seus 
sentimentos. As reflexões são o ponto de partida para a construção de suas 
conclusões.
6
ORGAnIzAçãO DO LIVRO DIDátICO
Provocação
Textos que buscam instigar o aluno a refletir sobre determinado assunto antes 
mesmo de iniciar sua leitura ou após algum trecho pertinente para o autor 
conteudista.
Saiba mais
Informações complementares para elucidar a construção das sínteses/conclusões 
sobre o assunto abordado.
Gotas de Conhecimento
Partes pequenas de informações, concisas e claras. Na literatura há outras 
terminologias para esse termo, como: microlearning, pílulas de conhecimento, 
cápsulas de conhecimento etc.
Sintetizando
Trecho que busca resumir informações relevantes do conteúdo, facilitando o 
entendimento pelo aluno sobre trechos mais complexos.
Sugestão de estudo complementar
Sugestões de leituras adicionais, filmes e sites para aprofundamento do estudo, 
discussões em fóruns ou encontros presenciais quando for o caso.
Posicionamento do autor
Importante para diferenciar ideias e/ou conceitos, assim como ressaltar para o 
aluno noções que usualmente são objeto de dúvida ou entendimento equivocado.
7
Introdução
Neste Livro Didático, apresentaremos Algoritmos e Lógica de Programação e 
o funcionamento do processo de desenvolvimento de programas (softwares) , 
considerando obter bom embasamento para, no futuro, aplicar na programação de 
computadores.
A lógica de programação é muito importante para pessoas que desejam trabalhar com 
desenvolvimento de programas para computadores. Pode, portanto, ser definida como um 
conjunto de técnicas para organizar pensamentos para atingir determinado objetivo.
Ao desenvolver um sistema, a responsabil idade do programador é maior na 
criação dosalgoritmos do que em sua implementação, pois, quando esses são 
bem projetados, o tempo para conclusão do projeto é reduzido, possibilitando a 
entrega no prazo previsto.
Sem que se perceba, os algoritmos estão presentes no nosso dia a dia: numa receita de 
bolo, num manual de instruções de um equipamento ou no passo a passo para explicar 
a solução de um problema matemático, por exemplo. 
Serão estudados os conceitos básicos e as técnicas para a criação e o desenvolvimento de 
algoritmos por meio de três métodos para sua representação, que são alguns dos 
mais conhecidos, tendo como objetivo obter a capacidade de transformar qualquer 
problema do cotidiano em um algoritmo de boa qualidade, ou seja, obtendo-se uma 
base teórica de boa qualidade, para o aprendizado futuro de uma Linguagem de 
Programação. 
Objetivos
Este Livro Didático tem como objetivos:
 » Entender o conceito de algoritmo.
 » Desenvolver um algoritmo sobre um exemplo do dia a dia.
 » Criar e ler um algoritmo representado em forma de fluxograma.
Provocação
Mas, para começar, reflita sobre o significado da palavra “Lógica”. O que é “Lógica”?
8
 » Desenvolver um algoritmo sobre um exemplo sequencial numérico.
 » Criar e ler um algoritmo sequencial numérico representado em forma de fluxograma.
 » Desenvolver a capacidade de análise de problemas com soluções dependentes 
de testes.
 » Conhecer os operadores relacionais e lógicos.
 » Conhecer os comandos de tomada de decisão simples, composta (se e se ... senão) 
e de múltipla escolha (caso).
 » Desenvolver a capacidade de análise de problemas com tomada de decisão.
 » Identificar as ações que devem ser executadas de forma repetitiva na solução de 
problemas.
 » Determinar as condições de controle da repetição.
 » Apresentar os recursos de programação “enquanto” e “para”.
 » Criar algoritmos utilizando estruturas de repetição de forma aninhada.
9
Apresentação
Para resolver um problema no computador, é prioritário que seja encontrada uma maneira de 
descrever esse problema de forma bastante clara e precisa. É preciso encontrar uma sequência 
de passos que possibilitem que o problema seja resolvido de maneira automática e até mesmo 
repetitiva. Essa sequência é conhecida como “algoritmo”.
A noção de algoritmo é primordial na computação. A criação de algoritmos com o objetivo 
de resolver problemas é uma das maiores dificuldades para quem inicia em programação de 
computadores.
Objetivos
 » Entender o conceito de algoritmo.
 » Ser capaz de desenvolver um algoritmo sobre um exemplo do dia a dia.
 » Ser capaz de criar e ler um algoritmo representado em forma de fluxograma.
 » Ser capaz de desenvolver um algoritmo sobre um exemplo sequencial numérico.
1.1. Conceito de Algoritmo
Um algoritmo pode ser definido como um conjunto de regras (instruções), bem definidas, 
para solução de um determinado problema. Segundo o dicionário Michaelis, o conceito 
de algoritmo é “utilização de regras para definir ou executar uma tarefa específica ou 
para resolver um problema específico”. 
A partir desses conceitos de algoritmos, pode-se perceber que a palavra algoritmo não 
é um termo computacional, ou seja, não se refere apenas à área de informática, é uma 
definição ampla, que pode, inclusive, ser utilizada normalmente no cotidiano. 
1CAPÍTULOALGORItMO
10
CAPÍTULO 1 • ALGORItMO
Figura 1. O que são algoritmos?
Fonte: https://continbox.com.br/o-que-sao-algoritmos/.
Um programa tem como premissa a solução de um problema apresentado; nesse caso, 
para a construção de seu respectivo algoritmo, alguns itens devem ser observados: a) 
encontrar os diversos passos componentes do problema de forma simples e objetiva, 
não apresentando interpretações diversas; b) ordenar esses passos do forma organizada; 
e c) manter esses passos dentro de uma sequência finita.
Abaixo tem-se um exemplo simples de algoritmo com uma estrutura sequencial descrevendo 
os passos para troca de um pneu.
Algoritmo para troca de um pneu de automóvel:
1. manter o carro desligado e o freio de estacionamento acionado;
2. pegar as ferramentas necessárias (chave de roda e macaco);
3. pegar o estepe;
4. afrouxar os parafusos de fixação do pneu furado;
5. suspender o carro utilizando o macaco;
6. retirar os parafusos de fixação do pneu;
Para refletir
Na informática, o algoritmo é o “projeto do programa”, ou seja, antes de se fazer um programa (software) na 
Linguagem de Programação desejada (Pascal, C, Delphi etc.), deve-se fazer o algoritmo do programa.
11
ALGORItMO • CAPÍTULO 1
7. retirar o pneu furado;
8. colocar o estepe;
9. recolocar os parafusos de fixação do pneu, apertando-os;
10. com o macaco, baixar o carro;
11. fazer um último aperto de ajuste nos parafusos de fixação do pneu;
12. guardar as ferramentas no local adequado.
Observe o nível de detalhamento do texto do algoritmo acima. Como mencionado 
anteriormente, os passos devem ser claros e capazes de realizar todas as operações 
necessárias à solução da situação proposta. Em alguns casos, pode ser necessário 
obter orientações especializadas para a correta estruturação do algoritmo.
1.1.1. Partes de um Algoritmo
Um algoritmo, mesmo o mais básico deles, é um sistema. Sendo assim, possui três partes em 
sua estrutura básica, representada na figura 1. São elas:
1. Entrada de dados – Nela, o usuário apresenta, quando solicitado, os dados para que o 
algoritmo possa ser executado corretamente.
2. Processamento de dados – Nessa parte, são realizados todos os procedimentos necessários 
à solução do problema proposto, tais como: resolução de equações, avaliação de resultados 
parciais, definição de “caminhos” a seguir etc.
3. Saída de dados – Parte do algoritmo responsável pela apresentação dos resultados 
desejados. Dependendo da estrutura criada pelo programador, pode estar distribuída 
no corpo do algoritmo.
Figura 2. Estrutura básica de um algoritmo.
 
 
 
 
Entrada Saída Processamento 
Fonte: O autor.
Por exemplo, considere a sequência abaixo que descreve a troca de uma lâmpada danificada:
Algoritmo para troca de lâmpada:
1. pegue uma escada; (entrada)
2. pegue uma lâmpada nova; (entrada)
12
CAPÍTULO 1 • ALGORItMO
3. posicione a escada embaixo da lâmpada; (processamento)
4. suba na escada; (processamento)
5. retire a lâmpada velha; (processamento)
6. coloque a lâmpada nova; (processamento)
7. acenda a lâmpada. (saída)
Ou, ainda, o exemplo abaixo para calcular a área de um retângulo:
Algoritmo para área do retângulo:
1. leia L1; (entrada)
2. leia L2; (entrada)
3. A ← L1*L2; (processamento)
4. escreva A. (saída)
Para calcular a área, é necessário saber os valores de L1 e L2. Nesse caso, a entrada 
para o processamento desse algoritmo consistirá desses valores (que devem ser 
informados pelo usuário pelo teclado, por exemplo). O processamento do algoritmo 
será a realização do cálculo L1*L2 e a atribuição do resultado dessa expressão para a 
variável A. A parte da saída consistirá na escrita do valor de A no monitor.
1.2. Fluxogramas
Fluxogramas são representações gráficas de um algoritmo (ou programa). Cada passo, 
ou linha de comando, descrito é representado por uma forma geométrica definida 
por regras básicas para cada tipo.
A figura abaixo representa um algoritmo na forma de um fluxograma. 
O início e o fim do algoritmo são marcados com uma figura elíptica; as 
ações a serem executadas estão em retângulos; sendo que as estruturas de 
controle condicionais estão em losangos e indicam duas possibilidades 
de proseguimento do algoritmo, uma para o caso da expressão avaliada 
(condição) ser verdadeira e outra para o caso de ser falsa. (CECHINEL; 
FERRARI, 2018, pag. 18)
Observando o fluxograma abaixo, as ações a serem executadas estão representadas 
por retângulos; o procedimento de avaliação de uma determinada situação (no caso, a 
situação do forno) é representado dentro de um losango, com duas possíveis respostas, 
uma verdadeira e outra falsa, qualquer delas direcionandopara o passo seguinte.
13
ALGORItMO • CAPÍTULO 1
Figura 3. Representação de um algoritmo na forma de um fluxograma.
início 
abrir forno 
forno 
aceso?
botar 
lenha 
acender 
fogo 
assar 
pão 
fim 
sim não 
Fonte: Cechinel e Ferrari (2018).
1.3. Pseudocódigos
Uma segunda forma de representar os algoritmos é a utilização de pseudocódigos. 
Costuma-se dizer que é uma maneira intermediária entre a linguagem natural e uma 
linguagem de programação.
Utiliza-se um conjunto restrito de códigos (palavras-chave) que correspondem às 
instruções nas linguagens de programação, embora sem a rigidez das estruturas de 
nenhuma das linguagens conhecidas.
Figura 4. Exemplo de um pseudocódigo.
leia (x,y) {Esta linha é um comentário} 
se x > u então 
escreva (“x é maior”) 
senão 
se y > x então 
escreva (“y é maior”) 
senão 
escreva (“x e y são iguais”) 
fim se 
fim se 
Fonte: Adaptado de Cechinel e Ferrari (2018).
14
CAPÍTULO 1 • ALGORItMO
A figura acima apresenta um exemplo estruturado como pseudocódigo que se propõe 
a escrever o maior valor entre x ou y, digitados pelo usuário. As expressões em negrito 
correspondem às palavras-chave que representam os comandos, ou estruturas, 
utilizadas em todas as linguagens de programação. Observe que, nas diversas linguagens 
de programação, os comandos (ou estruturas) variam, mas sua representação no 
pseudocódigo é a mesma.
1.4. Representação de Dados
As linguagens de programação implementam formas de representar e manipular 
os dados, que podem ser classificados em dois grandes grupos: os tipos de dados 
primitivos e os tipos de dados não primitivos. Os tipos de dados primitivos são os 
tipos básicos que devem ser implementados por todas as linguagens de programação, 
como os números reais, inteiros, booleanos, caracteres e strings. Os tipos de dados 
não primitivos, normalmente são os vetores, matrizes, classes, enumerações, etc., que 
costumam ser estruturas de dados mais complexas do que os tipos de dados primitivos.
1.4.1. tipos Primitivos
A correta representação de um dado torna mais eficiente a utilização dos recursos 
computacionais e do programa propriamente dito.
As linguagens de programação possuem suas próprias estruturas para definir os tipos de 
dados a serem armazenados e utilizados, mas todas têm como base os tipos apresentados 
a seguir.
 » Tipo inteiro: declararemos variáveis do tipo numérico inteiro quando 
precisarmos armazenar valores inteiros, positivos ou negativos (1, 5, 7, -10, 
-5, ...). Por exemplo, se precisarmos de uma variável para armazenar o número 
de filhos de um funcionário, o tipo ideal para essa variável seria inteiro.
 » Tipo real: declararemos variáveis do tipo numérico real para armazenar valores 
reais; em outras palavras, valores com ponto decimal (5.7, 3.2, -8.5). Esse seria 
o tipo ideal para armazenar, por exemplo, o salário de funcionários.
Atenção
Os dados em um computador são classificados e armazenados de acordo com o tipo de informação e a finalidade 
para a qual se deseja utilizá-los.
15
ALGORItMO • CAPÍTULO 1
 » Tipo caractere: declararemos variáveis do tipo caractere para armazenar um 
único caractere, que pode ser uma letra ou um símbolo. Por exemplo, para 
identificar o sexo do indivíduo, armazenaremos apenas o caractere ‘F’ ou ‘M’.
 » Tipo cadeia: declararemos variáveis do tipo cadeia para armazenar uma 
sequência de caracteres, ou seja, uma palavra, uma mensagem, um nome. 
Assim, se precisarmos de uma variável para armazenar o nome de uma pessoa, 
esse seria o tipo ideal.
 » Tipo lógica: declararemos variáveis do tipo lógico para armazenar valores 
lógicos, ou seja, o valor armazenado em variáveis desse tipo será sempre 
VERDADEIRO ou FALSO (resultado de uma estrutura condicional dentro do 
programa).
1.4.2. Constantes
Constantes são as informações (dados) que permanecem com o mesmo valor durante todo 
o processamento do algoritmo (programa). As constantes seguem as mesmas classificações 
apresentadas acima.
1.4.3. Variáveis
O conceito de variável deve ser muito bem assimilado para a criação de um algoritmo ou 
programa.
Como o próprio nome já diz, as variáveis armazenam valores que podem ser alterados 
diversas vezes durante o processamento do algoritmo (programa) conforme as 
instruções são executadas. Deve-se ter me mente que, ao alterar o conteúdo de uma 
variável, o valor anteriormente armazenado se perde.
As variáveis, em um algoritmo (ou programa), devem ser definidas com a utilização 
de um nome, também conhecido como identificador, criado pela pessoa que está 
desenvolvendo o algoritmo. Por exemplo, caso seja utilizada uma variável para 
armazenar o nome de um aluno, pode-se identificá-la como “nomedoaluno”, “nome_
do_aluno”; a média desse aluno pode ser “mediadoaluno”, “media_do_aluno” ou 
simplesmente “media”.
Atenção
Uma variável é, em última análise, um espaço reservado na memória do computador onde os dados, ou informações, 
deverão ser guardados.
16
CAPÍTULO 1 • ALGORItMO
Uma variável pode ser vista, por analogia, como uma gaveta com uma etiqueta colada 
a sua frente, cujo conteúdo não é fixo, permanente. Na verdade, essa gaveta pode ter 
seu conteúdo alterado, em quantidade, diversas vezes, mantendo sempre o mesmo 
tipo de conteúdo. Como exemplo, uma variável denominada NOTA contém o valor 8; 
porém, em outro instante posterior, poderá conter qualquer outro valor numérico. 
Observe que, a cada instante, ela conterá um, e somente um, valor.
1.4.3.1. Identificação das Variáveis
Trataremos agora da identificação das variáveis de modo mais específico. Para se utilizar os 
valores armazenados nas variáveis, é preciso que eles estejam vinculados corretamente a 
uma das variáveis do algoritmo. O nome da variável é que será utilizado para ter acesso ao 
seu conteúdo.
Uma analogia útil para entender o conceito e a necessidade de utilização 
do identificador seria pensar no mesmo como uma placa de sinalização 
que indica (delimita) uma determinada região ou espaço na memória do 
computador onde o dado (informação) desejado está localizado. Sendo 
assim, toda vez que se deseja acessar uma determinada informação 
utilizamos o nome dessa placa de sinalização e recuperamos o conteúdo 
que está localizado dentro do espaço delimitado pela mesma. (CECHINEL; 
FERRARI, 2018, pag. 30).
Tais regras estão apresentadas abaixo:
1. O nome a ser utilizado para identificar a variável deve sempre começar com um caractere 
alfabético.
2. Pode ter tantos caracteres alfanuméricos que desejar, desde que não ultrapasse 30 (trinta) 
caracteres nem desobedeça à regra anterior.
3. Os caracteres alfabéticos podem ser minúsculos ou maiúsculos.
4. Não deve conter sinais de pontuação, acentuação, operadores aritméticos ou espaço 
em branco. A única exceção, nesse caso, é o caractere sublinhado ( _ ) que pode ser 
utilizado para substituir o espaço em branco no nome da variável (observe os 
exemplos apresentados anteriormente).
Observe a lei
A nomeação dos identificadores deve obedecer a algumas regras.
17
ALGORItMO • CAPÍTULO 1
5. Evite palavras em inglês que possuam a mesma grafia da língua portuguesa 
(hotel, por exemplo). Algumas dessas palavras são chamadas de “palavras 
reservadas” e possuem funções específicas dentro da linguagem de programação.
Suponha a seguinte situação: um problema que controla compras de mercadorias em uma 
loja tem que armazenar o nome da mercadoria, o preço e a quantidade. Para isso, pode-se 
utilizar as seguintes variáveis: “nomemercadoria” ou “nome_mercadoria”, “quantidade” 
ou “quantidade_mercadoria” ou “quant_mercadoria”, “preco” ou “precomercadoria” ou 
“preco_mercadoria”. Assim, é mais fácil lembrar a finalidade (tipo e conteúdo) de cada um.
Observe que o identificador “preco” não tem cedilha, obedecendo ao que foi mencionado na 
regra número 4 acima.
No desenvolvimento de algoritmos, frequentemente se torna necessário armazenar dados 
referentes ao problema, mas, para armazenar esses dados, é preciso solicitar ao computadorque ele reserve uma área da memória para utilização. O modo de solicitar ao computador que 
reserve memória é chamado de declaração de variáveis.
A sintaxe para a declaração de variáveis em pseudocódigo é apresentada abaixo:
Sintaxe: var nome_da_variavel: <tipo_da_variavel>
var
A palavra var é utilizada em pseudocódigo para indicar a declaração de uma variável.
nome_da_variavel
Deve seguir o conjunto de regras apresentadas acima para identificação das variáveis.
tipo_da_variavel
É necessário informar o tipo dos dados que serão armazenados na variável para que o computador 
saiba o tamanho do espaço de memória que reservará. Esses tipos coincidem com os já 
apresentados acima, quando se tratou dos Tipos Primitivos.
Importante
Ao nomear os identificadores, é conveniente utilizar palavras mnemônicas, ou seja, palavras que lembrem o 
caráter do conteúdo armazenado. Isso facilita a leitura do código programado e possibilita que eles sejam melhor 
documentados.
18
CAPÍTULO 1 • ALGORItMO
1.5. Comandos de Entrada e Saída
São os comandos que permitem a leitura de dados da memória (Entrada) e o 
armazenamento/escrita de dados na memória (Saída).
1.5.1. Entrada
Na maioria das vezes, um algoritmo (ou programa) necessita de dados, que devem ser 
introduzidos pelo usuário, para serem processados. Nesses casos, utiliza-se um periférico 
de entrada padrão: em geral, o teclado.
Observe o exemplo abaixo que representa um possível sistema de locadora de filmes, 
em que são necessários alguns dados, por exemplo, o código do cliente e o nome do 
filme. Essas informações são fornecidas pelo sistema a partir de comandos de entrada 
de dados.
Figura 5. Declaração de variáveis e comando de entrada de dados.
1: var codigo_cliente : inteiro 
2: nome_fita: cadeia 
3: leia(codigo_cliente) 
4: leia(nome_fita) 
Fonte: Adaptado de Cechinel e Ferrari (2018).
Para realizarmos a entrada de dados utilizaremos o comando leia. Ao 
utilizar o comando leia o programador deve saber de antemão qual a 
variável que irá armazenar o valor que será fornecido pelo usuário. No 
caso do exemplo anterior, os valores fornecidos pelo usuário são referentes 
ao código do cliente e ao nome da fita que o mesmo está locando. Sendo 
assim, é necessário declarar variáveis que possam armazenar valores 
que sejam compatíveis com as informações solicitadas ao usuário. Por 
exemplo, a informação do código do cliente pode ser um valor do tipo 
inteiro, então é necessário que declaremos no algoritmo uma variável 
desse tipo, seguindo esse mesmo raciocínio, a informação do nome da fita 
pode ser uma informação do tipo caractere, sendo também necessário que 
declaremos no algoritmo uma outra variável para receber essa informação. 
(CECHINEL; FERRARI, 2018, pag. 42).
Importante
Essa sintaxe apresentada acima pode variar apenas na ordem em que são escritas. Alguns autores representam 
primeiro o nome da variável (ou lista de nomes) e, depois, o tipo delas.
19
ALGORItMO • CAPÍTULO 1
Observe no exemplo acima que, tendo sido declaradas corretamente as variáveis, a 
instrução “leia”, seguida do nome da respectiva variável entre parênteses, irá receber o 
valor correspondente digitado pelo usuário.
Observando o exemplo a seguir, quando for executada a instrução na linha 3, o usuário deverá 
informar um valor que corresponda ao que se pede, ou seja, um valor numérico inteiro, 
pressionando, a seguir, a tecla “ENTER” para que a linha 4 seja executada, armazenando o valor 
digitado na variável indicada entre parênteses. O mesmo ocorrerá nas linhas 5 e 6, sendo que 
o usuário deverá agora digitar um nome, declarado do tipo cadeia de caracteres, conforme a 
declaração na linha 2.
Figura 6. Exemplo de comando de entrada e saída.
1: var codigo_cliente : inteiro 
2: nome_finta: cadeia 
3: escreva(“digite código do cliente e tecle <ENTER>”) 
4: leia(codigo_cliente) 
5: escreva(“digite o nome da fita e tecle <ENTER>”) 
6: leia(nome_fita) 
Fonte: Adaptado de Cechinel e Ferrari (2018).
Observe no exemplo acima as linhas 3 e 5. Nelas está sendo utilizado o comando de 
saída de dados “escreva”, que apresenta na saída padrão (o monitor) a frase que se 
encontra dentro dos parênteses e entre aspas, informando ao usuário o que ele deve 
digitar para dar sequência ao processamento do algoritmo.
1.5.2. Saída
Quando se deseja apresentar algum tipo de informação no monitor (saída padrão), 
utiliza-se o comando escreva, denominado “comando de saída de dados”, seguido da 
informação desejada. Sendo assim, caso deseje escrever a frase “Boa tarde!” na tela, a 
instrução ficará da seguinte forma:
escreva (“Boa tarde!”)
As aspas não irão aparecer no monitor; servem para delimitar a frase (ou expressão) que se 
deseja que o usuário visualize. Já quando se deseja apresentar o conteúdo de uma variável 
na tela, a estrutura do comando tem uma leve modificação. Suponha que o algoritmo em 
execução deva apresentar a média de um determinado aluno, e este valor, que será 6.5 (seis 
e meio), esteja armazenado na variável “MEDIA” (observe o nome do identificador em letras 
maiúsculas como indicado na regra número 3 apresentada anteriormente). Para isso, o 
comando, ou instrução, será o seguinte:
20
CAPÍTULO 1 • ALGORItMO
escreva (MEDIA)
Irá, portanto, ser apresentado no monitor o conteúdo armazenado na variável indicada, 
ou seja, irá aparecer para o usuário o número 6.5 (atente para o detalhe que está 
sendo utilizado como separador decimal o ponto, que é o padrão das linguagens de 
programação). Observe que, nesse caso, o que está entre os parênteses não está com 
aspas, pois a palavra MEDIA corresponde ao identifcador da variável cujo valor se deseja 
que seja apresentado.
Observe agora a instrução abaixo.
escreva (“Media do aluno: “, MEDIA)
Essa instrução fará com que seja apresentada no monitor a frase Media do aluno:, seguida 
do valor da média armazenado na variável MEDIA. A frase, ou sequência de caracteres 
desejada, entre aspas fica separada do identificador que representa a variável por uma 
vírgula.
1.5.3. Operadores Aritméticos
Em geral, no desenvolvimento de algoritmos, são utilizadas expressões matemáticas para 
a resolução de cálculos. A tabela abaixo apresenta os operadores aritméticos básicos e as 
representações necessárias para escrever as expressões.
Figura 7. Operadores aritméticos utilizados.
Operação Operador Exemplo 
Adição + 2+3, 9+x
Subtração - x-1, f(x)-2
Multiplicação * 2*1, x*y, 2*g(x)
Divisão / 1/x, a/z, 2*f(x) 
Potenciação ** 10**x, 2**3 
Resto (Módulo) mod 10 mod 2, 120 mod 10 
Divisão Inteira div 10 div 2, 120 div 10 
Fonte: Adaptado de Cechinel e Ferrari (2018).
Importante
Note que, quando se deseja escrever alguma mensagem na tela (letra, frase, número etc.) literalmente, deve-se utilizar 
aspas para identificar o que será escrito, pois o que estiver entre aspas no algoritmo será exatamente o que aparecerá 
na tela do computador. Por outro lado, quando se quer escrever o conteúdo de uma variável, não se utilizam aspas.
21
ALGORItMO • CAPÍTULO 1
Nos algoritmos, assim como nas linguagens de programação, as expressões matemáticas 
sempre obedecem às regras matemáticas comuns, ou seja:
 » Quando existem parênteses nas expressões, as operações dentro dos parênteses 
têm prioridade em relação às operações fora dos parênteses. Ocorrendo vários 
níveis de parênteses, ou seja, um parêntese dentro de outro, a prioridade na 
solução se inicia nas operações do parêntese mais interno para o mais externo.
 » Em uma equação, se ocorrerem operações com a mesma prioridade, a solução é 
realizada da esquerda para a direita.
Observe a tabela abaixo, na qual são apresentadas as prioridades e a ordem de execução dos 
operadores numa expressão aritmética, conhecida como precedência de operadores.
Figura 8. Prioridade de operações aritméticas.
Ordem Operação Símbolo 
1a Parênteses ( ) 
2a Potenciação ** 
3a Multiplicação, Divisão, Resto e Divisão Inteira *, /, mod, div 
4a Adição, Subtração +, - 
Fonte: Adaptado de Cechinele Ferrari (2018).
Dessa forma, veja os seguintes exemplos e os respectivos resultados:
 » Exemplo 01: 4 + (6 * (3 + 5)) = 52
 » Exemplo 02: 4 + 6 * (3 + 5) = 52
1.5.3.1. Horizontalização
As expressões aritméticas dentro de um algoritmo devem ser escritas totalmente na 
horizontal, posicionando os operadores corretamente. A figura 9 apresenta um exemplo 
de como transformar uma expressão aritmética tradicional em seu correspondente linear. 
Para manter a ordem correta de resolução, observe a inclusão de parênteses.
Atenção
Ao se desenvolver um algoritmo, é bastante comum deixar parênteses não pareados nas expressões aritméticas, o que 
é um erro difícil de se localizar posteriormente. Um teste prático para evitar esse tipo de contratempo consiste em 
contar na expressão quantos parênteses esquerdos e direitos existem, conferindo se eles estão em mesmo número.
22
CAPÍTULO 1 • ALGORItMO
Figura 9. Horizontalização de fórmulas.
𝑴𝑴 = 𝑵𝑵𝑵𝑵 + 𝑵𝑵𝑵𝑵𝑵𝑵 𝑴𝑴 ← (𝑵𝑵𝑵𝑵 + 𝑵𝑵𝑵𝑵)/2 
Fonte: Carvalho (2007).
Exemplos
Elabore um algoritmo que armazene os valores 20 e 5 nas variáveis X e Y, respectivamente. 
Feito isso, o algoritmo deve armazenar a soma dos valores armazenados anteriormente 
na variável Z e, a seguir, apresentar no monitor o valor armazenado em cada uma das 
variáveis. A solução está apresentada abaixo.
Figura 10. Exemplo de algoritmo com horizontalização.
X ← 20 
Y ← 5 
Z ← X + Y 
escreva X 
escreva Y 
escreva Z 
escreva X, Y, Z 
Fonte: Carvalho (2007).
Elabore um algoritmo que armazene os valores 4 e 3 nas variáveis A e B, respectivamente. 
A seguir, armazene o produto de A com B na variável C e a divisão de A por B na variável 
D. Ao final, o algoritmo deve escrever os valores de A, B, C e D e a mensagem ‘Fim do 
Algoritmo’. Abaixo está uma das possíveis soluções.
Exemplo resolvido:
A ← 4
B ← 3
C ← A * B
D ← A / B
escreva (A, B, C, D)
escreva (“Fim do Algoritmo”)
23
ALGORItMO • CAPÍTULO 1
Observe, no exemplo acima, a representação da seta para a esquerda como comando de 
atribuição e as estruturas dos comandos de saída utilizados.
O exemplo abaixo representa uma solução para a seguinte proposição: suponha um algoritmo 
que leia dois valores, armazenando-os em variáveis distintas; em seguida, o algoritmo deve 
realizar o produto do primeiro valor pela soma de ambos e esse resultado deverá ser dividido 
pelo segundo valor inserido, escrevendo o resultado final no monitor.
Solução de algoritmo:
início
leia (A, B)
C ← A * (A + B) / B
escreva (C)
fim
Sintetizando
Vimos até agora:
 » A definição básica de um algoritmo.
 » Os componentes básicos de um algoritmo.
 » Os comandos básicos de um algoritmo.
 » Exemplos de algoritmos para solução de problemas simples.
24
Apresentação
É comum nos algoritmos surgirem situações em que a execução de uma ação ou 
sequência de subações esteja sujeita a uma certa condição. Essa condição é representada 
no texto do algoritmo por uma expressão lógica.
Denomina-se expressão lógica a expressão cujos operadores são lógicos e cujos operandos 
são relações, constantes e/ou variáveis do tipo lógico.
Objetivos
 » Desenvolver a capacidade de análise de problemas com soluções dependentes de 
testes.
 » Conhecer os operadores relacionais e lógigos.
 » Conhecer os comandos de tomada de decisão simples, composta e de múltipla 
escolha.
2.1. Estruturas de Condição
Até o presente caso, nos itens apresentados anteriormente, os algoritmos foram formados 
de modo sequencial, numa estrutura conhecida como “Top Down”. Nessa situação, a 
execução é realizada sequencialmente, linha após linha, até chegar no final. Porém, essa 
estrutura é limitada, pois pode ser necessário, como geralmente acontece, um “desvio” na 
sequência de execução dependendo de situações (condições) do problema ou situação 
apresentada. Nesse caso, faz-se uso de uma estrututa conhecida como estruturas de 
condição, comum à maioria das linguagens de programação conhecidas hoje em dia.
Considere, por exemplo, uma situação comum aos estudantes: verificar se determinado 
aluno está aprovado ou não ao final de um período letivo. Para isso, necessita-se saber 
2CAPÍTULOEStRUtURAS DE DECISãO
25
EStRUtURAS DE DECISãO • CAPÍTULO 2
a média considerada para aprovação e a média do aluno. Será necessário avaliar se a 
média desse aluno é maior, igual ou menor ao valor considerado base para aprovação. 
Sendo assim, caso ocorra a primeira situação, o programa executará um conjunto de 
instruções; caso contrário, o programa executará outro conjunto de instruções. São 
situações semelhantes à descrita que necessitam das estruturas de condição.
2.1.1. Operadores Relacionais
Operações relacionais são os símbolos que são utilizados para realizar as comparações 
permitidas entres valores, tais como a descrita acima. A figura abaixo apresenta os tipos 
de operadores relacionais comuns à maioria das linguagens de programação.
Figura 11. Operadores relacionais permitidos.
Símbolo Significado 
> maior 
<a menor 
= igual 
>= maior ou igual 
<= menor ou igual 
<> diferente 
 
Fonte: Carvalho (2007).
A figura 11 apresenta alguns exemplos de comparações válidas nas diversas linguagens de 
programação.
Figura 12. Operações relacionais.
Comparação válida Significado 
variável e constante X = 3 
variável e variável A <> B 
variável e expressão Y = W +J 
expressão e expressão (X + 1) < (Y + 4) 
 
 
Fonte: Carvalho (2007).
2.1.2. Estrutura de Condição Simples: se-então
A estrutura condicional mais simples que se pode utilizar é a “se-entao”, que possui a estrutura 
básica apresentada abaixo:
se <expressão-lógica> então:
<bloco de comandos>
fim se
26
CAPÍTULO 2 • EStRUtURAS DE DECISãO
A <expressão-lógica> será substituída por uma estrutura em que se compara o que se 
deseja e apresenta como resultado um valor “verdadeiro” (V ) ou “falso” (F); sendo o 
resultado verdadeiro, <bloco de comandos>, ou seja, as instruções compreendidas entre 
o “se e o “fim-se” serão executadas; caso contrário, a execução do programa continua 
a partir da linha após a estrutura de condição, ou seja, a partir da instrução abaixo do 
“fim-se”. Observe, portanto, que a estrutura condicional simples começa na instrução 
“se” e termina na instrução “fim se”.
O <bloco de comandos> consiste em um conjunto de instruções executadas apenas 
quando o resultado da expressão lógica for verdadeiro.
Voltando ao exemplo da média do aluno, considere a condição “média >= 6”. Sendo a 
média igual a 5, o bloco de comandos não será executado; se a média for igual a 8.5, o 
bloco de comandos será executado. A estrutura desse exemplo é apresentada abaixo.
Exemplo de condição simples.
var media: real
escreva (“Informe a media do aluno: “)
leia (media)
se media >= 6 então
escreva (“Aluno aprovado.”)
fim se
2.1.3. Estrutura de Condição Composta: se-então-senão
Observe novamente o exemplo de média anterior. O trecho do algoritmo apresentado só 
apresenta alguma resposta se a condição apresentada for verdadeira; mas, caso seja 
falsa, nada é apresentado. Para resolver esse problema, pode-se complementar a 
estrutura anterior criando uma “estrutra de condição composta”, acrescentando o 
comando senão. Observe a estrutura abaixo, representando a condição composta.
se <expressão-lógica> então:
<bloco de comandos verdade>
senão:
<bloco de comandos falso>
fim se
Na estrutura “se-então-senão”, o <bloco de comandos verdade>, como anteriormente, 
será executado se a <expressão lógica> for verdadeira, e, a seguir, a execução do 
algoritmo continua a partir da linha abaixo do “fim se”; se a <expressão lógica> for falsa, 
27
EStRUtURAS DE DECISãO • CAPÍTULO 2
será executado o <bloco de comandos falso>, apresentado abaixo do “senão”, dando 
continuidade à execução das linhas de comando existentes após o “fim se”.
Existe a possibilidade de a estrutura de condição não possuir a opção de comandos caso a 
resposta da condição seja falsa. Nesse caso, ela volta a ser executada como uma estruturade condição simples.
O algoritmo abaixo mostra como escrever que a pessoa é maior de idade quando tem 18 
anos ou mais, ou que a pessoa é menor de idade quando essa condição não é atendida.
Exemplo de condição composta.
var media: real
escreva (“Informe a media do aluno: “)
leia (media)
se media >= 6 então
escreva (“Aluno aprovado.”)
senão
escreva (“Aluno reprovado.”)
fim se
No exemplo acima, sendo a resposta da condição verdadeira, será apresentada a 
mensagem “Aluno aprovado” no monitor e, a seguir, o processamento “pula” para a 
primeira linha de comando após o “fim se”. Se a resposta for falsa, a primeira sequência 
de comandos (bloco de comandos verdade) não será executada, pulando para as linhas 
após o “senão”, continuando a execução do algoritmo após o “fim se”.
Observe o exemplo seguinte: escreva um algoritmo para ler um valor. Se o valor lido for 
igual a 6, escrever a mensagem ‘Valor lido igual a 6’; caso contrário, escrever a mensagem 
‘Valor lido diferente de 6’.
Exemplo resolvido:
inicio
leia (valor)
se valor = 6, então
escreva (“Valor lido igual a 6.”)
senão
escreva (“Valor lido diferente de 6.”)
fim se
fim
Mais um exemplo: desenvolver a lógica para um programa que leia dois valores numéricos 
e efetue a adição desses valores. Caso o valor somado seja maior ou igual a 10, deverá 
28
CAPÍTULO 2 • EStRUtURAS DE DECISãO
ser apresentado somando a ele mais 5; caso o valor somado não seja maior ou igual a 
10, este deverá ser apresentado subtraindo 7.
1. Ler um valor para a variável A e outro valor para a variável B.
2. Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X.
3. Verificar se X é maior ou igual a 10; caso seja verdadeiro, calcule R ←x + 5. Caso não 
seja, calcule R ←X – 7.
início
var A, B, X, R: inteiro
escreva (“Digite um número:”)
leia (A)
escreva (“Digite outro número:”)
leia (B)
X ← A + B
se (X >= 10) então
R ← X + 5
senão
R ← X – 7
fim se
escreva (“O resultado é:”, R)
fim
Observe que, após a definição dos tipos de variáveis, é solicitada a leitura dos valores 
para as variáveis A e B. Depois, esses valores são atribuídos na variável X, a qual possui 
o resultado da adição dos dois valores. Nesse ponto, é questionada no programa uma 
condição que permitirá escrever o resultado da soma adicionado de 5, caso esta seja 
maior ou igual a 10; não sendo, o programa apresentará o resultado subtraindo 7.
2.1.4. Estruturas de Condição Concatenadas
Ao utilizar uma estrutura de condição composta, é possível agrupar outras estruturas 
do mesmo tipo umas dentro das outras. Neste caso, tem-se a estrutura de condição 
concatenada ou aninhada.
Nas estruturas de decisão concatenadas, os blocos de comando verdade ou falso podem 
conter outras estruturas concatenadas e, neste caso, a estrutura de condição mais interna 
será analisada se as anteriores o forem e uma das condições for satisfeita.
29
EStRUtURAS DE DECISãO • CAPÍTULO 2
Por exemplo, suponha que se deseja verificar o problema referente às médias 
dos alunos de uma dada disciplina. Sabe-se que um aluno é aprovado caso 
apresente média maior ou igual a 7.0 e frequencia maior ou igual a 75%. Além 
disso, se o aluno obtiver a frequência minima exigida e uma média entre 3 
e 7, poderá realizar uma última avaliação de recuperação. Para resolver o 
problema em questão utilizando apenas estruturas de condição se-então-
senão pode-se iniciar verifcando a frequencia do aluno, e se a mesma for 
menor que 75% o aluno será considerado reprovado, mesmo com média 
aceitável, porém caso a frequencia respeite o mínimo exigido, é necessário 
a avaliar a média para saber se está aprovado, em recuperação ou reprovado. 
No momento em que é verificado que a frequencia é menor que 0.75 (75%) 
o aluno já está imediatamente reprovado, mas caso a frequencia seja maior 
ou igual a esse valor, pode-se continuar com o algoritmo para avaliar em 
que situação que o aluno se encontra. Nesta sequência, é necessário avaliar 
a média do mesmo, verificando se está acima de 7.0 (aprovado), entre 3 e 
7.0 (recuperação), ou abaixo de 3.0 (reprovado). Observe o algoritmo abaixo 
que apresenta uma solução para o exemplo descrito. (CECHINEL; FERRARI, 
2018, pag. 50).
Condição concatenada.
var frequencia, media: real
escreva (“Digite a media e a frequencia: “)
leia (media, frequencia)
se frequencia >= 0.75 então
se media >= 7 então
escreva (“Voce está APROVADO”)
senão
se media >= 3 então
escreva (“Voce está em RECUPERACAO”)
senão
escreva (“Voce está REPROVADO POR MEDIA”)
fim se
fim se
senão
escreva (“Voce esta REPROVADO POR FALTAS”)
fim-se
Fonte: CECHINEL, Cristian; FERRARI, Fabrício, 2018.
Desenvolver a lógica para um programa que efetue o cálculo do reajuste de salário de 
um funcionário. Considere que o funcionário deverá receber um reajuste de 15% caso 
seu salário seja menor ou igual a 500. Se o salário for maior que 500, mas menor ou igual 
30
CAPÍTULO 2 • EStRUtURAS DE DECISãO
a 1.000, seu reajuste será de 10%; caso seja ainda maior que 1.000, o reajuste deverá ser 
de 5%.
Perceba que o problema em questão estabelece três condições para calcular o reajuste do 
salário do funcionário, sendo:
 » Salário <= 500, reajuste de 15%.
 » Salário > 500, mas <= 1.000, reajuste será de 10%.
 » Salário > 1.000, reajuste será de 5%.
Essas condições deverão ser encadeadas, pois todas as possibilidades de reajuste deverão 
ser cercadas. Sendo assim, observe o algoritmo abaixo:
1. definir uma variável para o salário reajustado: novo_salario;
2. ler um valor para a variável salário;
3. verificar se o valor de salário <= 500; se sim, reajustar em 15%;
4. verificar se o valor de salário <= 1.000; se sim, reajustar em 10%;
5. verificar se o valor de salário > 1.000; se sim, reajustar em 5%;
6. apresentar o valor reajustado, atribuindo a novo_salário.
inicio
var salario, novo_salario: real
escreva (“Digite o valor do salario:”)
leia (salario)
se ( salario <= 500 ) então
novo_salario ← salario * ( 15 / 100 )
senão
se ( salario <= 1000 ) então
novo_salario ← salario * ( 10 / 100 )
senao
novo_salario ← salario * ( 5 / 100 )
fim se
fim se
escreva (“O valor do novo salario é:” ,novo_salario)
fim
31
EStRUtURAS DE DECISãO • CAPÍTULO 2
2.1.5. Operadores Lógicos
Em muitos casos, pode-se realizar testes múltiplos na mesma expressão lógica. Voltando 
ao exemplo de média de um aluno, suponha que exista uma condição em que o aluno terá 
que fazer uma prova de recuperação caso a média fique no intervalo maior ou igual a 5 e 
menor que 7. Nesse caso, utilizando os operadores lógicos, a expressão lógica ficaria: se 
(media >= 5) e (media < 7). Observe a figura abaixo, na qual são apresentados os operadores 
lógicos utilizados na maioria das linguagens de programação.
Figura 13. Operadores lógicos utilizados.
Operação Operador 
Negação não 
Conjunção e 
Disjunção (não-exclusiva) ou 
Disjunção (exclusiva) xou 
(lê-se: “ou exclusivo) 
Fonte: Carvalho (2007).
Note que a tabela acima apresenta os operadores lógicos já ordenados de acordo com 
suas prioridades, ou seja, se na mesma expressão ocorrer o operador ou e o operador 
não, por exemplo, primeiro será executado o não e depois o ou.
Observe que as respostas obtidas com os operadores lógicos têm grande 
semelhança com o conhecido Mapa de Karnaugh, basta verificá-lo e comparar 
com a Tabela Verdade apresentada abaixo. 
Figura 14. tabela verdade.
A B A e B A ou B não A A xou B 
F F F F V F 
F V F V V V 
V F F V F V 
V V V V F F 
Fonte: Carvalho (2007).
Abaixo, alguns exemplos de utilização de operadores lógicos:
32
CAPÍTULO 2 • EStRUtURAS DE DECISãO
Figura 15. Uso de operadores lógicos.
 
Expressão Quando eu não saio? 
Se chover e relampejar, eu não saio Somente quando chover e relampejar ao 
mesmo tempo (apenas 1 possibilidade) 
Se chover ou relampejar, eu não saio Somente quando chover, somente quando 
relampejar ou quando chover e relampejar ao 
mesmo tempo (3 possibilidades) 
Se chover xou relampejar,eu não 
saio 
Somente quando chover, ou somente quando 
relampejar (2 possibilidades) 
Fonte: Carvalho (2007).
Os exemplos A, B e C abaixo são apresentados em Português Estruturado:
a. se (salario > 180) e (salário < 800) então
escreva (“Salário válido para financiamento”)
senão
escreva (“Salário fora da faixa permitida para financiamento”)
fim se
b. se (idade < 18) ou (idade > 95) então
escreva (“Você não pode fazer carteira de motorista”)
senão
escreva (“Você pode possuir carteira de motorista”)
fim se
c. se (idade > = 18) e (idade < = 95) e (aprovado_exame = ‘sim’) então
escreva (“Sua carteira de motorista estará pronta em uma semana”)
senão
escreva (“Você não possui idade permitida ou não passou nos testes”)
fim se
Exemplos de utilização de operadores lógicos resolvidos
Desenvolver a lógica para um programa que leia um (entre 0º e 360º) e que escreva o 
quadrante ao qual pertence. Ignorar os eixos:
1. ler um valor para a variável ângulo ;
2. verificar se o ângulo digitado é > 0 e < 90, se for verdade: “ângulo está no primeiro 
quadrante”;
33
EStRUtURAS DE DECISãO • CAPÍTULO 2
3. verificar se o ângulo digitado é > 90 e < 180, se for verdade: “ângulo está no segundo 
quadrante”;
4. verificar se o ângulo digitado é > 180 e < 270, se for verdade: “ângulo está no terceiro 
quadrante”;
5. verificar se o ângulo digitado é > 270 e < 360, se for verdade: “ângulo está no quarto 
quadrante”.
inicio
var angulo: inteiro
escreva (“Digite um ângulo: “)
leia (angulo)
se ( angulo > 0 ) .e. ( angulo < 90 ) então
escreva (“Ângulo está no primeiro quadrante”)
senão
se ( angulo > 90 ) .e. ( angulo < 180 ) então
escreva (“Ângulo está no segundo quadrante”)
senão
se ( angulo > 180 ) .e. ( angulo < 270 ) então
escreva (“Ângulo está no terceiro quadrante”)
senão
se ( angulo > 270 ) .e. ( angulo < 360 ) então
escreva (“Ângulo está no quarto quadrante”)
fim se
fim se
fim se
fim se
fim
O programa acima não se preocupa se o usuário digitar um valor indevido, ou seja, se 
não estiver na faixa ou estiver em um dos eixos. Esse exemplo foi feito dessa forma para 
que se possa concentrar apenas no operador lógico “e”.
Desenvolver a lógica para um programa que leia o código relativo ao sexo (masculino=1 
ou feminino=2). Se for digitado um código correto, informar que o código é válido, 
caso contrário informar que o código é inválido:
1. ler um código numérico para a variável código;
2. se o código digitado for igual a 1 ou igual a 2, apresentar uma mensagem informando 
que o código é válido; caso contrário, informar que o código é inválido.
34
CAPÍTULO 2 • EStRUtURAS DE DECISãO
inicio
var codigo: inteiro
escreva (“ Digite um código:”)
leia (codigo)
se ( codigo = 1 ) .ou. ( codigo = 2 ) então
escreva (“O código do sexo é válido”)
senão
escreva (“O código do sexo é inválido”)
fim se
fim
O exemplo mostra, por meio da utilização do operador .ou. , que somente será 
apresentada a mensagem “O código do sexo é válido” caso o valor fornecido para a 
variável código seja 1 ou 2. Qualquer outro valor fornecido apresentará a mensagem: 
“O código do sexo é inválido”.
Sintetizando
Vimos até agora:
 » Que os algoritmos podem ser utilizados em problemas que necessitem de testes para serem solucionados.
 » Os operadores relacionais e lógicos utilizados.
 » Os comandos que compõem as estruturas simples e compostas de decisão.
35
Apresentação
Existem ocasiões em que é necessário efetuar determinado número de vezes a 
repetição de um trecho de programa. Nesse caso, poderá ser criado um looping para 
que efetue o processamento de determinado trecho tantas vezes quantas forem 
necessárias. Os loopings também são chamados de laços de repetição.
Supondo que um programa deve executar um determinado trecho de instruções por 
cinco vezes, com o conhecimento adquirido até este momento, você iria escrever o 
mesmo trecho, repetindo-o o número de vezes necessárias. 
Para esses casos, existem comandos apropriados para efetuar a repetição de 
determinados trechos de programas. A principal vantagem desse recurso é que o 
programa passa a ter um tamanho menor, podendo sua amplitude de processamento 
ser aumentada sem alterar o tamanho do código de programação. Dessa forma, 
pode-se determinar repetições com números variados de vezes.
Objetivos
 » Capacitar o aluno a identificar as ações que devem ser executadas de forma 
repetitiva na solução de problemas.
 » Capacitar o aluno a determinar as condições de controle da repetição.
 » Apresentar os recursos de programação “enquanto” e “para”.
3.1.Estrutura de Repetição
Uma das principais características que consolidaram o sucesso na utilização dos 
computadores para a resolução de problemas foi a sua capacidade de repetir o 
processamento de um conjunto de operações para grandes quantidades de dados. 
3CAPÍTULOEStRUtURAS DE REPEtIçãO
36
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
Exemplos de conjuntos de tarefas que repetimos diversas vezes dentro de uma situação 
específica podem ser observados largamente no nosso dia a dia. (CECHINEL; FERRARI, 
2018, pag. 53).
Em uma estrutura de repetição, uma sequência de instruções é executada diversas 
vezes, interrompendo essa repetição quando uma condição é satisfeita, ou seja, esse 
conjunto de instruções é repetido sem a necessidade de reescrevê-las várias vezes. 
Algumas publicações tratam as estruturas de repetição como “laços ou loops”.
É possível definir quando é necessário o uso de uma estrutura de repetição analisando 
o problema e verificando se uma instrução ou uma sequência de instruções deve ser 
executada várias vezes. Sendo isso confirmado, deve-se, então, providenciar a criação 
de uma estrutura de repetição. As estruturas de repetição envolvem a avaliação de uma 
condição para ser interrompida; logo, ela possui instruções semelhantes às estruturas 
de decisão para sua correta execução.
Figura 16. Fluxograma da instrução enquanto...faça...fim_enquanto.
Condição 
Instruções executadas 
enquanto a condição é 
verdadeira 
N 
S 
Fonte: Escola Alcides Maya (2018).
Cuidado
Cuidado para não confundir essa nova estrutura com a estrutura de decisão usada anteriormente. Nesse caso, o 
processamento retorna à condição após a execução do conjunto de instruções enquanto a condição não for satisfeita.
37
EStRUtURAS DE REPEtIçãO • CAPÍTULO 3
As estruturas de repetição podem ser apresentadas de três maneiras diferentes: 
enquanto-faça, faça-enquanto e para-faça. A principal diferença entre elas é: 
“enquanto-faça” executa primeiro o teste da condição para depois realizar o bloco 
de comando; ao contrário, “faça-enquanto” executa o bloco uma vez antes de testar 
a condição; já a estrutura “para-faça” possui um conjunto de instruções que simulam 
as duas anteriores para definir quando toda a estrutura deve ser finalizada. Cada 
uma tem suas próprias características, mas podem ser utilizadas para resolver um 
mesmo problema. Dessa forma, o programador deverá avaliar qual a melhor opção 
a ser utilizada.
3.1.1. teste no Início: enquanto-faça
Abaixo tem-se uma representação do formato geral da estrutura de repetição 
“enquanto-faça”. Observe que, antes de entrar na estrutura de repetição, uma 
expressão lógica é analisada e, sendo o resultado verdadeiro, as instruções dentro 
da estrutura serão executadas. A seguir, a mesma expressão lógica é avaliada; assim 
que o resultado da expressão se torna falso, o processamento sai da estrutura de 
repetição e continua a partir da linha abaixo dessa estrutura.
Estrutura de repetição enquanto-faça.
enquanto <expressão lógica> faça
<sequência de comandos>
fim enquanto
A alteração do resultado da expressão lógica depende, geralmente, de uma instrução 
dentro do bloco de comandos ou de uma variável externa fornecida pelo usuário, ou 
sistema, durante a execução.
A escolha dessa estrutura recai, na maioria das vezes, quando não se sabe com 
antecedência a quantidade de repetições a serem realizadas. 
Por exemplo, suponha que,em um algoritmo, é oferecido ao usuário 3 opções de menu 
sendo que uma dessas opções é a de sair do programa. Caso se deseje que o usuário 
possa executar várias vezes as opções dispostas no menu, não se tem como determinar 
quando o usuário irá optar por sair do algoritmo; sendo assim, não se pode limitar a 
repetição a um determinado número de vezes. 
Considere um problema mais específico onde é necessário realizar a leitura 
de vários nomes de pessoas e a cada nome que lido deve-se escrever na tela 
a frase “O nome digitado foi nome”, onde nome é a variável. A princípio 
isso deve ser feito diversas vezes e quando o usuário digitar um nome 
38
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
igual a “fim” o algoritmo deve parar. Da mesma maneira que no exemplo 
anterior não se pode definir quando o usuário irá digitar “fim”, não se tem 
como definir a quantidade de vezes que o algoritmo deverá repetir esse 
conjunto de ações (CECHINEL; FERRARI, 2018, pag. 54).
Elabore um algoritmo que leia um determinado valor do teclado e armazene-o na 
variável A; o algoritmo deverá multiplicar esse valor por 10, armazenando o resultado 
na variável B, apresentando, a seguir, o resultado; isso deverá ser repetido quatro vezes.
Sequência do algoritmo:
1. criar as variáveis necessárias: uma para controlar as repetições (contador, 
inicializado com o valor 1) e as demais – enquanto o valor desse contador for 
menor ou igual a 4, os passos identificados de 2 a 5 serão executados;
2. ler o valor digitado pelo usuário, armazenando-o em A;
3. realizar a multiplicação desejada e armazenar o resultado em B;
4. apresentar, no monitor, o valor do cálculo obtido e armazenado na variável B;
5. somar 1 na variável definida como contador;
6. quando o valor do contador for maior que 4, encerrar o processamento.
inicio
var A, B, CONTADOR: inteiro
CONTADOR ← 1
enquanto ( CONTADOR <= 4 ) faça
leia (A)
B ← A * 10
escreva (B)
CONTADOR ← CONTADOR + 1
fim enquanto
fim
Observe que foi necessário criar uma terceira variável (CONTADOR) para controlar o 
número de repetições do processo que deverá ser executado. Essa variável foi iniciada 
Atenção
1. A repetição (o laço) se encerra quando a condição (teste) é falsa.
2. As instruções a serem repetidas podem nunca ser executadas, porque o teste é no início da repetição.
39
EStRUtURAS DE REPEtIçãO • CAPÍTULO 3
com o valor 1, sendo gradativamente incrementada durante o processamento. Observe 
que a instrução “enquanto”, seguida da condição, controla a repetição e, quando a variável 
CONTADOR atingir o valor de interrupção (valor = 5), a estrutura será finalizada.
Depois de efetuar a primeira leitura, a instrução “CONTADOR ← CONTADOR + 1” incrementa 
a variável de controle, reinicializando o conteúdo.
Quando a variável CONTADOR passa a ser 5, resultando, para a instrução “enquanto”, uma 
condição “falsa”, o processamento será redirecionado para a primeira instrução após a 
instrução “fim_enquanto”, ou seja, para a instrução “fim”, encerrando o programa.
Imagine de outra forma: o exemplo deverá ser executado enquanto o usuário desejar, 
ou seja, o contador de vezes não existe e, em seu lugar, uma instrução solicitando ao 
usuário que informe se deseja continuar ou não.
Sequência do algoritmo:
1. criar uma variável para ser utilizada como resposta se deseja ou não continuar – 
enquanto a reposta for sim, serão executados os passos de 2 a 4;
2. ler um valor para a variável A;
3. efetuar a multiplicação do valor de A por 10, armazenando o resultado na variável B;
4. apresentar o valor calculado armazenado em B;
5. quando a resposta for diferente de “sim”, interrompe-se o processamento da 
repetição.
inicio
var A, B: inteiro
 resp: caractere
resp ← ‘S’
enquanto ( resp = ‘S’ ) faça
leia (A)
B ← A * 10
escreva (B)
escreva (“Deseja continuar ?”)
leia (resp)
fim enquanto
fim
Veja que o contador foi substituído pela variável resp, que, enquanto for igual a ‘S’, executará 
a rotina existente entre as instruções enquanto e fim_enquanto.
40
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
Observe que o número de vezes que o processo se repetirá é agora controlado pelo 
usuário, encerrando-se quando alguma informação diferente de ‘S’ for fornecida para 
a variável “resp”.
3.1.2.teste no Fim: faça-enquanto ou repita-até
Essa instrução tem como característica principal o teste que controla as repetições no 
final da estrutura.
Essa estrutura também é conhecida por “repita”, e, para o processamento, sua estrutura 
básica utiliza as seguintes instruções: “repita...até_que”.
A estrutura “repita...até_que” sempre irá processar um conjunto de instruções pelo menos 
uma vez até que a condição se torne verdadeira. Para a estrutura “repita”, o conjunto de 
instruções é executado enquanto a condição de controle se mantiver “Falsa” e até que 
ela se torne “Verdadeira”.
Veja, a seguir, como se apresentam as estruturas básicas dessa instrução.
Estrutura de repetição faça-enquanto.
faça
<sequência de comandos>
enquanto <expressão lógica>
Estrutura de repetição repita-até.
repita
<sequência de comandos>
até que <expressão lógica>
Retornando ao exemplo inicial de estruturas de repetição, elabore um algoritmo que 
faça a leitura de um valor que será armazenado na variável A, multiplicando esse valor 
por 10, armazenando a resposta na variável B, devendo, a seguir, apresentar o resultado; 
essa sequência deve ser repetida por quatro vezes. É o mesmo exemplo utilizado na 
estrutura “enquanto”, para que se possa fazer uma comparação entre elas.
Atenção
1. A repetição (o laço) se encerra quando a condição (teste) for verdadeira.
2. As instruções a serem repetidas são executadas pelo menos uma vez, porque o teste é no final da repetição..
41
EStRUtURAS DE REPEtIçãO • CAPÍTULO 3
Sequência do algoritmo:
1. criar as variáveis necessárias, incluindo um controlador da repetição com valor inicial 1;
2. ler um valor digitado pelo usuário, armazenando-o na variável A;
3. realizar a multiplicação do valor de A por 10, armazenando o resultado em B;
4. apresentar o valor calculado contido na variável B;
5. realizar o incremento da variável controladora;
6. repetir os passos 2 a 5 até que a variável controladora seja maior que 4.
inicio
var A, B, CONTADOR: inteiro
CONTADOR ← 1
repita
leia (A)
B ← A * 10;
escreva (B)
CONTADOR ← CONTADOR + 1
até que (CONTADOR > 4 )
fim
Logo no início do processo, ao CONTADOR é atribuído o valor 1. A seguir, a instrução 
“repita” faz com que a sequência de instruções seguintes, até a instrução “até_que”, 
seja repetida até satisfazer a a condição CONTADOR > 4.
Logo a seguir, é apresentado o mesmo exemplo sem o uso da variável de controle. 
Observe que, neste caso, o responsável pelo encerramento do processo será o usuário.
início
var A, B: inteiro
 resp: caractere
repita
leia (A)
B ← A * 10
escreva (B)
escreva (“Deseja continuar ?”)
leia (resp)
até que ( resp < > ‘S’ )
fim
42
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
Observe que a variável “resp” não precisou ser inicializada com qualquer valor, pois 
não influencia diretamente na estrutura repita, considerando que será executada 
pelo menos uma vez, verificando apenas no final se a condição resp <> ‘S’ é aceita.
Escreva um algoritmo para ler dois valores. Após a leitura, deve-se calcular a soma 
dos valores lidos e armazená-la em uma variável. Após o cálculo da soma, escrever o 
resultado e escrever também a pergunta “Deseja realizar novo cálculo (S/N)?”. Deve-se 
ler a resposta e, se a resposta for ‘S’ (sim), os comandos serão repetidos (instruções), 
mas, se a resposta for ‘N’ (não), o algoritmo deve ser finalizado escrevendo a mensagem 
‘Fim dos Cálculos’.
Resposta: Estrutura repita-até que. 
início
var A, B, soma: inteiro
 resp: caractere
repita
leia (A, B)
soma ← A + B
escreva (soma)
escreva (“Deseja realizar novo cálculo (S/N)?”)
leia (resp)
ate que (resp = ‘N’)
escreva (“Fim dos Calculos”)
fim
3.1.3. Repetição com Controle: para ou para-faça
Anteriormente,foram vistas duas formas de elaborar looping: uma usando o conceito 
“enquanto” e outra usando o conceito “repita”. Foi visto também como elaborar rotinas 
que efetuam a execução de um looping determinado número de vezes, com a utilização 
de um contador (por meio de uma variável de controle).
Porém, existe uma possibilidade que facilita o uso de contadores finitos sem utilizar as 
duas estruturas anteriores, deixando-as para quando não se conhece antecipadamente 
o número de vezes que determinada sequência de instruções deverá ser executada. Os 
loopings que possuem um número finito de execuções poderão ser processados por 
meio de uma estrutura conhecida como para, tendo como formato básico um conjunto 
de instruções “para...de...até...passo...faça...fim_para”.
A estrutura “para...de...até...passo...faça...fim_para” tem a sua lógica controlada por uma 
variável conhecida como contador, por isso a necessidade de se conhecer o número de 
repetições, ou o limite a ser atingido, da situação em estudo.
Abaixo é apresentada a estrutura básica da lógica da função “para”.
43
EStRUtURAS DE REPEtIçãO • CAPÍTULO 3
Estrutura de repetição para-faça.
para <nome da variável> de <valor inicial> até <valor final> passo <incremento> faça
<sequência de comandos>
fim para
Considere a seguinte situação: escreva um algoritmo para escrever cinco vezes a palavra BOA 
TARDE na tela.
Resposta: Estrutura de repetição para-faça.
início
para x de 1 até 5 passo 1 faça
escreva (“BOA TARDE”)
fim para
fim
Na resposta acima, o X é a variável de controle (que, nesse caso, funciona como o 
contador), ou seja, uma variável qualquer (com qualquer nome) que vai determinar o 
número de repetições do processo. O valor 1 é o valor inicial que será atribuído à variável 
X, e o valor 5 é o valor final, ou limite, atribuído à variável X; com isso, tem-se cinco 
repetições da instrução (ou das instruções) que estiver dentro do laço.
Cada vez que a variável é incrementada (aumenta uma unidade), as instruções de dentro 
da repetição são executadas; então, a variável, X no exemplo, inicia com o valor 1 e a cada 
execução (repetição) aumenta +1 (é incrementada), até chegar ao valor final, que também 
é determinado (no caso é o 5).
Ainda utilizando o exemplo das outras estruturas de repetição, pode-se observar o 
funcionamento dessa nova função. Acompanhe a resolução abaixo.
Sequência do algoritmo:
1. definir um contador, cujos limites inicial e final são, respectivamente, 1 e 5 (cinco 
repetições);
2. ler um valor digitado pelo usuário que será armazenado em A;
Para refletir
Você saberia dizer qual é a grande diferença entre a estrutura de repetição Para e as estruturas Repita e Enquanto?
44
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
3. efetuar os cálculos definidos, armazenando o resultado em B;
4. apresentar o valor obtido, que está armazenado em B;
5. repetir a sequência de 2 a 4 enquanto o controlador se mantiver no intervalo definido.
início
var A, B, CONTADOR: inteiro
para CONTADOR de 1 até 5 passo 1 faça
leia (A)
B ← A * 10
escreva (A)
fim para
fim
Repare agora uma estrutura que apresenta os valores de 1 até 10. Essa estrutura serve 
para verificar as alterações no conteúdo de uma variável utilizada como controle da 
repetição, pois ela apresenta exatamente o conteúdo dessa variável.
Sequência do algoritmo:
1. definir um contador, variando de 1 a 10;
2. apresentar o valor armazenado na variável de controle;
3. repetir o passo 2 até que o contador atinja o limite estipulado.
inicio
var cont: inteiro
para cont de 1 até 10 passo 1 faça
escreva (cont)
fim para
fim
Agora, invertendo o raciocínio do exemplo acima, elabore um algoritmo que escreva na tela 
os números de 10 até 1.
Vamos utilizar a estrutura para...de...até...passo...faça...fim_para, mas com o passo 
decrementando o valor da variável contadora.
Sequência do algoritmo:
1. definir um contador, variando de 10 a 1;
2. apresentar o valor armazenado na variável de controle;
45
EStRUtURAS DE REPEtIçãO • CAPÍTULO 3
3. repetir o passo 2 até que o contador atinja o limite esperado.
inicio
var cont: inteiro
para cont de 10 até 1 passo -1 faça
escreva (cont)
fim para
fim
3.2. Determinação do Maior e Menor Valor
Em diversas ocasiões, surgem problemas em que é necessário determinar qual o maior ou o 
menor valor em um conjunto de valores.
Escreva um algoritmo para ler a nota de 10 alunos e escrever o valor da nota mais alta e a 
mais baixa.
Exemplo resolvido.
início
var maior, menor, i: inteiro
 nota: real
maior ← 0
menor ← 10
para i de 1 até 10 passo 1 faça
leia (nota)
se (nota > maior) então
maior ← nota
fim se
se (menor < nota) então
menor ← nota
fim se
fim para
escreva (“Maior:”, maior)
escreva (“Menor:”, menor)
fim
46
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
3.3. Contadores e Acumuladores
Em algoritmos com estruturas de repetição (Repita, Enquanto ou Para), é comum surgir 
a necessidade de se realizar contagens de ocorrências, somas ou produtos consecutivos 
de valores em um conjunto de dados. Nessa situação, faz-se uso de variáveis específicas 
para o armazenamento dos resultados. As variáveis utilizadas para a contagem de 
ocorrências são conhecidas como contadores, e as variáveis utilizadas para armazenar 
os resultados de somas ou produtos sequenciais são conhecidas como acumuladores.
3.3.1. Contadores
Um contador é utilizado para contar o número de vezes que um evento (uma instrução) 
ocorre, ou seja, contar a quantidade de vezes que uma instrução, ou conjunto de instruções, 
é executada.
Forma Geral: VARIÁVEL ← VARIÁVEL + CONSTANTE
Exemplo: X ← X + 1
Explicação: um contador é uma variável (qualquer) que recebe ela mesma mais um valor (uma 
constante). No caso do exemplo acima, a variável X está recebendo o valor dela mesma mais 1. 
Normalmente a constante que será somada no contador é o valor 1, para contar de 1 em 1, mas 
pode ser qualquer valor, como, por exemplo, 2, se quisermos contar de 2 em 2.
Observações dos Contadores:
1. A variável (do contador) deve possuir um valor inicial conhecido, isto é, ela 
deve ser inicializada. Normalmente inicializa-se a variável do contador com 
zero, ou seja, zera-se a variável antes de utilizá-la. Para zerar uma variável, 
basta atribuir a ela o valor zero: VARIÁVEL ← 0.
2. A constante (que é geralmente o valor 1) determina o valor do incremento da 
variável (do contador), ou seja, o que será somado (acrescido) a ela.
Atenção
Quando se tem conhecimento dos limites dos valores possíveis, por exemplo, os valores das notas serão sempre de 0 a 
10, então se sabe quais são os valores limites (o valor mínimo e o valor máximo), ou seja, não ocorrerá nenhuma nota 
menor que 0 ou maior que 10. Nesses casos, é mais fácil descobrir o maior ou o menor valor, pois é possível inicializar 
a variável Maior, por exemplo, com o valor 0 e a variável Menor com o valor 10 que funcionará perfeitamente. Porém, 
se os valores dos limites não são conhecidos, a situação se complica um pouco, pois não se saberá com que valor 
deve-se inicializar as variáveis para comparação. Nesse caso, aconselha-se inicializar tanto a variável Maior quanto 
a Menor com o “primeiro valor lido” e depois comparar os próximos valores lidos com o primeiro (os nomes “Maior” 
e “Menor” são apenas exemplos, pode-se denominar as variáveis que serão usadas para os testes como quiser) 
(CARVALHO, 2007).
47
EStRUtURAS DE REPEtIçãO • CAPÍTULO 3
Exemplo: escreva um algoritmo para ler a nota de 10 alunos e contar quantos foram 
aprovados, sendo que, para ser aprovado, a nota deve ser maior ou igual a 6,0. Escrever 
o número de aprovados.
Exemplo resolvido.
início
var contador, nota, i: inteiro
contador ← 0
para i de 1 até 10 passo 1 faça
leia (nota)
se (nota >= 6) então
contador ← contador + 1
fim se
fim para
escreva (contador)
fim
3.3.2. Acumuladores ou Somadores
Os acumuladores são semelhantes aos contadores em sua filosofia: a um valor já 
existente na variável (o acumulador), acrescentarou multiplicar outro valor armazenado 
em outra variável. Para acrescentar valores ao acumulador, ele dever ser inicializado 
com o valor 0 e incrementado no valor de outro termo qualquer, dependendo do 
problema em questão.
Forma Geral: VARIÁVEL1 ← VARIÁVEL1 + VARIÁVEL2
Exemplo: X ← X + Y
Explicação: um acumulador (somador) é uma variável (qualquer) que recebe outra 
variável. No caso do exemplo acima, a variável X está recebendo o valor dela mesma 
mais o valor da variável Y. A variável Y representa o valor a ser somado, acumulado 
(incrementado) na variável X.
Observações dos Acumuladores:
1. A variável1 (do acumulador) deve possuir um valor inicial conhecido, isto é, 
ela deve ser inicializada. Normalmente, inicializa-se a variável do acumulador 
Para refletir
Se, no exemplo acima, fosse solicitado para contar também o número de reprovados, o que deveria ser feito? 
48
CAPÍTULO 3 • EStRUtURAS DE REPEtIçãO
com zero, ou seja, zera-se a variável antes de utilizá-la. Para zerar uma variável, 
basta atribuir a ela o valor zero: VARIÁVEL1 ← 0
2. A variável2 indica o valor a ser acumulado, somado e armazenado na variável1.
3. Ao serem utilizados os acumuladores para armazenar produtos sucessivos, 
deve-se utilizar um valor neutro da multiplicação (o número 1) para inicializar 
a variável que servirá como acumulador.
Exemplo: veja a solução abaixo, em que o exemplo acima foi alterado para calcular 
também a média geral da turma e, ao final, apresentar o total de aprovados e a média.
Exemplo de acumuladores.
inicio
var contador, soma, i, nota: inteiro 
contador ← 0
soma ← 0
para i de 1 até 10 passo 1 faça
leia (nota)
se (nota >= 6) então
contador ← contador + 1
fim se
soma ← soma + nota
fim para
media ← soma/10
escreva (contador, media)
fim
Atenção
Normalmente, inicializam-se as variáveis que serão utilizadas como contador ou como acumulador com o valor zero, 
mas elas podem ser inicializadas com o valor que se desejar, de acordo com a necessidade.
Sintetizando
Vimos até agora:
 » Conceitos e exemplos de estruturas de repetição (laços).
 » Como identificar as ações a serem executadas de modo repetitivo.
 » Como determinar as condições de uso dos controles de repetição.
 » Como utilizar as diversas formas de estruturas de repetição.
 » Qual a diferença de uso de contadores e acumuladores.
49
Apresentação
Do mesmo modo que é possível se ter uma Seleção dentro de outra, também se pode ter uma 
Repetição dentro de outra, dependendo do problema a ser resolvido. Além disso, pode ser 
necessária uma estrutura de, por exemplo, Repita dentro de um Enquanto ou vice-versa, ou um 
Repita dentro de outro Repita, enfim, as combinações são inúmeras. A seguir, serão apresentados 
exemplos de estruturas de repetição “Para dentro de outro Para”, que é bastante utilizada para 
leitura e escrita de Vetores e Matrizes, por exemplo.
Objetivos
 » Desenvolver a capacidade de criar algoritmos com estruturas de dados aninhadas.
4.1. Estruturas de Dados Homogêneas
Ao serem apresentadas as estruturas dos desvios condicionais e as estruturas de 
repetição, observou-se que as possibilidades de programação são mais extensas 
do que se imaginava. Entretanto, mesmo com o uso das novas técnicas, ainda 
não é possível resolver alguns tipos de problemas, pois as variáveis apresentadas 
são simples e armazenam apenas um único valor por vez.
Neste tópico, serão apresentadas técnicas de programação que permitirão 
trabalhar com um conjunto de informações dentro de uma mesma, e única, 
variável.
Essas estruturas de dados também são conhecidas como: variáveis indexadas, 
var iáveis compostas, arranjos, vetores, matr izes – podem, porém, ser 
chamadas apenas de matrizes.
4CAPÍTULOEStRUtURAS DE DADOS
50
CAPÍTULO 4 • EStRUtURAS DE DADOS
4.1.1. Matrizes de uma dimensão ou vetores
Vetores são varíaveis compostas que podem armazenar um conjunto de 
valores. Todos estes valores são referenciados através do nome do vetor 
(o mesmo para todo o conjunto de valores) e de um índice (distinto para 
cada valor) e constituído por uma constante inteira positiva. As variáveis 
vetoriais são semelhantes aos vetores usados na matemática e na física, 
em que um vetor, por exemplo é constituído por três valores x1, x2 e x3; 
neste caso o nome do vetor é x e os índices são 1, 2 e 3. Ao contrário de um 
escalar que possui só um valor, x, neste exemplo, é uma variável composta 
por 3 valores. As variáveis vetoriais, nos problemas reais, são constituídas 
por um grande número de valores (CECHINEL; FERRARI, 2018, pag. 60). 
Como, em um vetor, os valores armazenados devem ser todos do mesmo tipo, os vetores 
são, então, chamados de variáveis compostas homogêneas.
Ex e m p l i f i c a n d o o u s o d e m a t r i ze s, o b s e r ve a s e g u i n t e s i t u a ç ã o : “E m u m a 
determinada instituição de ensino, um professor realiza seis avaliações durante 
o período letivo. Deseja-se fazer um programa que leia as seis notas dos alunos 
e, ao final, calcule e apresente a média do aluno”.
Dessa forma, será necessário somar as seis notas de cada aluno e calcular a média. A 
tabela abaixo apresenta os dados (notas) de um aluno e a coluna (célula) da média do 
aluno que deverá ser calculada (ESCOLA ALCIDES MAYA, 2018).
Figura 17. Quadro de valores para exemplo.
Aluno Nota 1 Nota 2 Nota 3 Nota 4 Nota 5 Nota 6 Média 
1 4.0 5.0 5.0 3.0 7.5 4.0 ? 
Fonte: Escola Alcides Maya (2018).
Observe que, utilizando as estruturas anteriormente apresentadas, seria necessário 
ler cada uma das notas, de cada um dos alunos, para somá-las, conforme a sequência 
descrita a seguir. Isso acarretaria uma quantidade imensa de variáveis para armazenar 
os dados necessários.
Sendo assim, é necessário:
1. ler as notas do aluno para as variáveis nota1, nota2, nota3, nota4, nota5, nota6;
2. efetuar a soma das notas e a divisão delas por 6, atribuindo o seu resultado para a 
variável media;
3. apresentar o valor da variável média após a operação de soma e divisão dos valores 
fornecidos.
51
EStRUtURAS DE DADOS • CAPÍTULO 4
Utilizando-se matrizes unidimensionais (vetores), é possível criar uma única variável 
para armazenar todos os seis valores necessários.
Uma matriz de uma dimensão ou vetor será representada por seu nome e seu tamanho 
(dimensão) entre colchetes. Dessa forma, seria um vetor “nota[6]”, sendo seu nome 
nota, possuindo um tamanho de 6 (ESCOLA ALCIDES MAYA, 2018).
Isso significa que poderão ser armazenados na mesma variável “nota” (agora classificada 
como um vetor) até seis elementos.
No caso das matrizes, é possível armazenar mais de um valor por vez, pois são 
dimensionadas exatamente para esse fim. Dessa forma, será possível manipular uma 
quantidade maior de informação com pouco trabalho de processamento. Deve-se 
apenas considerar que, com relação à manipulação dos elementos de uma matriz, 
eles ocorrerão de forma individualizada, pois não é possível efetuar a manipulação 
de todos os elementos do conjunto ao mesmo tempo (ESCOLA ALCIDES MAYA, 2018).
A sintaxe para a declaração de matrizes unidimensionais ou vetores em pseudocódigo é 
apresentada abaixo:
Sintaxe: var nome_da_variavel[dimensão]: <tipo_da_variável/dado>
No caso do exemplo do cálculo da média do aluno, ter-se-ia então uma única variável 
indexada (a matriz) contendo todos os valores das notas. Isso seria representado da 
seguinte forma:
nota[0] = 4.0
nota[1] = 5.0
nota[2] = 5.0
nota[3] = 3.0
nota[4] = 7.5
nota[5] = 4.0
Atenção
Perceba que, na utilização de variáveis simples, existe uma regra: uma variável somente pode conter um valor por vez. 
52
CAPÍTULO 4 • EStRUtURAS DE DADOS
É necessário que fique bem claro que o elemento é o conteúdo da matriz, ou seja, os 
valores das notas. Tendo como exemplo a nota[0] = 4.0, o número 0 entre os colchetes é 
o índice, o endereço no qual o elemento (valor da nota) 4.0 está armazenado.
Nas estruturas anteriores (sequencial ou de repetição), são necessárias várias instruções 
para