Apostila de Algoritmos e Estruturas de Dados

Algoritmos e Estruturas de Dados I
ALGORITMOS E
ESTRUTURAS DE DADOS I
Tecnologias de Informação e Comunicação na Educação

Professor Antonio Maria Pereira de Resende
Tutora Profa Ana Rubélia Mendes de Lima Resende
Lavras/MG
2011
Prof. Antônio Maria e Profa. Ana Rubélia 1

Ficha catalográfica preparada pela Divisão de Processos

Técnicos da Biblioteca Central da UFLA
Espaço a ser preenchido pela biblioteca

ALGORITMO E ESTRUTURAS DE DADOS I

1 INTRODUÇÃO AO CURSO ..................................................................................................................... 7
1.1 Algoritmo ...................................................................................................................................... 7
1.2 Estrutura de Dados ..................................................................................................................... 10
1.3 Algoritmo e Estrutura de Dados ................................................................................................. 12
1.4 Orientações para um Melhor Aprendizado de AED ................................................................... 13
2 CONSTRUÇÃO DE ALGORITMOS......................................................................................................... 14
2.1 Notações para Construção de Algoritmos.................................................................................. 14
2.1.1 Notação em Descrição Narrativa........................................................................................ 14
2.1.2 Notação Gráfica .................................................................................................................. 14
2.1.3 Notação em Pseudocódigo ................................................................................................. 16
2.1.4 EXERCÍCIOS PROPOSTOS .................................................................................................... 17
2.2 Teste de Mesa ............................................................................................................................ 18
2.3 Fases de desenvolvimento de um Algoritmo ............................................................................. 19
3 ALGORITMOS EM PSEUDOCÓDIGO .................................................................................................... 21
3.1 Estrutura Básica de um Algoritmo.............................................................................................. 21
4 DECLARAÇÃO DE VARIÁVEIS E CONSTANTES ..................................................................................... 22
4.1 Variáveis ..................................................................................................................................... 22
4.1.1 Tipos de Dados ................................................................................................................... 24
4.1.2 EXERCÍCIO PROPOSTO ........................................................................................................ 25
4.2 Constantes .................................................................................................................................. 25
4.3 Regras para nomear Variáveis, Constantes e Algoritmos .......................................................... 26
5 COMANDOS SEQUENCIAIS ................................................................................................................. 28
5.1 Comando de Entrada .................................................................................................................. 28
5.2 Comando de Saída ...................................................................................................................... 28
5.3 Comando de Atribuição .............................................................................................................. 29

5.4 Boas Práticas para os Comandos Sequenciais............................................................................ 30
5.5 Operadores e Funções pré-definidas ......................................................................................... 31
5.5.1 Operadores Aritméticos ..................................................................................................... 31
5.5.2 Funções pré-definidas ........................................................................................................ 32
6 COMANDOS CONDICIONAIS ............................................................................................................... 37
6.1 Operadores Relacionais e Lógicos .............................................................................................. 37
6.1.1 Operadores Relacionais ...................................................................................................... 38
6.1.2 Operadores Lógicos ............................................................................................................ 40
6.1.3 EXERCÍCIO PROPOSTO ........................................................................................................ 42
6.2 Comando Condicional Simples SE ... ENTÃO .............................................................................. 42
6.3 Comando Condicional Composto SE ... ENTÃO ... SENÃO .......................................................... 43
6.4 Indentação.................................................................................................................................. 46
6.5 Aninhamento de Comandos SE...ENTÃO...SENÃO ..................................................................... 48
6.6 Comando Condicional ESCOLHA ... CASO ................................................................................... 52
7 COMANDOS DE REPETIÇÃO................................................................................................................ 59
8 Comando de Repetição: Número Definido de Repetições e Teste de Condição no Início ................ 61
8.1 Comando de REPETIÇÃO PARA ... FAÇA ..................................................................................... 61
9 Comando de Repetição: Número Indefinido de Repetições e Teste de Condição no Início .............. 71
9.1 Comando de REPETIÇÃO ENQUANTO ... FAÇA ........................................................................... 71
9.1.1 Peculiaridades Importantes do ENQUANTO..FAÇA ............................................................ 72
9.1.2 Loop Infinito ....................................................................................................................... 74
10 Comando de Repetição: Número Indefinido de Repetições e Teste de Condição no Final ........... 81
10.1 Comando de repetição REPITA ... ATÉ........................................................................................ 81
10.1.1 Peculiaridades Importantes do REPITA ... ATÉ ................................................................... 82
10.1.2 Loop Infinito ....................................................................................................................... 84

11 VARIÁVEIS COMPOSTAS HOMOGÊNEAS: VETORES E MATRIZES ................................................... 93
12 VETORES ......................................................................................................................................... 95
12.1 Representação Gráfica de um Vetor .......................................................................................... 96
12.2 Declaração de Vetor ................................................................................................................... 96
12.3 Manipulação de Dados de um Vetor .......................................................................................... 97
12.4 Operações de Entrada e Saída de dados em um Vetor .............................................................. 97
12.5 Processamento dos Dados de um Vetor .................................................................................... 99
12.5.1 EXERCÍCIOS PROPOSTOS .................................................................................................. 100
13 MATRIZES ..................................................................................................................................... 101
13.1 Representação Gráfica de uma Matriz ..................................................................................... 101
13.2 Declaração de Matriz................................................................................................................ 102
13.3 Manipulação de Dados de uma Matriz .................................................................................... 104
13.4 Operações de Entrada e Saída de dados em uma Matriz ........................................................ 104
13.5 Processamento dos Dados de uma Matriz ............................................................................... 107
14 VARIÁVEIS COMPOSTAS HETEROGÊNEAS: REGISTROS E VETOR DE REGISTROS ......................... 112
14.1 Declaração de Registro ............................................................................................................. 112
14.2 Representação Gráfica de um Registro .................................................................................... 113
14.3 Manipulação de Dados de Variável de Registro ....................................................................... 113
14.4 Operações de Entrada e Saída Utilizando Registros ................................................................ 114
14.5 VETOR DE REGISTROS ............................................................................................................... 115
14.6 Representação Gráfica de Vetor de Registro ........................................................................... 116
14.7 Manipulação de Dados do Vetor de Registro........................................................................... 117
14.8 Operações de Entrada e Saída Utilizando Vetor de Registros ................................................. 117
15 MODULARIZAÇÃO: PROCEDIMENTOS E FUNÇÕES ...................................................................... 121

15.1 PROCEDIMENTOS ..................................................................................................................... 122
15.1.1 Declaração de Procedimentos.......................................................................................... 123
15.1.2 Procedimentos sem Passagem de Parâmetros ................................................................ 125
15.1.3 Procedimentos com Passagem de Parâmetros ................................................................ 126
15.2 FUNÇÕES .................................................................................................................................. 127
15.2.1 Declaração de Funções ..................................................................................................... 128
15.2.2 Funções sem Passagem de Parâmetros ........................................................................... 129
15.2.3 Funções com Passagem de Parâmetros ........................................................................... 130
15.3 ESCOPO DE VARIÁVEIS – VARIÁVEIS LOCAIS E GLOBAIS .......................................................... 135
15.4 PASSAGEM DE PARÂMETROS POR VALOR E POR REFERÊNCIA ............................................... 136
15.4.1 Passagem de Parâmetros por Valor ................................................................................. 136
15.4.2 Passagem de Parâmetros por Referência ........................................................................ 138
16 RECURSIVIDADE............................................................................................................................ 141
16.1.1 EXERCÍCIOS PROPOSTOS ........................................................................................... 145
17 ÍNDICE DE FIGURAS ...................................................................................................................... 146
18 ÍNDICE DE TABELAS ...................................................................................................................... 152
19 RELAÇÃO DE ÍCONES .................................................................................................................... 153

1 INTRODUÇÃO AO CURSO
O conteúdo de Algoritmo e Estrutura de Dados – AED é ensinado em cursos técnicos e
universitários como Ciência da Computação, Sistemas de Informação, Engenharias (de Software,
Elétrica, Civil, Mecânica, Mecatrônica,...), Programação, Analista de Sistemas, Informática,
dentre outros. A profundidade e abrangência do conteúdo dependem do foco de cada curso.
Geralmente, o conteúdo de AED divide-se em disciplinas denominadas AED I, AED II e
AED III nos cursos relacionados à computação. O aprendizado é acumulativo, sendo impossível
aprender AED II ou AED III sem aprender AED I, ou aprender AED III sem aprender AED I e
AED II.
O ensino das disciplinas de AED desenvolve o raciocínio lógico dos alunos, capacitando-os
para programação de computadores.
A seguir, o termo Algoritmo e o termo Estrutura de Dados são explicados separadamente,
facilitando a compreensão de seus significados.
1.1 Algoritmo
A primeira palavra relacionada a Algoritmo, algorism, foi criada no século 9 pelo
matemático persa islão Abu Abdullah Muhammad ibn Musa Al-Khwarizmi. Inicialmente, o termo
foi criado para nomear regras que ensinavam como realizar cálculos usando números hindu-
arábicos. No século 18, o termo foi traduzido para o Latin Europeu como Algorithm, e seu
significado passou a abranger todo procedimento definido (claro, preciso) para resolver
problemas e executar tarefas.
Um exemplo clássico de algoritmo pertence ao matemático Euclides, pai da geometria

Euclidiana, que desenvolveu um algoritmo para calcular o Máximo Divisor Comum – MDC,
replicado a seguir:
1. Divida o número a por b, o resto é r;

2. Troque a pelo valor de b;
3. Troque b pelo valor de r;
4. Continue os passos acima até não mais conseguir dividir.
Neste caso, a é o MDC.
Figura 1 - Algoritmo de Euclides para calcular o MDC

Executando o algoritmo de Euclides...

Tabela 1 - Execução do algoritmo de Euclides para calcular o MDC dos números 48 e 30
a b Resto r Passos do Algoritmo

48 30 18 Passo 1- Divide-se 48 por 30 e o resto coloca-se na coluna do resto;
Passo 2 - Valor de b colocado em a;
30 18 12 Passo 3 - Valor de r colocado em b;.
Passo 1- Divide-se novamente a por b colocando o resto em r;
Passo 3 - Valor de r colocado em b;.
6 0 -X-
Passo 1- Divide-se novamente a por b colocando o resto em r.
Como não é mais possível dividir, então a (=6) é o MDC de 48 e 30.
Existem outros algoritmos conhecidos na matemática como:

a) de Arquimedes para calcular uma aproximação do número Pi; e
b) de Erastótenes para encontrar números primos (Crivo de Erastótenes).
Veja a seguir algoritmo de Erastótenes para encontrar números primos de 2 até N e sua
execução.
1. Definir o valor limite N;

2. Encontrar a raiz quadrada de N, guardar a parte inteira denominando-a de raiz;
3. Criar uma lista (vetor) com os números de 2 até N;
4. Para i de 2 até a raiz faça
4.1. Se i não estiver riscado na lista, riscar todos os seus múltiplos de i² até N;
5. Pronto, após finalizar o passo 4, os números não riscados formam a lista de números
primos de 2 a N.
Figura 2 - Algoritmo Erastótenes para encontrar números primos de 2 até N.

Executando o algoritmo de Erastótenes...

Tabela 2 - Execução do algoritmo de Erastótenes para encontrar os números primos de 2 a 30
Passo 1) N = 30;
Passo 2) Raiz (30) = 5,477. Para guardar parte inteira então raiz = 5;
Passo 3) Lista de números de 2 até 30

02 03 04 05 06 07 08 09 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Passo 4) Para i de 2 até a raiz faça
Passo 4.1) para i=2, riscar todos os seus múltiplos de i²(=4) até N se não estiver riscado
02 03 04 05 06 07 08 09 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Passo 4.1) i=3, riscar todos os seus múltiplos de i² (=9)até N se não estiver riscado
02 03 04 05 06 07 08 09 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Passo 4.1) i=4, riscar todos os seus múltiplos de i²(=16) até N se não estiver riscado
02 03 04 05 06 07 08 09 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Passo 4.1) i=5, riscar todos os seus múltiplos de i² (=25) até N se não estiver riscado
02 03 04 05 06 07 08 09 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Passo 5) Pronto, os números não riscados formam a lista de números primos de 2 a N.

02 03 05 07 11 13
17 19 23 29
Os números primos de 2 a 30 são: 02, 03, 05, 07, 11, 13, 17, 19, 23 e 29.
Portanto, pode-se afirmar que algoritmo é um conjunto de passos (instruções) bem

definidos e executados em uma sequencia lógica para se produzir um resultado esperado. Assim,
se alguém deseja calcular o MDC de dois números, basta aplicar o algoritmo de Euclides. Se

alguém deseja encontrar os números primos em um intervalo de 2 até N, deve aplicar o algoritmo
de Erastótenes.
Outro exemplo prático de algoritmo é uma receita de bolo.

Uma receita de bolo define os passos a seguir para se fazer um bolo. Há receitas com
passos bem definidos e quando seguidos obtêm-se o bolo. Estas receitas podem ser chamadas de
algoritmo. Entretanto, há também receitas escritas de maneira inadequada, ou faltando
quantidade de um ingrediente, ou faltando o tempo que determinada massa fica no fogo. Tais
receitas não podem ser chamadas de algoritmo, por não possuírem passos (instruções) bem
definidos para se atingir o fim esperado.
Em computação dizemos que instrução é uma informação que indica uma ação a ser
executada, por exemplo, por um computador. Deve-se considerar que uma instrução executada
em separado, pode não ter sentido. Para obtermos o resultado desejado precisamos executar um
conjunto de instruções na ordem correta.
Exemplificando...
Para fazer um bolo é preciso executar uma sequencia de instruções, como: separar os
utensílios e ingredientes a serem utilizados, pré-aquecer o forno e medir os ingredientes, untar a
forma, bater os ovos etc.
Entretanto estas instruções devem ser executadas em uma ordem adequada – não se deve
colocar o fermento após o bolo assado.
1.2 Estrutura de Dados

A melhor maneira de explicar uma estrutura de dados é compreender um formulário em
papel contendo seus campos, tamanho de cada campo e o tipo de dado a ser armazenado.
Exemplificando...
Na Figura 3, observa-se um formulário que deve ser preenchido para renovação ou
assinatura nova de uma revista. Nele, observa-se a necessidade de preencher campos como:
- Informar se é assinatura nova ou renovação;
- Informar o código do assinante, se assinante;
- Informar qual revista e o prazo da assinatura;

- Informar o valor a ser pago; dentre outros.
O usuário sabe que não pode colocar o valor em uma data, nem uma data em um campo de
nome, por exemplo. E que as informações devem ser preenchidas de acordo com o tamanho do
campo. Isto é uma estrutura de dados, onde se tem um conjunto de dados com tamanho e tipo de
dado para cada campo bem definidos.
Figura 3 – Formulário de Assinatura de Revista
Um exemplo de uma estrutura de dados para Cliente é:
Cliente {
nome [30]: literal; //
salario: real;
idade: inteiro;
}
Figura 4 – Estrutura de dados Cliente

Entretanto, dependendo da empresa, a estrutura de dados para Cliente poderia ser:
Cliente {
nome [50]: literal;
telefone: literal;
sexo: caractere;
credito: real;
}
Figura 5 – Variação de uma Estrutura de dados Cliente
De acordo com o problema e necessidade da empresa, as estruturas de dados são planejadas

e definidas.
Considerando que o computador é utilizado para informatizar as empresas e seus

processos, então existe a necessidade de capturar as informações existentes e automatizá-las.
Para isto, utilizam-se os conceitos de Estrutura de Dados para representar, armazenar, processar
e recuperar estas informações nos computadores.
Em AED, ensinam-se várias Estruturas de Dados e o aluno deverá aprender aplicá-las

corretamente dependendo da finalidade desejada.
1.3 Algoritmo e Estrutura de Dados

Sabendo que:
- Algoritmo é um conjunto de passos bem definidos para se atingir um resultado; e
- Estrutura de dados define um conjunto de dados, seu tamanho e tipo de dado para cada
campo;
Pode-se afirmar então que Algoritmo e Estrutura de Dados é o conjunto de conhecimento

que permite representar a informação no computador associado a um conjunto de passos bem
definidos que propiciam realizar operações com estas informações.
No mercado de trabalho, diariamente, profissionais da área de computação e sistemas de

informação deparam-se com problemas. Para cada um dos problemas, ele deve definir:
- a(s) melhor(es) estrutura de dados aplicável na solução do problema (Estrutura de Dados);
- construir um conjunto de passos para realizar operações com os dados (Algoritmo).
Após construir o(s) algoritmo(s) e definir a(s) estrutura(s) de dados, o profissional está apto
para programar o sistema que será entregue ao cliente.
Portanto, não é possível programar sem saber algoritmos e estrutura de dados. O

profissional deve ter o raciocínio lógico que o capacita a pensar como o computador. Após muita
prática, os profissionais conseguem programar o computador sem ter de formalmente definir o

algoritmo, pois seu raciocínio já está treinado para observar o problema, desenvolver o algoritmo
mentalmente e programá-lo no computador.
Ressalta-se que se o profissional não souber resolver o problema manualmente, ele não
conseguirá desenvolver o algoritmo, pois não será capaz de definir os passos que descrevem a
solução. Quando o profissional se encontrar nesta situação, caso comum, ele deve estudar e
aprender a desenvolver a solução manualmente para depois descreva o algoritmo. Quando estiver
desenvolvendo um sistema para uma empresa, ele deve procurar as pessoas que realizam aquela
atividade manualmente, a fim de aprender e passar o conhecimento daquelas pessoas para a
forma de algoritmo e programá-lo.
Algoritmo e Estrutura de Dados caracterizam-se por não possuir solução única. Se 30

pessoas forem convidadas para desenvolver algoritmos para determinado, espera-se 30 soluções
distintas.
1.4 Orientações para um Melhor Aprendizado de AED

1. Treine - Quanto mais exercícios o aluno resolver, maior será sua capacidade na resolução de
novos problemas. Deve-se exercitar algoritmos diariamente, resolvendo, pelo menos, 2 ou 3
problemas, pois somente a prática propiciará o aprendizado;
2. Teste - Sempre realize o teste de mesa para verificar se o algoritmo está correto;
3. Relembre - Não vá para a aula sem leia/revisar o conteúdo de aulas anteriores. O
conhecimento é acumulativo, é imprescindível saber os conceitos anteriores para aprender a
aplicar os novos;
4. Seja responsável - Faça você mesmo os exercícios e busque exercícios complementares em
livros na biblioteca. Lembre-se que cada um possui a sua própria lógica, produzindo
algoritmos distintos. Só aprende quem faz por si mesmo, não há outra forma de aprendizado.
Evite resolver uma grande lista de exercícios em apenas um dia; e
5. Aprenda - Enquanto você não souber resolver um problema manualmente, você será incapaz
de descrever o algoritmo. Se pedir para um aluno, que cozinha, construir um algoritmo para
fritar um bife, ele o fará. Porém, se pedir a ele para calcular a derivada dupla de uma equação
ordinária de 3ª ordem e ele não souber resolver, então o aluno deverá estudar para aprender
como se faz o cálculo para depois desenvolver um algoritmo.

2 CONSTRUÇÃO DE ALGORITMOS
Para começar a construir algoritmos, deve-se primeiro aprender as notações mais utilizadas
para descrevê-los e conhecer as fases para seu desenvolvimento.
2.1 Notações para Construção de Algoritmos

Os três tipos de notações utilizadas para construir algoritmos são: descrição narrativa,
gráfica e pseudocódigo. O profissional deve escolher uma das três formas, sendo o pseudocódigo
o mais utilizado na computação.
2.1.1 NOTAÇÃO EM DESCRIÇÃO NARRATIVA
Consiste em descrever os passos de uma solução utilizando linguagem natural.
Exemplificando...
Algoritmo para fritar um ovo:
Passo 1 – Pegar a frigideira e colocar óleo;
Passo 2 – Levar a frigideira ao fogo;
Passo 3 – Pegar o ovo, quebrá-lo e colocar seu conteúdo na frigideira;
Passo 4 – Esperar a clara ficar branca e virar o ovo; e
Passo 5 – Se preferir, você pode estourar a gema para deixá-la firme.
Figura 6 - Exemplo de algoritmo usando Descrição Narrativa
2.1.2 NOTAÇÃO GRÁFICA
Consiste em descrever os passos de uma solução utilizando a forma gráfica. Existem

diferentes formas de representar um algoritmo graficamente, sendo o fluxograma, também
conhecido como diagrama de blocos, a mais difundida.
O conjunto de símbolos descritos a seguir é utilizado para representar uma seqüência lógica
(algoritmo) denominada Fluxograma.
Tabela 3 – Simbologia utilizada em Fluxogramas
Indica o início e o fim de um algoritmo.
Indica a direção do processamento. Utiliza-se para conectar os símbolos.

Representa um processo a ser executado, cálculos e atribuição de
valores.

Indica entrada de dados. No interior devem constar informações de

variáveis a serem lidas.
Símbolo utilizado para representar saída de dados.
Indica decisão segundo uma condição e possibilidade de desvio. Deve

haver uma entrada, uma pergunta e duas saídas, conhecidas por
VERDADEIRO ou FALSO.
Indica uma conexão entre pontos distantes de um algoritmo.
Indica uma rotina a ser chamada. No final da rotina (subprograma) a

execução continua do ponto onde foi realizada a chamada.
Exemplificando...
Figura 7 - Fluxograma Fritar um ovo

Figura 8 - Fluxograma Média
2.1.3 NOTAÇÃO EM PSEUDOCÓDIGO
Consiste em descrever os passos de uma solução utilizando um conjunto de instruções pré-

definidas.
O pseudocódigo utilizado no Brasil denomina-se portugol e possui um conjunto de

instruções utilizáveis para a descrição da solução do problema. A seguir, utiliza-se o portugol
para leia duas notas de um aluno, calcular a média e responder se ele está aprovado ou
reprovado, considerando média mínima de 60% para aprovação.

Exemplificando...
Algoritmo media;
Declare N1,N2 : inteiro;
media : real;
Inicio
Leia (N1);
Leia (N2);
media  (N1+N2) / 2;
SE (media >= 60) ENTÃO
Escreva (“Aluno aprovado com média: ”, media);
SENÃO
Escreva (“Aluno reprovado com média: ”, media);
FIMSE;
Fim.
Figura 9 - Algoritmo Média em Pseudocódigo
2.1.4 EXERCÍCIOS PROPOSTOS

1) Elabore um algoritmo, usando descrição narrativa:
i. para alguém sair da faculdade e chegar até sua casa.
ii. para trocar uma lâmpada.

2.2 Teste de Mesa

Após desenvolver um algoritmo ele deverá sempre ser testado. Este teste é chamado de
Teste de Mesa e implica em seguir as instruções do algoritmo de forma precisa para verificar se
o procedimento utilizado está correto ou não.
Exemplificando...
# Algoritmo x y z Saída
1. algoritmo soma;
2. Declare x, y, z : inteiro;
3. Inicio
4. Leia(x); 8
5. Leia(y); 7
6. z  x + y; 15
7. Escreva(z); 15
8. Fim.
Figura 10 – Execução de Teste de Mesa do Algoritmo Soma
Cria-se uma tabela sendo que: na primeira coluna insere-se o programa, na segunda coluna
até a penúltima inserem-se os dados de entrada (x e y) e processamento (z), e na última coluna os
dados de saída. Após montar a tabela, basta leia cada uma das linhas do programa e fazer o que
se pede.
A primeira linha apenas determina o nome do programa (soma). A segunda linha determina
os dados de entrada e processamento. A terceira linha informa onde o corpo principal do
algoritmo começa. Na quarta linha, o comando leia(x) implica em se determinar o valor de x que,
neste caso, foi atribuído o valor 8. Na quinta linha, o comando leia(y) implica em se determinar o
valor de y que, neste caso, foi atribuído o valor 7. Na sexta linha, o comando z x + y implica
em somar os dois números e guardar o resultado em z. O valor guardado foi 15. Na sétima linha,
o comando ESCREVA determina que o valor z deve ser escrito na tela do computador. E a
última linha encerra o algoritmo.

2.3 Fases de desenvolvimento de um Algoritmo

Um algoritmo é uma seqüência lógica de instruções que podem ser executadas, portanto,
qualquer tarefa que siga determinado padrão pode ser descrita por um algoritmo.
Por exemplo: - Como fazer Arroz Doce ou então - Calcular o Saldo de um

Estoque.
Para evitar erros no desenvolvimento de um algoritmo, deve-se conhecer algumas fases

fundamentais para sua construção.
1ª Fase) Compreensão do problema: Compreenda o problema a ser resolvido, destacando

os pontos principais;
2ª Fase) Definição das Entradas: Identificar os dados que devem ser solicitados e lidos
pelo computador para a resolução do problema;
3ª Fase) Definição do Processamento: Definir quais operações devem ser realizadas nos
dados de entrada, gerando os dados de saída;
4ª Fase) Definição das Saídas: Identificar quais dados o usuário espera receber do
computador após ter fornecido os dados de entrada;
5ª Fase) Construção do algoritmo: Escolher a notação descritiva, gráfica ou pseudocódigo

e construir o algoritmo; e
6ª Fase) Teste do algoritmo: Executar o algoritmo passo a passo, aplicando, por exemplo, o
teste de mesa.

Exemplificando...
Problema: Calcule e mostre a média aritmética simples das notas de um aluno, sabendo que foram
realizadas 4 provas P1, P2, P3 e P4.
1ª Fase – Compreensão do Problema: Devo obter as 4 notas do aluno, somá-las e dividir a soma por 4.
O resultado é a média. Logo, eu conheço a solução do problema e se é possível resolve-lo manualmente,
então deve-se buscar um algoritmo para ele.
2ª Fase – Definição das Entradas: Os dados de entrada são P1, P2, P3 e P4.
3ª Fase – Definição do Processamento: O procedimento será somar os 4 dados de entrada (P1, P2, P3,
P4) e dividir seu resultado por 4.
4ª Fase – Definição das Saídas: O dado de saída será a média final.
5ª Fase – Construção do Algoritmo: Será utilizada a notação em Pseudocódigo e o algoritmo é:
Algoritmo em Pseudocódigo
Algoritmo media;
Declare P1, P2, P3, P4, media: real;
Inicio
Leia(P1);
Leia(P2);
Leia(P3);
Leia(P4);
Media  (P1+ P2+P3+ P4) / 4;
Escreva(“Média: ”, media);
Fim.
6ª Fase – Teste do Algoritmo:

Realizando o teste de mesa do algoritmo construído:
# Algoritmo P1 P2 P3 P4 Media Saída
1 Algoritmo media;
2 Declare P1, P2, P3, P4, media: real;
3 Inicio
4 Leia(P1); 8
5 Leia(P2); 7
6 Leia(P3); 5
7 Leia(P4); 10
8 Media  (P1+ P2+P3+ P4) / 4; 7,5
9 Escreva(“Média: ”, media); Média: 7,5
10 Fim.

3 ALGORITMOS EM PSEUDOCÓDIGO
3.1 Estrutura Básica de um Algoritmo
Um algoritmo possui a estrutura básica representada a seguir. As representações indicadas
pela notação < > implicam que devem ser substituídas e o programador deve determinar o valor.
As representações indicadas pela notação [ ] implicam em estrutura facultativa, podendo-se fazer
um algoritmo sem utilizá-la.
Utiliza-se duas barras “//” para comentar uma linha. Para comentar um bloco que possua
mais de uma linha, utiliza-se barra e asterisco “/*” para abrir o comentário de bloco e asterisco e
barra “*/” para fechar o comentário de bloco.
/*Este algoritmo calcula a área de um círculo

Algoritmo <nome do algoritmo>; qualquer e imprime o resultado */
[Const <declare uma constante>;] Algoritmo AreaCirculo; // π*r2
[Declare <declare uma variável>;] Declare area, R: real;
Início Início
<comandos>; R  2; // raio recebe o valor 2
Fim. area  3,1415 * (R * R);
Escreva (area); // mostra na tela a área
Fim.
Figura 11 - Estrutura básica de um algoritmo Figura 12 - Exemplo de um algoritmo
O detalhamento para se construir o algoritmo e quais comandos podem ser usados consiste
no objetivo do restante deste livro.

4 DECLARAÇÃO DE VARIÁVEIS E CONSTANTES

Declaração de variáveis e constantes é utilizada para informar ao computador quais dados
serão utilizados e necessários para resolver-se um problema.
Para um computador calcular o salário de um funcionário, ele precisa de dados como

salário base do funcionário, número de horas extras, total de adiantamentos, dentre outros
créditos e descontos que compõem uma folha de pagamento. Cada um desses valores representa
um dado a ser armazenado e processado no computador, o qual os transforma em salário bruto e
líquido.
Algoritmos podem possuir dados declarados como variáveis ou constantes, explicados a

seguir.
4.1 Variáveis
Declara-se uma variável para determinar seu nome (salário, data, idade, nome, ...) e o tipo
de dado (número inteiro, número real, um caractere, texto, ...) a ser fornecido pelo usuário ou
calculado pelo algoritmo.
Se o algoritmo precisa armazenar a idade de uma pessoa, então é preciso declarar no

algoritmo uma variável chamada idade do tipo inteiro. Se é preciso armazenar o salário de um
funcionário, então deve-se declarar no algoritmo a variável salário do tipo real. A declaração das
variáveis idade e salário é exemplificada a seguir.
Algoritmo teste;
Declare idade : inteiro;
salario : real;
INICIO
<comandos>;
FIM.
Figura 13 - Exemplo de declarações de variáveis

Uma variável está associada a uma posição de memória, e seu conteúdo pode ser alterado
durante a execução de um programa. Embora uma variável possa assumir diferentes valores, ela
só pode armazenar um valor por vez.
Valor da variável
Algoritmo teste2;
Declare salario, comissao: real;
Nome da variável
Início
salario  1200,00;
Escreva (“Entre com valor da comissão: “); Alterando o valor
Leia (comissao); da variável
salario  salario + comissao;
Escreva (“O salário atual é:”, salario);
Fim;
Figura 14 - Exemplo Alteração de valor de variável
Representação de criação de variáveis na memória do computador e armazenamento

das informações.
1 2 3 4 5 6 7
1 700,00
2
3 1200,00
4 comissao
salario
Após a execução da instrução: salario  salario + comissao;
1 2 3 4 5 6 7
1 700,00
2 comissao
3 1900,00
4
salario
Figura 15 – Representação de criação de variáveis na memória do computador

4.1.1 TIPOS DE DADOS
O computador processa dados de vários tipos, podendo realizar as mais diferentes

operações com dados, inteiros, reais, irracionais, racionais, etc. O programador deve saber quais
os dados e tipos de dados ele precisa para resolver um problema. Para conseguir estas
informações, pode-se consultar o cliente que solicitou o programa e leia os formulários utilizados
na empresa. Por meio destes formulários é possível determinar os campos importantes e seus
tipos de dados.
Em um formulário, não se deve escreva uma data em um campo que se pede um valor
monetário. Não se deve escreva um número no campo que pede o nome da pessoa. Não se deve
escreva um valor monetário onde pede-se uma idade. Isto gera erro no preenchimento de
formulários porque o tipo de dado esperado possui um formato e o usuário escreve outro.
No computador não é diferente. Deve-se definir o tipo de dado para cada um dos campos.
O computador acusará erro, por exemplo, se você tentar escreva 12/03/2017 em uma idade.
Idade não aceita barras e é composto por apenas um número inteiro, ao contrário da data que
possui 2 números inteiros. O contrário também gera erro, pois um número inteiro não satisfaz a
necessidade de 3 números inteiros.
Algoritmos e programas de computadores exigem que o programador estabeleça (defina)

cada um dos dados e o Tipo de Dado que ele utiliza para resolver um problema. Os Tipos de
Dados utilizados para construção de algoritmos são inteiro, real, literal, caractere e lógico. Cada
um deles explicado a seguir.
Tabela 4 – Tipo de Dados
Tipo Descrição Exemplo

Inteiro Armazena um número inteiro 1; 345; -237; 91; 125874;
Real Armazena um número real 2,0; 21,987; - 237,2; 0,9854;
Armazena um único (1) caractere podendo ser letras
maiúsculas, minúsculas, números (não utilizados
Caractere para cálculos) e caracteres especiais como (&, #, $, „1‟; „L‟; „a‟; „!‟; „%‟; „~‟
@, [, {, dentre outros). O caractere sempre é
representado entre aspas simples.
Armazena um conjunto de caracteres como um nome
“PEDRO”; “Rua das Flores”;
de pessoa, data, cor, descrição de um produto, etc.
Literal “São Paulo”; “Amarelo”; “Pacote
Uma literal sempre é representado entre aspas
de Macarrão 500gr”; “21/12/2011”
simples ou dupla.
V; F; Verdadeiro; Falso
Lógico Armazena o valor verdadeiro ou falso
Podem-se fazer operações com os tipos de dados. Os números podem ser somados,
subtraídos dentre outras operações aritméticas. Literais podem ter parte de seus caracteres
retirados, outros inseridos etc.

4.1.2 EXERCÍCIO PROPOSTO

1) Relacione o Tipo de Dado e o valor armazenável nele. Utiliza-se a vírgula para separar as
casas decimais e o ponto a casa de milhares:
1-Inteiro ( ) „K‟ ( ) falso
2-Real ( )V ( ) -95
3-Caractere ( ) „V‟ ( ) „-95‟
4-Literal ( ) 2,1345 ( ) „6‟
( ) „mecanismo de destruição‟ ( ) „234‟
5-Lógico ( ) 325.472 ( ) „a‟
( ) „21/02/2548‟ ( ) „aaaa‟
( ) „02/02/22‟ ( ) „$‟
( ) „*‟ ( ) „UFLA‟
( ) -352,254 ( ) „325.654.387,35987412569874521‟
( ) „Roxo‟
( ) 325.654.387,35987412569874521
4.2 Constantes
Denomina-se como constante dados que não se modificam no decorrer do algoritmo, por
isto o nome de constante.
Exemplos clássicos de constantes são número Pi, número de Euler (e), aceleração da
gravidade, dentre outros. Qualquer dado que possua um valor que não varie deve ser declarado
como uma constante. A declaração das constantes Pi e „e‟ (número de Euler) é exemplificado no
algoritmo a seguir.
valor da constante
Algoritmo teste;
Const pi = 3,1415;
e = 2,71828;
Declare idade : inteiro;
nome da constante
salario : real;
Início
<comandos>;
Fim.
Figura 16 - Exemplo de declarações de constantes

A representação de constantes e variáveis na memória do computador é idêntica e segue a

forma mostrada na Figura 15.
4.3 Regras para nomear Variáveis, Constantes e Algoritmos

As regras para nomear variáveis, constantes e algoritmos são apresentadas a seguir:
 O nome deve estar relacionado ao conteúdo armazenado (idade, nome, sexo);
 Devem começar com uma letra ou sublinhado “_“;
 O restante pode ser letra ou número ou sublinhado;
 Não usar espaços em brancos;
 Não usar caracteres especiais do tipo @, +, -, %, !, #, $, &, *, (, ^ , }, dentre outros;
 Não usar palavras reservadas da linguagem de programação; e

O uso de letras maiúsculas ou minúsculas é indiferente no algoritmo. Entretanto,
dependendo da linguagem de programação utilizada, maiúsculo ou minúsculo determinam
variáveis e constantes distintas.
Tabela 5 - Exemplo de nomes válidos e inválidos
Nomes Válidos Nomes Inválidos

TOTAL 3ARQUIVO - começa com dígito
UMNOMEMUITOCOMPRIDOEDIFICILDELER X+Y - não permitido
lado2 For - palavra reservada para comando
UM_NOME_MUITO_COMPRIDO_MAS_FACIL_DE_LEIA Until - palavra reservada para comando
L123 Media(76) - não é permitido parênteses
duas_palavras Data de nascimento - não é permitido espaço


1) Diferencie constantes de variáveis. Exemplifique a declaração de uma constante e de
uma variável:
2) Deseja-se armazenar nota, nome, número da matrícula, sexo, data de nascimento, valor da
mensalidade de um aluno e se ele é bolsista. Declare as variáveis em portugol.
3) Assinale com C os nomes CORRETOS para algoritmos, variáveis e constantes e com I os
INCORRETOS. Explique o que está errado nos incorretos.
( ) 34 - 23 ( ) km/h ( ) 3notas
( ) nome aluno ( ) “nota” ( ) nota_bimestral
( ) _d20 ( ) cia3a3 ( ) e-mail
( ) Minimo ( ) xyz ( ) estado_civil( )
( ) aula_03 ( ) Data_Nascimento ( ) comissao%
( ) SALARIO ( ) achou! ( ) nota_bimestral
( ) nota*final ( )A+B ( ) 360hs

5 COMANDOS SEQUENCIAIS
Os comandos sequenciais são as estruturas mais simples utilizadas na construção de
algoritmos e subdividem-se em comandos de entrada, saída e atribuição.
Ela é formada por um conjunto de instruções (ou comandos) que executadas em uma
seqüência linear de cima para baixo e da esquerda para a direita, ou seja, da mesma forma como
foram escritas.
5.1 Comando de Entrada

Em diversas soluções de problemas necessita-se de dados informados pelo usuário para
serem processados pelo algoritmo, sendo o teclado a entrada padrão do computador.
O Comando de Entrada permite obter estes dados externos ao algoritmo e armazená-los em

variáveis.
Em pseudocódigo o comando de entrada é representado pela palavra Ler ou Leia.
Exemplificando...
...
leia (raio); // O valor digitado pelo usuário será armazenado na variável raio.
...
leia (nome); // Os caracteres digitados pelo usuário serão armazenados na variável nome.
...
5.2 Comando de Saída

O Comando de Saída é utilizado para apresentar dados e mensagens ao usuário.
Em pseudocódigo o comando de saída é representado pela palavra Escrever ou Escreva.
Exemplificando...
Escreva (“Digite um valor:”); // Mostra uma mensagem ao usuário.
Escreva (x); // Mostra o valor armazenado na variável x.
Escreva (“O aluno “, nome, “está aprovado”); /*Mostra a mensagem “O aluno “, logo depois o valor
armazenado na variável nome e em seguida o restante da mensagem “está aprovado” */

5.3 Comando de Atribuição

O Comando de Atribuição é utilizado para atribuir valor ou operações a uma variável,
sendo representado pelo símbolo “”.
Exemplificando...
x  “José”;
y  2.5;
y  y + 1;
teste  falso;
media  (N1 + N2 + N3 + N4) / 4;
raio  2;
area  PI * (raio * raio);
perimetro  3* PI * raio;
Utilizamos as palavras INÍCIO e FIM para delimitar o bloco de sequência, conforme

sintaxe a seguir.
Exemplificando...
Algoritmo Comandos_Sequenciais;
Declare
X, Y : inteiro;
A, B : real;
nome : literal;
INÍCIO
Escreva (“Entre com o valor de X: ”) ;
Leia (X);
Escreva (“Entre com o valor de A: ”);
Leia (A);
Escreva (“Entre com o seu nome: ”);
Leia (nome);
Y  X * 3;
B  (A * 2,4) / 3;
Escreva (nome “, os valores de X e A agora valem: “,Y, B);
FIM.
Figura 17 – Exemplo de Comandos Sequenciais
Observe que todos os comandos entre INÍCIO e FIM estão com a margem mais a direita,
para facilitar a visualização. Isto se chama indentação e será explicada em mais detalhes em
outra seção. O mesmo pode ser observado com 3 linhas de declaração de variáveis, cuja margem
foi empurrada para a direita, sendo um subnível de Declare.

5.4 Boas Práticas para os Comandos Sequenciais

1) SEMPRE Escreva uma mensagem ao usuário antes de qualquer comando de entrada, informando o
dado a ser fornecido e a unidade de medida. Caso contrário, o usuário verá o cursor piscando na tela e
não saberá o que fazer.
ERRADO CERTO
// Cursor fica piscando e usuário não sabe o que // Envia mensagem e lê o nome
fazer Escreva(“Nome: ”);
// pois não foi enviada mensagem a ele Leia(nome);
Leia(nome);
// Usuário não sabe se temperatura é C, F ou K. // Envia mensagem e lê o salário
Escreva(“Digite a temperatura: ”); Escreva(“Digite a temperatura em Celsius: ”);
Leia(temp); Leia(temp);
2) Ao imprimir o resultado de um processamento na tela do computador, SEMPRE mande uma mensagem

informando a unidade de medida e o que o dado representa. Caso contrário, o usuário verá um dado na
tela e não saberá do que se trata.
ERRADO CERTO
// Usuário sabe que o dado é sobre altura, mas // Informar a unidade de medida e o que o dado
não // representa
// sabe se é em metros, centímetros etc. Escreva(“Altura: “, altura, “ (metros)”);
Escreva(“Altura: ”, altura);
// Usuário vê um número na tela e não sabe do // Informar a temperatura explicitando ser em
que se trata. Celsius.
Escreva(temperatura); Escreva(“A temperatura atual é: ”, temp, “C”);
3) O computador trabalha com dados numéricos sem conhecer a unidade de medida ou o dado
representado. Assim, quando você digita 30 no teclado, o computador não sabe se 30 é a idade (anos),
a temperatura (C,F, K), a dimensão (mm, cm, m, km,...), pressão etc. Se você pedir para ele subtrair a
idade da pressão, ele o fará, pois para ele tudo é número. Cabe ao programador gerenciar e fazer
corretamente as contas, ficando atento as unidades de medida.

5.5 Operadores e Funções pré-definidas

Os operadores são meios pelo qual incrementamos, decrementamos, comparamos e
avaliamos dados dentro do computador. Temos três tipos de operadores: Aritméticos,
Relacionais e Lógicos.
Os Operadores Relacionais e Lógicos serão apresentados na seção 6.1.1 e 6.1.2
respectivamente.
Vejamos agora os operadores Aritméticos.
5.5.1 OPERADORES ARITMÉTICOS

Os Operadores Aritméticos são utilizados para obter resultados numéricos. Além da adição,
subtração, multiplicação e divisão, podem utilizar também o operador de multiplicação para
exponenciação.
Os símbolos para os Operadores Aritméticos são:

Tabela 6 – Operadores Aritméticos
+ Adição
- Subtração
* Multiplicação
/ Divisão
* * ou ^ Exponenciação
5.5.1.1 Hierarquia das Operações Aritméticas
Na resolução das operações aritméticas os operadores possuem uma hierarquia de

prioridade ou regra de precedência.
Tabela 7 – Hierarquia das Operações Aritméticas
1º ( ) parênteses
2º Exponenciação
3º Multiplicação ou divisão (o que vier primeiro)
4º Adição ou subtração (o que vier primeiro)

Exemplificando...
area_triangulo  (Base * Altura) / 2;

X=11
X  5*(7-9)+3*7;
Z  1 + 7 * 2 ** 3 –1;
Z=56
media  (P1+ P2) / 2;
5.5.2 FUNÇÕES PRÉ-DEFINIDAS

Uma função tem por objetivo retornar um valor ou informação. As funções pré-definidas ou
bibliotecas de funções armazenam um conjunto de funções que podem ser usadas pelos
programas.
A Tabela 8 apresenta alguns tipos de funções pré-definidas para a utilização na construção
de algoritmos.
Entretanto, cada linguagem possui suas próprias funções pré-definidas e como veremos
adiante no tópico 15.2 o programador pode criar funções conforme necessidade.
Tabela 8 – Funções pré-definidas
ABS(x) Retorna o valor absoluto de x

TRUNC(x) ou INT(x) Retorna a parte inteira de x
FRAC(x) Retorna a parte fracionária de x
SQRT(x) Retorna a raiz quadrada de x
ROUND(x) Retorna o valor arredondado de x
SQR(x) Eleva o valor de x ao quadrado
x MOD y Retorna o resto da divisão entre x e y
x DIV y Retorna o valor inteiro do resultado da divisão de x por y
CONCAT(x) Concatena (junta) uma sequencia de caracteres
SIN(x) Retorna o Seno de x
COS(x) Retorna o Coseno de x
TAN(x) Retorna a Tangente de x

Exemplificando...
A  ABS (-4); // A  4
A  TRUNC (2,78); // A  2
A  INT (4,15); // A  4
A  INT (-4,15); // A  - 4
A  FRAC (3.65); ;// A  0.65
A  FRAC (-3.65); // A  - 0.65
A  SQRT(9); // A  3;
A  ROUND (2.78); // A  3
A  ROUND (-1,4); // A  -1
A  SQR(2); // A  4;
A  7 MOD 2 ; // A  1;
A  6 MOD 2 ; // A  0;
A  7 DIV 2; // A 3,5;
A  18 DIV 3; // A 6;
A  CONCAT(“abc”, “def”) ; // A  abcdef;
A  CONCAT(“ana”, “rubelia”) ; // A  anarubelia;

Exercícios Resolvidos:
1) Elabore um algoritmo para calcular o perímetro de um círculo dado o seu raio, considerando
que Perímetro = 2 * π * Raio.
Algoritmo perimetro_circulo;
Const pi = 3,1415;
Declare peri, raio : real;
INÍCIO
Escreva (“Programa para calcular o perímetro de um círculo dado seu raio”);
Escreva (“Entre com o valor do raio: ”);
Leia (raio);
peri  2 * pi * raio;
Escreva (“O perímetro do círculo segundo o raio “, raio, “informado é: ”, peri);
FIM.
Figura 18 – Algoritmo para calcular o perímetro de um círculo
2) Elabore um algoritmo para calcular consumo médio de um veículo, conhecidos a distância
total e a quantidade de combustível consumido para percorrer tal distância.
Algoritmo calc_consumo;
Declare consumo, distancia, qde_comb: real;
INÍCIO
Escreva (“Programa para calcular o consumo médio de combustível”);
Escreva (“Informe a distancia em Km percorrida pelo veiculo: ”);
Leia (distancia);
Escreva (“Informe a quantidade em litros de combustível gasto: ”);
Leia (qde_comb);
consumo  qde_comb/ distancia;
Escreva (“O consumo médio de combustível para a distância de”, distancia, “km foi
de:” , consumo, “litros/km.”);
Escreva (“O carro fez ”, distancia/qde_comb, “ km por litro!”);
FIM.
Figura 19 – Algoritmo para calcular o consumo de combustível
3) Elabore um algoritmo para leia uma quantidade de chuva dada em polegadas e apresente o
equivalente em milímetros, considerando que 1 polegada = 25,4 milímetros (mm).
Algoritmo chuva_em_mm;
Declare pol, mm: real;
INÍCIO
Escreva (“Programa para converter um volume de chuva de polegadas para milímetros.”);
Escreva (“Informe a quantidade de chuva em polegadas: ”);
Leia (pol);
mmpol * 25,4;
Escreva (“volume de chuva em milímetros é: “, mm, “mm”);
FIM.
Figura 20 – Algoritmo para calcular o consumo de combustível


1) Para as variáveis a seguir e seus respectivos valores, B  2; X  3 determine o resultado
das expressões aritméticas a seguir:
a) X * B
b) - (X ** B)
c) (-X) ** B
d) (2*B)/X^X
2) Escreva em linguagem algorítmica as expressões aritméticas:
3) Dada a declaração de variáveis:

Declare A, B, C : inteiro;
X, Y, Z : real;
NOME, RUA : literal;
L1, L2 : lógico;
Classifique as expressões a seguir segundo o tipo de dado resultante da(s) operação(ões), em I

(inteiro), R (real), L (literal), B (lógico) ou ND (quando não for possível definir):
( )A+B+C ( )A+Z/A
( )A+B+Z ( ) A B = L1
( ) NOME + RUA ( ) (A = B)
( )AB ( )X+Y/Z
( )AY ( )X=Z/A
( ) NOME RUA ( ) L1 ** L2
( )A+B/C ( ) A + B / L2
( )A+X/Z ( ) X < L1 / RUA
4) Elabore um algoritmo para calcular o estoque médio de uma peça, considerando que
EstoqueMedio = (QuantidadeMínima + QuantidadeMáxima) /2. Faça um Teste de Mesa
com dados definidos por você.

5) Elabore um algoritmo para leia uma temperatura em graus Fahrenheit, calcule e exiba a
temperatura convertida em graus Centígrados, considerando que C = (F - 32) * ( 5 / 9 ).
6) Elabore um algoritmo que leia o salário base de um funcionário, o número de horas extras
feitas, o valor de cada hora extra e o auxilio refeição. Imprima na tela o valor do salário
bruto (sem descontos). Na sequencia calcule o desconto do INSS de 10% sobre o salário
bruto e mostre o total a receber.
7) Elabore um algoritmo que leia três números e apresente o resultado da soma das
combinações destes números.
8) Elabore um algoritmo para leia uma temperatura em graus Celsius, calcule e exiba a
temperatura convertida em graus Kelvin, considerando que K = C + 273.
9) Elabore um algoritmo que dada a cotação do dólar e um valor em dólares, converta este
valor em Real e mostre o resultado.
10) Elabore um algoritmo que leia valores para X e Y respectivamente e calcule:
a) O resto da divisão de X / 3
3
b) X – 4
2
c) (X * Y)
Y
d) X + 2
e) Raiz quadrada de Y

6 COMANDOS CONDICIONAIS
Os comandos condicionais (decisão ou desvio) permitem a escolha de uma instrução ou
grupo de instruções a ser executado quando determinada condição é ou não satisfeita como
exemplificado na figura a seguir.
sim Escrever ( “ X é maior ou igual a 10”)

X >= 10 ?
não
Escrever ( “ X é ,menor a 10” )
Figura 21 – Fluxograma de Comando Condicional SE ENTÃO SENÃO
...
se (tiver dinheiro suficiente) então
almoçarei em um bom restaurante;
senão
comerei um lanche;
fim-se;
...
Figura 22 – Exemplo de Comando Condicional SE ENTÃO SENÃO
Neste capítulo, apresentam-se Operadores Relacionais, Operadores Lógicos e Comandos

Condicionais “SE ... ENTÃO”, “SE ... ENTÃO ... SENÃO” e “ESCOLHA ... CASO”.
6.1 Operadores Relacionais e Lógicos

Os Operadores Relacionais e Lógicos são utilizados para comparar e avaliar dados
utilizados nos comandos condicionais. Desta forma, será possível criar algoritmos que
representem regras do mundo real como:
- Se salário for maior que 2400 reais então desconte 15% do imposto de renda na fonte;
- Se salário menor que 3 salários mínimos então salário família por dependente será 30
reais, senão 10 reais.
- Se comprador é de Minas Gerais então aplique 18% ICMS, senão aplique 12% de ICMS.

6.1.1 OPERADORES RELACIONAIS
Os Operadores Relacionais são utilizados para comparar caracteres e números. Estes

operadores sempre retornam valores lógicos (Verdadeiro ou Falso / True ou False).
Os símbolos para os Operadores Relacionais são:

Tabela 9 – Operadores Relacionais
= Igual a
<> ou # Diferente de
> Maior que
< Menor que
>= Maior ou igual a
<= Menor ou igual a
Exemplificando...
Tabela 10 – Operadores Relacionais aplicados ao tipo INTEIRO
Dados os valores das variáveis do tipo INTEIRO X = 3 e Y = 7, vide os

resultados das expressões a seguir:
Expressão Resultado
X=Y FALSO
X <> Y VERDADEIRO
X>Y FALSO
X<Y VERDADEIRO
X>=Y FALSO
X<=Y VERDADEIRO
.
Analogamente, o raciocínio é aplicado para variáveis do tipo reais, caractere e lógico.

Tabela 11 – Operadores Relacionais aplicados ao tipo REAL
Dados os valores das variáveis do tipo REAL X = 4.52 e Y = 4.60, vide os

X=Y FALSO
X <> Y VERDADEIRO
X>Y FALSO
X<Y VERDADEIRO
X>=Y FALSO
X<=Y VERDADEIRO
.

Tabela 12 – Operadores Relacionais aplicados ao tipo CARACTERE
Dados os valores das variáveis do tipo CARACTERE X = „a‟ e Y = „d‟,

vide os resultados das expressões a seguir:
X=Y FALSO
X <> Y VERDADEIRO
X>Y FALSO
X<Y VERDADEIRO
X>=Y FALSO
X<=Y VERDADEIRO
.
Para saber se um caractere é maior que outro, consideram-se os caracteres em ordem

alfabética e que os caracteres minúsculos são maiores que os maiúsculos. Além disto, „a‟ é
diferente de „A‟, implicando que caracteres maiúsculos são diferentes de caracteres minúsculos,
ainda que represente a mesma letra no alfabeto.
Veja exemplo a seguir:

Tabela 13 – Operadores Relacionais aplicados a CARACTERES maiúsculo e minúsculo
Dados os valores das variáveis do tipo CARACTER X = „A‟ e Y = „a‟, vide

os resultados das expressões a seguir:
X=Y FALSO
X <> Y VERDADEIRO
X>Y FALSO
X<Y VERDADEIRO
X>=Y FALSO
X<=Y VERDADEIRO
.
Tabela 14 – Operadores Relacionais aplicados ao tipo LITERAL
Dados as variáveis do tipo LITERAL X = „Ana‟ e Y = „antonio‟, vide os

X=Y FALSO
X <> Y VERDADEIRO
X>Y FALSO
X<Y VERDADEIRO
X>=Y FALSO
X<=Y VERDADEIRO
.

Para comparar literais, usa-se as mesmas regras de caracteres, seguindo um processo

análogo a procura de palavra em um dicionário. Assim compara-se a primeira letra de X, „A‟,
com a primeira letra de Y, „a‟, assume-se que X é menor que Y, pois letras maiúsculas são
menores que as minúsculas.
Outro exemplo para melhor compreensão seria comparar X=‟Ana‟ e Y=‟Antonio‟.

Compara-se a primeira letra das duas palavras. Observa-se que elas são idênticas e representam a
letra „A‟ maiúscula. Portanto, deve-se comparar a segunda letra das duas palavras. Observa-se
que também são idênticas e representam a letra „n‟ minúscula. Na sequência, deve-se comparar a
terceira letra das duas palavras. Observa-se que a terceira letra de X é „a‟ e a terceira letra de Y é
„t‟, como as duas são minúsculas e „a‟ aparece primeiro que „t‟ no alfabeto, então pode-se
afirmar que X é menor que Y.
6.1.2 OPERADORES LÓGICOS

Quando se escreve expressões lógicas, elas podem ser simples ou compostas. Seu programa
pode utilizar expressões simples como “Se salário >2400 então...”. Porém, existem problemas
que exigem expressões lógicas mais complexas como: “Se salário < 2400 E dependentes > 3
então...”.
Outro exemplo seria “Se (matrícula=‟12345‟ OU matricula=‟23156‟ então...”. Observe que

existem casos que várias condições com operadores relacionais precisam ser inseridas na mesma
condição.
Para fazer isto, necessita-se dos operadores lógicos E, OU e NÃO.
Os Operadores Lógicos são utilizados para combinar resultados de expressões, retornando

se o resultado final é verdadeiro ou falso.

Tabela 15 – Operadores Lógicos
E Uma expressão E é verdadeira se todas as

condições forem verdadeiras
OU Uma expressão OU é verdadeira se pelo menos
uma condição for verdadeira
NÃO Uma expressão NÃO inverte o valor da expressão
ou condição, se verdadeira inverte para falsa e
vice-versa
6.1.2.1 Tabela verdade genérica...
Dados os valores de x e y, observe os resultados:

Operador E - a resposta da operação é verdade se x e y forem verdadeiras.
x y xEy
V V V
V F F
F V F
F F F
Operador OU - a resposta da operação é verdade se pelo menos um dos

elementos for verdadeiro.
x y x OU y
V V V
V F V
F V V
F F F
Operador NÃO - Se ela for verdade, torna-se falsa, e vice-versa.

x NÃO x
V F
F V
.

6.1.3 EXERCÍCIO PROPOSTO

Dados X2, A5, B4 e C3 e D6, determine os resultados lógicos das expressões,
indicando se são VERDADEIRAS ou FALSAS:
a) (X >= 2)
b) (X < 1) E (B >=D)
c) (A + B) > 10 OU (A + B) = (C + D)
d) (A >= C) E (D >= C)
e) NÃO (X > 3)
f) (X < 1) E NÃO (B > D)
g) NÃO (D < 0) E (C > 5)
h) NÃO (X > 3) OU (C < 7)
i) (A > B) OU (C > B)
6.2 Comando Condicional Simples SE ... ENTÃO

No SE ... ENTÃO determinada que se uma condição for satisfeita então o bloco de
comando(s) é executado.
... ; (ponto e vírgula) marca o

SE (condição) ENTÃO fim deste comando.
; (ponto e vírgula) marca o comando 1;
fim do comando SE. comando 2;
comando 3;
FIMSE;
...
Figura 23 – Sintaxe do Comando Condicional Simples
Exemplificando...
Faça um algoritmo que leia a média de um aluno e escreva na tela “Aluno Aprovado” caso
a média dele seja igual ou superior a 6.
...
SE (media>=6) ENTÃO
escreva (“Aluno Aprovado”);
FIMSE;
...
Figura 24 – Exemplo de Algoritmo usando Comando Condicional Simples

O trecho do algoritmo mostrado na Figura 1 apresenta a utilização do comando

SE...ENTÃO... para o enunciado apresentado. Se a média for maior ou igual a 6 então o
comando escreva é executado. Caso a média seja menor que 6, o comando escreva não é
executado.
6.3 Comando Condicional Composto SE ... ENTÃO ... SENÃO

No SE/ENTÃO/SENÃO se a condição for verdadeira o bloco referente aos comandos 1 e
2 será executado. Caso contrário serão executados os comandos 3 e 4.
...
SE (condição) ENTÃO
comando 1;
comando 2;
SENÃO
comando 3;
comando 4;
FIMSE;
...
Figura 25 – Sintaxe do Comando Condicional Composto
Exemplificando...
Faça um algoritmo que leia a média de um aluno e escreva na tela se ele foi aprovado ou
reprovado.
...
SE (media>=6) ENTÃO
escreva (“Aluno Aprovado”);
SENÃO
escreva (“Aluno Reprovado”);
FIMSE;
...
Figura 26 – Exemplo de Algoritmo usando Comando Condicional Composto
Na condição exemplificada, se for verdadeira, executa o comando APROVADO, caso

contrário executa o comando REPROVADO.

Veja na sequencia, exemplos utilizando os Operadores Lógicos E, NÃO e OU.
...
SE (media >= 6) E ( frequencia > 75% )
ENTÃO
escreva (“Aluno Aprovado”)
SENÃO
escreva (“Aluno Reprovado”);
FIMSE;
...
Figura 27 – Exemplo de Algoritmo usando Comando Condicional Simples
...
SE (NÃO tiver dinheiro) ENTÃO
almoçarei em casa;
SENÃO
irei a um restaurante;
FIMSE;
...
Figura 28 – Exemplo de Comando Condicional SE ENTÃO SENÃO, usando operador NÃO
...
SE (tiver dinheiro suficiente) OU (terminado o trabalho)
ENTÃO
irei ao cinema;
SENÃO
ficarei em casa;
FIMSE;
...
Figura 29 – Exemplo de Comando Condicional SE ENTÃO SENÃO, usando operador OU

1) Elabore um algoritmo para calcular as raízes de uma equação de segundo grau, dados os
fatores a, b e c, Considerando , se d menor que zero as raízes não podem ser
calculadas (não existem raízes reais). Senão, é possível calcular as duas raízes.
...
leia (a);
leia (b);
leia (c);
d  b * b – 4 * a * c;
SE (d < 0) ENTÃO
Escreva (“Não existem raízes reais”);
SENÃO
raiz1  ( -b + SQRT(d) ) / (2 * a );
raiz2  ( -b – SQRT(d) ) / (2 * a );
Escreva ( raiz1 );
Escreva ( raiz2 );
FIMSE;
...
2) Faça um algoritmo que receba um número inteiro e verifique se esse número é par ou
ímpar.
algoritmo par_impar;
declare num, r : inteiro;
INICIO
escreva (“Este algoritmo verifica se um número é par ou ímpar.”);
escreva (“Digite um número inteiro: ”);
leia (num);
r  num MOD 2;
SE (r = 0) ENTÃO
escreva(“Este número é par”);
SENÃO
escreva(“Este número é ímpar”);
FIMSE;
FIM.

6.4 Indentação
Indentação (palavra adaptada do inglês, indentation) é uma técnica de recuo que aplicada
ao código de um programa facilita a visualização da organização dos comandos e sua estrutura.
Seu uso iniciou-se antes da programação com o nome de “tabulação de texto”, sendo utilizada
rotineiramente na escrita de livros, panfletos, cartazes etc.
Exemplificando...
INSTITUTO PARA PROMOÇÃO DA FAMÍLIA
As inscrições no curso de Maturidade Familiar devem ser feitos na secretaria do Instituto

Para Promoção da Família de 3 a 11 de março. Os documentos necessários são:
 PAI
 Cópia do RG
 Cópia do título de reservista
 Cópia do último holerite
 MÃE
 Cópia do Certificado do Curso “A Arte De Ser Mãe”
 Cópia do RG
 Comprovantes Médicos com menos de 1 ano:
 Papa Nicolau
 Mamografia
 FILHOS
 Certidão de nascimento
Figura 30 – Exemplo de Indentação em Texto Comum
Na Figura 30, nota-se que a margem do primeiro parágrafo não é seguida em todo texto. Há
dois níveis de indentação, além do alinhamento natural da margem esquerda do primeiro
parágrafo. O primeiro nível refere-se às palavras PAI, MÃE E FILHOS, o qual foi empurrado
para a direita, não seguindo o alinhamento original da margem esquerda. O segundo nível,
empurrado mais para a direita do primeiro nível, refere-se aos comprovantes médicos a serem
entregues pela MÃE. Observa-se que as palavras “Papa Nicolau” e “Mamografia” estão em um
alinhamento mais interno da folha. A indentação auxiliando no entendimento de quais
documentos devem ser entregues por cada um dos participantes segundo seu papel na família
(pai, mãe ou filho).
Um texto pode ter vários níveis de indentação e deve-se garantir uniformidade da margem
para os textos de mesmo nível. Portanto, os textos selecionados para compor o segundo nível de
indentação devem seguir o mesmo alinhamento de margem, sendo proibida variação de margem
para o mesmo nível.

Quando se deseja criar um novo nível de indentação, basta empurrar um pouco mais a
margem para a direita. Na prática, a técnica de indentação permite associar visualmente
informações específicas as informações genéricas.
Os conceitos de indentação aprendidos no comando SE...ENTÃO...SENÃO serão

utilizados em outros comandos e estruturas.
Exemplificando...
Faça um algoritmo que leia um número e responda se ele é maior que 10.
Algoritmo Maior10;
declare x: inteiro; As 3 linhas de comando do
INÍCIO
ENTÃO foram indentadas para
Escreva (“Digite um número: ”);
facilitar a visualização. E o
Leia (x);
mesmo foi feito para o SENÃO.
SE (x>10) ENTÃO
escreva (x, “ é maior que 10”);
escreva (“Os comandos da indentação do ENTÃO foram executados”);
escreva(“A indentação facilita visualizar quais comandos estão dentro do ENTÃO”);
SENÃO
escreva (x, “ é menor que 10”);
escreva (“Os comandos da indentação do SENÃO foram executados”);
escreva(“A indentação facilita visualizar quais comandos estão dentro do SENÃO”);
FIMSE;
FIM.
Figura 31 – Exemplo de Indentação
Adote o hábito de utilizar a técnica de indentação mesmo que ela pareça difícil no início.
Após dominar seu uso, o programador observará que sua utilização facilita o trabalho, aumenta a
produtividade, facilita o entendimento do código, além de ser exigido nas empresas.

6.5 Aninhamento de Comandos SE...ENTÃO...SENÃO

A técnica de aninhamento de comando refere-se ao ato de utilizar um comando dentro de
outro comando. Portanto, diz-se que há aninhamento de comandos SE...ENTÃO...SENÃO,
quando utiliza-se um comando SE...ENTÃO...SENÃO dentro de outro comando
SE...ENTÃO...SENÃO. Não há limite de aninhamentos, podendo-se ter vários comandos
SE...ENTÃO...SENÃO um dentro do outro quantas vezes forem necessárias para se implementar
o algoritmo solicitado.
Até o momento, explicou-se aninhamento para o comando SE...ENTÃO...SENÃO, porém

este conceito também é válido para outros diversos outros comandos que ainda serão ensinados.
Exemplificando...
Faça um algoritmo que leia dois números inteiros e responda qual deles é o maior ou se
eles são iguais.
Algoritmo Maior;
declare x, y: inteiro;
INÍCIO
escreva (“Este algoritmo apresenta qual de 2 números inteiros, lidos do teclado, é o maior.”);
escreva (“Digite o primeiro número: ”);
leia (x);
escreva (“Digite o segundo número: ”);
leia (y);
Comando SE...ENTÃO...SENÃO dentro
SE (x>y) ENTÃO de outro comando SE...ENTÃO...SENÃO
escreva (x,“ é maior que “, y); denomina-se aninhamento.
SENÃO
SE (x<y) então
escreva (y,“ é maior que “, x);
SENÃO
escreva (x,“ é igual a “, y);
FIMSE;
FIMSE;
FIM.
Figura 32 – Exemplo de Aninhamento de Comandos SE...ENTÃO...SENÃO, Algoritmo Maior
A Figura 32 apresenta um algoritmo contendo 1 aninhamento. Nela observa-se que há um

comando SE...ENTÃO...SENÃO dentro do bloco de um SENÃO. Assim, se há um comando

SE...ENTÃO...SENÃO dentro de outro comando SE...ENTÃO...SENÃO, diz-se ter

aninhamento.
O aninhamento pode ocorrer apenas com SE...ENTÃO e dentro dele outro SE...ENTÃO.
Outra forma seria ter um comando SE...ENTÃO dentro de um bloco SENÃO, bem como
outras variações. Havendo um comando dentro do outros, afirma-se ter aninhamento.

1) Faça um algoritmo que leia a média final e frequencia de um aluno e imprima na tela se o
aluno está REPROVADO POR FREQUENCIA, APROVADO, RECUPERAÇÃO ou
REPROVADO POR NOTA, sabendo que:
 Aluno precisa ter 75% ou mais de frequencia nas aulas, caso contrário ele está
reprovado por falta, independente da nota.
 Aluno está aprovado se a Média for maior ou igual a 60 pontos.
 Aluno está de recuperação se a média for maior ou igual a 30 e menor que 60.
 Aluno está reprovado por nota se a média for menor que 30 pontos.
Algoritmo Aprovacao_Aluno;
Declare media, frequencia: real;
INÍCIO
leia(frequencia);
leia (media);
SE ( frequencia >= 0.75 ) ENTÃO
SE (media >= 60) ENTÃO

escreva("Aluno APROVADO!")
SENÃO
SE ( media >= 30 ) ENTÃO
escreva( "Aluno deve fazer RECUPERAÇÃO!");
SENÃO
escreva( "Aluno REPROVADO POR NOTA INSUFICIENTE!" );
FIMSE;
FIMSE;
SENÃO
escreva("Aluno REPROVADO POR FALTAS!");
FIMSE;
FIM.
Figura 33 – Exemplo de Aninhamento de Comandos SE...ENTÃO...SENÃO, Algoritmo Aprovacao_Aluno

2) Faça um algoritmo para leia três números inteiros X, Y e Z e verificar se eles formam um
triângulo, imprimindo na tela "X, Y e Z não formam um triângulo" ou "X, Y e Z formam um
triângulo". Se as medidas formarem um triângulo, imprimir na tela se o triângulo é
equilátero, isósceles ou escaleno.
Algoritmo triangulo;
Declare
x, y, z: inteiro;
INICIO
leia ( x, y, z );
SE ( x+y>z ) E ( x+z>y ) E ( y+z>x ) ENTÃO

escreva (“X, Y e X formam um triângulo“ );
SE( x=y ) E ( y=z ) E (x=z) ENTÃO
escreva (“Triângulo Equilátero“);
SENÃO
SE ( x=y ) OU ( x=z ) ou ( y=z ) ENTÃO
escreva (“Triângulo Isósceles“);
SENÃO
SE ( x<>y ) E ( y<>z ) E ( x<>z ) ENTÃO
escreva (“Triângulo Escaleno“);
FIMSE;
FIMSE;
FIMSE;
SENÃO
escreva (“X, Y e X não formam um Triângulo”);
FIMSE;
FIM.
Figura 34 – Exemplo de Aninhamento de Comandos SE...ENTÃO...SENÃO, Algoritmo triangulo

6.6 Comando Condicional ESCOLHA ... CASO

O comando condicional ESCOLHA ... CASO possibilita comparar o valor de uma
variável/expressão em várias opções.
A Figura 35 representa que <variável> assumirá um valor e caso o valor seja igual ao valor
em opção1, então os comandos1 serão executados. Caso contrário, <variável> será comparada
com o valor em opção2 e, no caso de ser igual, executará comandos2, senão comparará com as
demais opções existentes. Se uma opção for satisfeita, então os comandos referente aquela opção
é executada e todas as demais opções são ignoradas.
Figura 35 – Fluxograma de Comando Condicional ESCOLHA CASO

ESCOLHA <variável>
CASO 1: < comandos >;
...
CASO n: < comandos >;
CASO CONTRÁRIO: < comandos >;
FIMESCOLHA;
Figura 36 – Sintaxe do Comando Condicional ESCOLHA CASO
O comando ESCOLHA...CASO, em algumas situações, pode ser usado para simplificar a

utilização do SE ... ENTÃO ... SENÃO, facilitando a leitura do algoritmo. Na Figura 37,
apresenta-se um trecho de algoritmo aplicando o comando SE...ENTÃO...SENÃO e, em seguida,
na Figura 38, apresenta-se a mesma lógica escrita com o comando ESCOLHA...CASO.
...
leia (cargo);
SE (cargo=1) ENTÃO
escreva("Presidente")
SENÃO
SE (cargo=5) ENTÃO
escreva("Chefe de Seção")
SENÃO
SE (cargo=8) ENTÃO
escreva("Auxiliar de Serviços Gerais")
SENÃO
escreva("Esta operação não permite cargos diferentes de 1, 5 e 8");
FIMSE;
FIMSE;
FIMSE;
...
Figura 37 – Algoritmo Aplicando o Comando SE...ENTÃO...SENÃO
Observa-se na Figura 37 um trecho de algoritmo que solicita leia um valor para cargo. Se o
usuário digitar o valor 1, então aparecerá na tela "Presidente". Se o usuário digitar o valor 5,
então aparecerá na tela "Chefe de Seção". Se o usuário digitar o valor 8, então aparecerá na tela
"Auxiliar de Serviços Gerais". Se o usuário digitar um valor diferente de 1, 5 ou 8, então
aparecerá na tela "Esta operação não permite cargos diferentes de 1, 5 e 8".
O algoritmo descrito na Figura 38 apresenta o mesmo algoritmo escrito com o comando

ESCOLHA...CASO. Se o usuário digitar o valor 1, então o “CASO 1” será escolhido e aparecerá
na tela "Presidente". Se o usuário digitar o valor 5, então o “CASO 5” será escolhido e aparecerá
na tela "Chefe de Seção". Se o usuário digitar o valor 8, então o “CASO 8” será escolhido e
aparecerá na tela "Auxiliar de Serviços Gerais". Se o usuário digitar um valor diferente de 1, 5

ou 8, então o “CASOCONTRARIO” será escolhido e aparecerá na tela "Esta operação não

permite cargos diferentes de 1, 5 e 8".
Ambos algoritmos tem a mesma funcionalidade, porém o algoritmo da Figura 38 possui

uma estética que torna mais fácil a leitura e compreensão do código.
...
leia (cargo);
ESCOLHA (cargo)
CASO 1: escreva("Presidente");
CASO 5: escreva("Chefe de Seção");
CASO 8: escreva("Auxiliar de Serviços Gerais");
CASOCONTRARIO escreva("Esta operação não permite cargos diferentes de 1, 5 e 8");
FIMESCOLHA;
...
Figura 38 – Algoritmo Aplicando o Comando ESCOLHA...CASO
O comando ESCOLHA... CASO possui variações na notação da cláusula CASO, descritas

a seguir:
Tabela 16 – Variação de Sintaxe para o Comando ESCOLHA...CASO
Notação Descrição
Caso 1: Verifica se o valor é 1
Caso 3..6: Verifica se o valor é um número entre 3 e 6. Logo, o valor pode ser 3,4,5 ou 6.
Verifica se o valor é um dos valores contidos na lista 2, 7, 9, 21. Portanto, o valor
Caso 2, 7, 21:
pode ser 2 ou 7 ou 21.
Ressalta-se que a sintaxe do comando ESCOLHA...CASO não aceita operadores

relacionais como >,< , <=, etc. Portanto, se você quiser verificar se um valor de x>=10 e x=< 20,
use a sintaxe “CASO 10..20” que denota um intervalo.
...
Leia (opcao);
ESCOLHA (opção)
CASO 2, 4: < comandos >;
CASO 5 ..10: < comandos >;
CASO CONTRÁRIO: < comandos >;
FIMESCOLHA;
...
Figura 39 – Sintaxe do Comando Condicional ESCOLHA CASO – Outra sintaxe 2

Deve-se ressaltar também que o comando ESCOLHA...CASO analisa APENAS uma

variável por vez, sendo permitido colocar ESCOLHA (SEXO) ou ESCOLHA(IDADE), mas
nunca escreva ESCOLHA(SEXO, IDADE). Este último não é aceito pelo comando.
Observa-se no Figura 39 diferença na sintaxe em “CASO 2, 4: ” e “CASO 5..10”. Quando

se utiliza números separados por vírgula, isto implica que qualquer um dos números descritos
serve. Portanto a linha “CASO 2,4: ” indica que se a opção digitada for 2 ou 4, os comandos
dentro desta estrutura serão executados! A linha “CASO 5..10: ” indica que se a opção digitada
for um valor variando de 5 até 10, inclusive extremidades, a comparação é verdadeira e,
portanto, os comandos referentes ao CASO 5..10 serão executados.
Exemplificando...
No algoritmo a seguir o valor da variável mês é lido e testado. Caso o valor esteja entre os
valores entre 1 a 12 é executado o comando correspondente a opção. Caso contrário é executado
o comando que escreve mês inválido.
algoritmo descubra_mes;
declare mes : inteiro;
INICIO
escreva (“Digite o número do mês: “);
leia (mes);
ESCOLHA (mes)
CASO 1: escreva (“Janeiro“);
CASO 2: escreva (“Fevereiro“);
CASO 3: escreva (“Março“);
...
CASO 12: escreva (“Dezembro“);
CASO CONTRÁRIO: escreva (“Mês inválido!“);
FIMESCOLHA;
FIM.
Figura 40 – Exemplo de Algoritmo usando Escolha Caso

Exemplificando...
No algoritmo da Figura 41 o valor da variável idade é lido e testado. A mensagem enviada

na tela corresponderá a idade digitada.
algoritmo faixa_etária;
declare idade : inteiro;
INICIO
escreva (“Digite a idade em anos: “);
leia (idade);
ESCOLHA (idade)
CASO 0..2: escreva (“Bebê“);
CASO 3..9: escreva (“Criança“);
CASO 10..19: escreva (“Adolescente”);
CASO 20..30: escreva (“Jovem“);
CASO 31..60: escreva (“Adulto“);
CASO CONTRÁRIO: escreva (“Idoso“);
FIMESCOLHA;
FIM.
Figura 41 – Exemplo de Algoritmo usando Escolha Caso


1) Dê os resultados das expressões contidas na tabela a seguir, utilizando os seguintes valores
para as variáveis:
Valor das variáveis Expressão Resultado
(X = Y) E (Y > Z)
a) X 8; Y10; Z3;
(X <> Y) OU (Y < Z)
b) X13; Y 2; Z5;
NÃO (X > Y)
c) X 4; Y 7; Z9;
(X < Y) E (Y > Z)
d) X 6; Y 4; Z4;
(X >= Y) OU (Y = Z)
e) X „a‟; Y „k‟; Z‟D‟;
NÃO (X <= Y)
f) X “Rosana”; Y “Roseane”; Z”Rosária”;
2) Para as variáveis a seguir e seus respectivos valores:

a1 x  3.0 L1  V
b2 y  2.0 nome  “PEDRO”
c3 z  -1.0 rua  “PEDRINHO”
L2  F
Determine o resultado das expressões a seguir:
a) a+c/b i) L1 OU L2
b) a+b+c j) (L1 E(NÃO L2))
c) c/b/a k) (L2 E (NÃO L1))
d) -x ** b l) (L1 E (NÃO L2)) OU (L2 E (NÃO L1))
e) - (x ** b) m) (x -y) E (c - b)
f) (-x) ** b n) (c - 3 * a) (x + 2 * z)
g) nome + rua o) rua <> nome
h) nome = rua
3) Elabore um algoritmo para receber 3 números e mostre o maior.

4) Elabore um algoritmo para receber 2 números e execute as operações a seguir, segundo a

escolha do usuário.
Escolha do usuário Operação

1 Média entre os números digitados
2 Diferença do maior pelo menor
3 Produto entre os números digitados
4 Divisão do primeiro pelo segundo
5) Elabore um algoritmo para receber 3 números e mostre-os em ordem crescente.
6) Elabore um algoritmo que leia um número inteiro e mostre uma mensagem indicando se este
número é par ou ímpar, e se é positivo ou negativo.
7) Um banco concederá um crédito especial a seus clientes dependendo de seu saldo médio. Faça
um algoritmo que leia o saldo médio de um cliente e calcule o valor do crédito de acordo com
a tabela a seguir. Mostre uma mensagem informando o saldo médio e o valor do crédito. (use
o comando ESCOLHA...CASO)
Saldo Médio Percentual
de 0 a R$ 200,00 nenhum crédito
de R$ 201,00 a R$ 400 20% do valor do saldo médio
de R$ 401,00 a R$ 600,00 30% do valor do saldo médio
acima de R$ 601,00 40% do valor do saldo médio

7 COMANDOS DE REPETIÇÃO
Para compreender a necessidade de comandos de repetição, é necessário examinar algumas
solicitações que um cliente pode fazer.
Imagine a solicitação de um algoritmo que imprima na tela a tabuada de 0 a 9 de

um número fornecido pelo usuário. Assim, se o usuário digitar o número 3, então deverá sair na
tela uma tabuada do número 3. A Figura 42 apresenta um algoritmo de tabuada sem utilizar
comando de repetição.
Algoritmo Tabuada_Sem_Comando_Repeticao;
declare i, tab, num: inteiro;
INICIO
Escreva (“Fazer tabuada do número: ”)
Leia (tab);
Escreva ( “0 x ”, tab, “ = ”, 0 * tab );
Escreva ( “1 x ”, tab, “ = ”, 1 * tab );
Escreva ( “2 x ”, tab, “ = ”, 2 * tab );
Escreva ( “3 x ”, tab, “ = ”, 3 * tab );
Escreva ( “4 x ”, tab, “ = ”, 4 * tab );
Escreva ( “5 x ”, tab, “ = ”, 5 * tab );
Escreva ( “6 x ”, tab, “ = ”, 6 * tab );
Escreva ( “7 x ”, tab, “ = ”, 7 * tab );
Escreva ( “8 x ”, tab, “ = ”, 8 * tab );
Escreva ( “9 x ”, tab, “ = ”, 9 * tab );
FIM.
Figura 42 – Exemplo de Algoritmo de Tabuada Sem Comando de Repetição
Nota-se que para fazer o algoritmo o comando escreva deve ser repetido várias vezes tendo
pequena alteração. Como a tabuada solicitada compreendia os valores entre os números 0 a 9
então o trabalho foi repetitivo, mas não tão grande.
Ao executar o algoritmo, se o usuário digitasse o número 5, então o programa imprimiria

na tela:
0x5=0
1x5=5
2 x 5 = 10
3 x 5 = 15
4 x 5 = 20
5 x 5 = 25
6 x 5 = 30
7 x 5 = 35
8 x 5 = 40
9 x 5 = 45
Figura 43 – Saída na tela do Algoritmo da Figura 42

O algoritmo torna-se maior e mais repetitivo se um engenheiro solicitar a você fazer um

programa que construa a tabela de seno de 0 até 90 graus, variando de 0.0001 em 0.0001 graus.
Quantas linhas você precisaria?
Outro pedido poderia ser a solicitação do somatório de 1 até 1milhão. Pense em como seria
a solução para o somatório de 1 até 10, depois imagine ter que fazer o somatório até 10 milhões.
Invista um tempo para compreender a solução e o trabalho repetitivo imposto por esta
solicitação.
Nestes dois últimos exemplos, do seno e do somatório, muitas linhas de código seriam
escritas, em um trabalho puramente repetitivo, mas você chegaria a uma solução.
Entretanto, os clientes não gostam de soluções fixas como somatório e 1 a 1milhão, ele
preferiria digitar o primeiro e último números, esperando a resposta do somatório. Ou então,
digitar os valores iniciais e finais para o cálculo do seno.
Para soluções que exigem trabalho repetitivo, devem-se usar comandos de repetição.
Os Comandos de Repetição, também conhecidos como Laços ou Loops, permitem que um

conjunto de instruções seja executado repetidamente até que uma determinada condição de
interrupção seja satisfeita.
Existem três Comandos de Repetição denominados PARA...FAÇA, ENQUANTO...FAÇA

e REPITA...ATÉ, categorizados da seguinte forma:
a) Comando de Repetição com Número de Repetições DEFINIDAS:

a.1) Teste de Condição no INÍCIO: o comando pertencente a esta categoria é o
PARA... FAÇA
b) Comando de Repetição com Número de Repetições INDEFINIDAS:
b.1) Teste de Condição no INÍCIO: o comando pertencente a esta categoria é o
ENQUANTO...FAÇA
b.2) Teste de Condição no FINAL: o comando pertencente a esta categoria é o
REPITA...ATÉ

Número de Repetições Definidas Teste de Condição no Início PARA...FAÇA
Número de Repetições Indefinidas Teste de Condição no Início ENQUANTO...FAÇA

Condição no Início
Teste de Condição no Final REPITA...ATÉ
Figura 44 – Categorização dos Comandos de Repetição
Cada um dos comandos descritos na Figura 44, PARA...ATÉ, ENQUANTO....FAÇA e

REPITA...ATÉ são detalhados nas próximas seções.
8 Comando de Repetição: Número Definido de Repetições e

Teste de Condição no Início
8.1 Comando de REPETIÇÃO PARA ... FAÇA
O comando PARA...FAÇA representa o comando desta categoria. Utiliza-se este comando
quando se sabe o número de vezes que um conjunto de instruções deve ser repetido. No caso da
tabuada de 1 até 9, por exemplo, sabe-se que deve-se começar no número 1 e terminar no 9,
caracterizando de maneira clara o valor de início e fim das repetições.
O teste de condição do comando PARA fica no início de sua estrutura. Assim, o bloco de
comandos é repetido até atingir o número de repetições explicitadas. Quando a condição não for
mais satisfeita, a execução saltará os comandos que deveriam ser repetidos, deixando de executá-
los, e continuando a execução normal do algoritmo. Se a condição não for satisfeita logo na
primeira comparação, nenhuma instrução dentro da estrutura PARA será executada.

Figura 45 – Fluxograma de Comando de Repetição PARA
Na Figura 45, a variável i recebe um valor inicial, um valor final e um valor para
incrementar a variável i a cada repetição realizada. Se o incremento for 1, então a cada repetição
a variável i será acrescida automaticamente de 1. Se o incremento for 3, então a cada repetição a
variável i é incrementada de 3 automaticamente.
A Figura 46 apresenta o pseudocódigo geral do comando PARA...FAÇA, referente ao

fluxograma apresentado na Figura 45. A variável utilizada no comando PARA...FAÇA para
contar o número de repetições é denominada de contador. O contador deve ser sempre do tipo
inteiro e o nome dado ao contador fica a critério do programador.
...
Declare contador: inteiro;
Contador
...
utilizado no
PARA contador DE <valor inicial> ATÉ <valor final> FAÇA
comando
<instruções>;
PARA...FAÇA
FIM -PARA;
...
Figura 46 – Pseudocódigo do Comando de Repetição PARA
No exemplo apresentado na Figura 47, foi declarada uma variável denominada CONT para
ser o contador utilizado no comando PARA...FAÇA. Observa-se que no comando
PARA...FAÇA que CONT inicia seu valor em 1, devendo ir até o valor 10. O incremento padrão
para CONT é 1, isto é, CONT começará seu valor em 1, e variará de 1 em 1, até atingir 10.

...
declare cont: inteiro;
...
PARA cont DE 1 ATÉ 10 FAÇA
escreva ( “o valor do contador é: ”, cont );
FIMPARA;
Escreva (“ Saiu das repetições do PARA...FAÇA”);
...
Figura 47 – Exemplo Do PARA...FAÇA Sem A Cláusula PASSO
Executando o algoritmo da Figura 47, cont inicia-se com o valor 1, em seguida o algoritmo
imprime a mensagem “o valor do contador é: 1” na tela.
Ao atingir o FIMPARA, o algoritmo retorna para a primeira linha do comando

PARA...FAÇA. cont passa a valer 2, e como ainda não chegou até 10, a linha escreva é
executada novamente, imprimindo na tela “o valor do contador é: 2”.
E assim sucessivamente, até que o valor de cont atinja o valor 10. Neste caso, ele imprime
a mensagem na tela “o valor do contador é: 10”, o último valor descrito no comando, e passa a
executar a próxima linha após o FIMPARA. As mensagens impressas na tela serão:
o valor do contador é: 1
Saiu das repetições do PARA...FAÇA
Figura 48 – Mensagens Impressas Na Tela Após Execução do Algoritmo da Figura 47
A Figura 49 apresenta o pseudocódigo geral do comando PARA...FAÇA com uma cláusula

extra denominada PASSO. Esta cláusula deve ser usada quando o programador desejar que o
contador varie com um valor diferente de 1 a cada repetição. Assim, se for descrito “PASSO 3”
no comando, o contador irá varia de 3 em 3 a cada repetição. O contador e o valor do PASSO
devem ser do tipo inteiro e o nome dado ao contador fica a critério do programador.

Determina o valor de
... variação do contador
Declare i : inteiro;
...
PARA i de <valor inicial> ATÉ <valor final> PASSO <valor de incremento>
FAÇA
<instruções>;
FIMPARA ;
...
Figura 49 – Pseudocódigo do Comando de Repetição PARA
Exemplificando...
...
Declare cont: inteiro;
...
PARA cont DE 1 ATÉ 10 PASSO 3 FAÇA
FIMPARA;
Escreva (“ Saiu das repetições do PARA...FAÇA”);
...
Figura 50 – Exemplo Do PARA...FAÇA com A Cláusula PASSO
Executando o algoritmo da Figura 50, cont inicia-se com o valor 1, em seguida imprime a
mensagem “o valor do contador é: 1” na tela. Ao atingir o FIMPARA, o algoritmo retorna para a
primeira linha do comando PARA...FAÇA.
Como foi determinado o valor 3 para PASSO, então cont passa a valer 4 (1 de CONT + 3
do PASSO). Como cont ainda não chegou até 10, a linha escreva é executada novamente,
imprimindo a mensagem “o valor do contador é: 4” na tela. Ao atingir o FIMPARA, o algoritmo
retorna para a primeira linha do comando PARA...FAÇA.
Como foi determinado o valor 3 para PASSO, então cont passa a valer 7 (4 de CONT + 3
do PASSO). E assim sucessivamente, até cont valer mais que 10. As mensagens impressas na
tela serão:

Exemplificando...
Faça um algoritmo que imprima na tela os números de 50 a 20.
Algoritmo Inverso_50_20;
...
PARA cont DE 50 ATÉ 20 PASSO -1 FAÇA
FIM-PARA;
Escreva (“Saiu das repetições do PARA...FAÇA”);
...
Figura 52 – Exemplo Do PARA...FAÇA Sem A Cláusula PASSO
Executando o algoritmo da Figura 52, cont é iniciado com o valor 50 e, em seguida, o

algoritmo imprime na tela a mensagem “o valor do contador é: 50”. Ao atingir o FIMPARA, o
algoritmo retorna para a primeira linha do comando PARA...FAÇA.
Como foi determinado o valor -1 para PASSO, então cont passa a valer 49 (50 de cont -1
do PASSO). Como cont ainda não chegou até 20, a linha escreva é executada novamente,
imprimindo a mensagem “o valor do contador é: 49”.
Isto ocorre sucessivamente até a última repetição da impressão com cont valendo 20. Após
isto, cont assa a valer 19 e então a repetição deixa de acontecer, considerando que a condição do
comando é “ATÉ 20”. Assim, o fluxo do programa passa para a primeira linha, imediatamente,
após o FIMPARA, imprimindo na tela “Saiu das repetições do PARA...FAÇA”. A saída na tela
será:
...
...

Exercícios Resolvidos
1. Faça um algoritmo que leia nome, nota 1 e nota 2 de 20 alunos, e imprima na tela o nome do
aluno e a sua média.
...
nome: literal;
n1, n2 : real;
...
PARA i de 1 ATÉ 20 passo 1 FAÇA
Escreva ("Nome: ");
Leia (nome);
Escreva ("Primeira nota:");
Leia (n1);
Escreva ("Segunda nota:");
Leia (n2);
media  (n1+n2)/2;
Escreva ("O aluno ",nome," teve média igual a: ",media);
FIMPARA;
...
Figura 54 – Exemplo de Algoritmo usando Comando de Repetição PARA
2. Faça um algoritmo que imprima na tela o valor do somatório de 1 até 50.
Algoritmo Somatorio_1_50;
Declare i, total : inteiro;
Inicio
total  0;
PARA i de 1 ATÉ 50 FAÇA
total  total + i;
FIMPARA;
Escreva ("O somatório de 1 a 50 é: “, total);
Fim.
Figura 55 – Exemplo de Somatório de 1 a 50 usando Comando de Repetição PARA

3. Faça um algoritmo que imprima na tela o valor do somatório de 1 até N, sendo N um valor
fornecido pelo usuário.
Algoritmo Somatorio_1_N;
Declare i, total, N : inteiro;
Inicio
Escreva ("Digite valor de N: ");
Leia (N);
total  0;
PARA i de 1 ATÉ N FAÇA
FIMPARA;
Escreva ("O somatório de 1 até “, N, “ é: “, total);
Fim.
Figura 56 – Exemplo de Somatório de 1 a N usando Comando de Repetição PARA
4. Faça um algoritmo que calcule o somatório de todos os múltiplos de 3 de 1 até N, sendo N um

valor fornecido pelo usuário. Imprimir o total do somatório na tela.
Algoritmo Somatorio_3_de_1_N;
Inicio
Leia (N);
total  0;
PARA i de 0 ATÉ N PASSO 3 FAÇA
FIMPARA;
Escreva ("O somatório dos múltiplos de 3 de 1 até “, N, “ é: “, total);
Fim.
Figura 57 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando a Cláusula PASSO

A Figura 58 apresenta solução alternativa sem utilizar a cláusula PASSO do comando

PARA...FAÇA. O resultado será o mesmo, mudando-se apenas a forma de se escreva o
algoritmo.
Declare i, total, N, num : inteiro;
Inicio
Leia (N);
total  0;
PARA i de 1 ATÉ trunc(N/3) FAÇA
total  total + num;
num  num + 3;
FIMPARA;
Escreva ("O somatório dos múltiplos de 3 de 1 até “, N, “ é: “, total);
Fim.
Figura 58 – Exemplo de Somatório dos múltiplos de 3 de 1 a N SEM a Cláusula PASSO

Exercícios Resolvidos
1. Faça um algoritmo que calcule o somatório dos termos a seguir, sendo N lido do teclado:
Somatório = 1 + 1/3 + 1/5 + 1/7 + ...+ 1/N
Algoritmo Somatorio_fracao;
total : real;
Inicio
Leia (N);
total  0;
PARA cont de 1 ATÉ N PASSO 2 FAÇA
total  total + ( 1 / cont );
FIMPARA;
Escreva ("O somatório é: “, total);
Fim.
2. Faça um algoritmo que calcule o somatório de N termos de fração, cujo denominador varia de
5 em 5 e o denominador de 2 em 2. N é lido do teclado:
Somatório = 1 + 6/3 +11/5 + 16/7 + ...
Declare cont, N: inteiro;
Total, denominador, numerador : real;
Inicio
Escreva ("Digite o número de termos N: ");
Leia (N);
total  0;
numerador 1;
denominador  1;
PARA cont de 1 ATÉ N FAÇA
total  total + ( numerador / denominador);
numerador  numerador + 5;
denominador  denominador + 2;
FIMPARA;
Fim.

3. Construir um algoritmo que monte a tabuada de um número escolhido pelo usuário:
Algoritmo tabuada;
Declare i, tab, num: inteiro;
INICIO
Escreva (“Tabuada do: ”)
Leia (tab);
Escreva (“Até o número: ”);
Leia (num);
PARA i de 1 ATÉ num FAÇA
Escreva (i, “ x ”, tab, “ = ”, i * tab);
FIMPARA;
FIM.
Figura 61 – Exemplo de Algoritmo Tabuada, usando PARA
4. Considere o seguinte problema: Deseja-se atualizar o preço de 30 produtos em 20%, temos:
Algoritmo atualizar_preco;
descricao : literal;
preco, n_preco : real;
INICIO
Escreva (“Este programa permite a atualização do preço em 20% de 30
produtos.”);
Escreva(“Descrição: “);
Leia (descricao);
Escreva(“Preço Atual: “);
Leia (preco);
n_preco  preco * 1.20;
Escreva(“O novo preço de “,descricao,” é = “, n_preco);
FIMPARA;
Fim.
Figura 62 – Algoritmo atualizar_preco, usando PARA

9 Comando de Repetição: Número Indefinido de Repetições e

Teste de Condição no Início
9.1 Comando de REPETIÇÃO ENQUANTO ... FAÇA
O comando de repetição ENQUANTO é utilizado quando não se sabe o número de vezes
que um conjunto de instruções deve ser repetido e o mínimo de repetições é zero, implicando que
as instruções dentro do ENQUANTO podem não ser executadas nenhuma vez. Os algoritmos
resolvidos com o comando PARA...FAÇA podem ser descritos com ENQUANTO...FAÇA.
Entretanto, nem sempre é possível transformar um algoritmo de ENQUANTO...FAÇA para num
algoritmo com PARA...FAÇA.
O teste de condição do comando ENQUANTO também fica no início de sua estrutura.

Assim, se a condição não for satisfeita logo na primeira comparação, nenhuma instrução dentro
da estrutura ENQUANTO será executada.
Figura 63 – Fluxograma de Comando Repetição ENQUANTO
A Figura 64 apresenta a sintaxe do comando ENQUANTO...FAÇA e a Figura 65 apresenta

um exemplo de seu uso.
ENQUANTO <condição> FAÇA

<comandos>;
FIMENQUANTO;
Figura 64 – Pseudocódigo do Comando de Repetição ENQUANTO

Exemplificando...
A Figura 65 apresenta um exemplo genérico do uso do comando ENQUANTO...FAÇA.

Sua utilização deve ser interpretada da seguinte forma. Enquanto uma condição for verdadeira,
por exemplo, “carro sujo”, o computador executará os comandos dentro do
ENQUANTO...FAÇA na ordem que aparece, uma linha de cada vez. Ao atingir a linha
FIMENQUANTO, o computador retorna para o ENQUANTO...FAÇA para verificar a condição.
Se a condição ainda for verdadeira, então os comandos serão repetidos. Se a condição não for
verdadeira, por exemplo, o carro estiver limpo, então o computador continua a execução do
programa na linha imediatamente após o FIMENQUANTO.
ENQUANTO carro sujo FAÇA

Molhe o pano na água e sabão;
Esfregue na parte suja;
Enxágue;
FIMENQUANTO;
Figura 65 – Exemplo genérico de Comando Repetição ENQUANTO
9.1.1 Peculiaridades Importantes do ENQUANTO..FAÇA
O comando ENQUANTO...FAÇA possui peculiaridades que, comumente, levam o

programador a erros por falta de atenção.
 Peculiaridade 1 – deve-se atribuir um valor inicial a variável/contador utilizada na

condição, podendo ser uma atribuição ou leitura. Infelizmente, muitos programadores
desatentos se esquecem de atribuir um valor inicial.
 Peculiaridade 2 - o contador ou variável utilizada na condição NÃO possui incremento

automático, por isto o programador deverá fazer o incremento manualmente. Portanto,
toda vez que utilizar o comando ENQUANTO...FAÇA, dentro dele deverá haver uma
linha contendo uma expressão matemática incrementando um valor ao contador variável.
 Peculiaridade 3 – A localização da linha de incremento dentro do ENQUANTO pode

impactar no resultado do algoritmo. Faça sempre o teste de mesa.

A Figura 66 apresenta um algoritmo que imprime na tela os valores de 1 a 10, aplicando o

comando de repetição ENQUANTO...FAÇA. Respeitando a peculiaridade 1, foi atribuído o
valor 1 a cont antes da condição do ENQUANTO. Caso não seja atribuído um valor inicial,
quando a linha “Enquanto (cont <=10) faça” for executada, cont não terá valor para ser
comparado com o número 10.
Como foi atribuído o valor 1 à cont, então pode-se afirmar que 1 é menor que 10, tornando
a condição verdadeira, implicando na execução das linhas de dentro do ENQUANTO. Logo,
seria impresso na tela a mensagem “o valor do contador é: 1”.
Na linha seguinte, atende-se a pecularidade 2 e cont é incrementado de 1, passando a valer

2. Na próxima linha, encontra-se o FIMENQUANTO que faz a execução mudar para a linha
“ENQUANTO (cont <=10) faça”. Nesta linha, como cont vale 2, pode-se afirmar que 2 é menor
que 10, tornando a condição verdadeira. Sendo a condição verdadeira, deve-se executar as linhas
dentro do ENQUANTO. Logo, seria impresso na tela a mensagem “o valor do contador é: 2”. Na
linha seguinte, atende-se a pecularidade 2 e cont é incrementado de 1, passando a valer 3.
Na próxima linha, encontra-se o FIMENQUANTO que faz a execução mudar para a linha
“ENQUANTO (cont <=10) faça”. Analogamente, continua-se a execução até cont ser
incrementado valer 10. Considerando que a condição é “(cont <= 10)” e 10 é igual a 10, então o
algoritmo escreve na tela “o valor do contador é: 10” e, na linha seguinte, acrescenta mais 1 a
cont, resultando no valor 1. Quando a execução retornar a condição com cont valendo 11, a
condição se tornará falsa e a execução passará para a primeira linha após o FIMENQUANTO,
imprimindo na tela “Saiu das repetições do ENQUANTO...FAÇA”.
Obrigatório atribuir valor

Algoritmo Escreve_ate_10; inicial ao contador
Inicio
cont  1;
ENQUANTO (cont <= 10) FAÇA
cont  cont + 1; Obrigatório adicionar
FIM-ENQUANTO;
algum valor ao
Escreva (“Saiu das repetições do
contador dentro do
ENQUANTO...FAÇA”);
Fim. ENQUANTO
Figura 66 – Algoritmo de Comando ENQUANTO...FAÇA Para Escreva de 1 a 10 na tela

A tela de saída após execução do algoritmo contido na Figura 66 será:

Saiu das repetições do ENQUANTO...FAÇA
Figura 67 – Tela De Saída Após Execução do Algoritmo da Figura 66
9.1.2 Loop Infinito
Define-se Loop infinito quando a execução entra num comando de repetição e não
consegue sair por erro no algoritmo, repetindo os comandos existentes dentro do laço
infinitamente. Por exemplo, na Figura 66, se o programador não escrevesse a linha “CONT
CONT + 1” dentro do ENQUANTO, então CONT teria sempre o mesmo valor. Portanto, como
CONT iniciou com o valor 1 e satisfaz a condição “(cont <= 10)”, então a execução entra no
comando ENQUANTO e nunca mais conseguirá sair.
Após escrever um algoritmo com ENQUANTO...FAÇA verifique se:
 As variáveis presentes na condição do ENQUANTO tem um valor inicial lido ou

atribuído antes da condição.
 Certifique-se que pelo menos uma variável da condição tem o valor
incrementado/decrementado dentro do comando ENQUANTO e que será possível sair da
repetição, evitando-se o loop infinito.
 O local onde ocorre o incremento/decremento está correto, evitando que possa ocorrer
uma repetição a mais ou a menos do projetado e/ou cálculos errados.

1. Faça um algoritmo que imprima na tela os números de 50 a 20.
Inicio
cont  50;
ENQUANTO ( cont >=20 ) FAÇA
cont  cont -1;
FIM-ENQUANTO;
Escreva (“Saiu das repetições do ENQUANTO...FAÇA”);
Fim
Figura 68 – Algoritmo que imprime de 50 a 20 aplicando ENQUANTO...FAÇA
2. Faça um algoritmo que leia nome, nota 1 e nota 2 de 20 alunos, e imprima na tela o nome do
aluno e a sua média.
Algoritmo Media_Aluno;
Declare cont : inteiro;
nome: literal;
n1, n2 : real;
Inicio
cont  1;
ENQUANTO (cont <= 20 ) FAÇA
Escreva ("Nome: ");
Leia (nome);
Leia (n1);
Leia (n2);
media  (n1+n2)/2;
cont  cont + 1;
FIM-ENQUANTO;
Fim.
Figura 69 – Exemplo de Algoritmo, usando Comando de Repetição ENQUANTO

3. Faça um algoritmo que imprima na tela o resultado do somatório de 1 até 10.
Algoritmo soma;
declare soma, i inteiro;
INICIO
soma  0;
i  1;
ENQUANTO i <= 10 FAÇA
soma  soma + i;
i  i + 1;
FIM-ENQUANTO;
Escreva (soma);
FIM.
Figura 70 – Algoritmo Soma usando ENQUANTO
4. Faça um algoritmo que imprima na tela o valor do somatório de 1 até N, sendo N um valor
fornecido pelo usuário.
Inicio
Leia (N);
total  0;
i  1;
ENQUANTO ( i <= N ) FAÇA
i  i + 1;
FIM-ENQUANTO;
Fim.
Figura 71 – Exemplo de Somatório de 1 a N usando Comando de Repetição ENQUANTO
5. Faça um algoritmo que calcule o somatório de todos os múltiplos de 3 de 1 até N, sendo N

um valor fornecido pelo usuário. Imprimir o total do somatório na tela.
Declare i, total, N: inteiro;
Inicio
Leia (N);
total  0;
i  0;
ENQUANTO ( i <= N ) FAÇA
i  i + 3;
FIM-ENQUANTO;

Escreva ("O somatório dos múltiplos de 3 de 1 até “, N, “ é: “,

total);
Fim.
Figura 72 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando ENQUANTO
6. Faça um algoritmo que calcule o somatório de N termos de fração, cujo denominador varia
de 5 em 5 e o denominador de 2 em 2. N é lido do teclado:
Somatório = 1 + 6/3 +11/5 + 16/7 + ...
total, denominador, numerador : real;
Inicio
Leia (N);
total  0;
numerador 1;
denominador  1;
cont  1;
ENQUANTO ( cont <= N ) FAÇA
cont  cont + 1;
FIM-ENQUANTO;
Fim.
Figura 73 – Exemplo de Somatório de 1 a N usando Comando de Repetição ENQUANTO
7. Faça um algoritmo que leia a senha de um usuário. O algoritmo somente deve permitir que o
usuário continue a executar o sistema se a senha digitada for correta, caso contrário, o
algoritmo deve pedir a senha ao usuário.
...
Escreva (“Digite a senha”);
Leia (senha);
ENQUANTO senha <> “xyz” FAÇA
Escreva (“Senha inválida”);
Escreva (“Digite a senha novamente”);
Leia (senha);
FIM-ENQUANTO;
Escreva (“Acertou a Senha”);
...
Figura 74 – Exemplo de Algoritmo, usando Comando de Repetição ENQUANTO

A Figura 74 apresenta um exemplo de algoritmo de ENQUANTO...FAÇA, o qual não é

possível fazê-lo com o comando PARA...FAÇA. Este algoritmo lê a senha de um usuário e
enquanto a senha estiver errada, o algoritmo fica preso no Loop solicitando nova senha. Portanto,
não é possível determinar quantas repetições ocorrem, sendo necessário o comando
ENQUANTO...FAÇA.
Neste exemplo, o usuário digita a senha, cuja primeira leitura está antes do
ENQUANTO...FAÇA, garantindo um valor inicial para que a senha possa ser comparada na
condição do ENQUANTO. Em seguida, a condição do ENQUANTO verifica se a senha é
diferente de “XYZ”. Se a senha digitada for diferente de “XYZ”, as linhas dentro do
ENQUANTO...FAÇA serão executadas. Essas linhas informam, nesta ordem, que a senha é
inválida e pede ao usuário digitá-la novamente.
Repare que enquanto a senha for diferente de “XYZ” o algoritmo ficará preso nestas
repetições e o usuário não conseguirá fazer mais nada no algoritmo. Quando o usuário digitar a
senha correta, a condição (senha <> “XYZ”) será falsa, e a execução continuará na linha
imediatamente após o FIM-ENQUANTO.

1. Faça um algoritmo que leia a descrição e preço de um produto. Atualize o preço em 30%
e escreva na tela a descrição e o novo preço. Caberá ao usuário a decisão de quantos
produtos deseja atualizar. Portanto, após cada entrada de dados e impressão na tela, o
algoritmo deve solicitar ao usuário a pressionar “S” ou “s” caso queira entrar com novo
produto para cálculo. O algoritmo deve parar a execução somente se o usuário não digitar
“S” e nem ”s”.
Declare resposta: caracter;
INICIO
Escreva (“Digite S para atualizar o preço ou N para sair”);
resposta  „S‟;
ENQUANTO ( resposta = „S‟ ) ou ( resposta = „s‟ ) FAÇA
Leia (descricao);
Leia (preco);
leia (resposta);
FIM-ENQUANTO;
FIM.
Figura 75 – Algoritmo atualizar_preco, usando ENQUANTO

2. Faça um algoritmo que leia 20 números inteiros positivos e imprima na tela o maior.
Declare i, num, maior : inteiro;
INICIO
i  1;
maior  -1;
ENQUANTO ( i <=20 ) FAÇA
Escreva(“Digite um número: “);
Leia (num);
Se ( num > maior ) então
maior  num;
Fim-se;
i  i + 1;
FIM-ENQUANTO;
Escreva (“O maior número digitado é ”, maior);
FIM.
Figura 76 – Algoritmo Imprimir Maior Número usando ENQUANTO

10 Comando de Repetição: Número Indefinido de Repetições e

Teste de Condição no Final
10.1 Comando de repetição REPITA ... ATÉ
O comando de repetição REPITA...ATÉ é utilizado quando não se sabe o número de vezes
que um conjunto de instruções deve ser repetido e o mínimo de repetições é um (1), implicando
que as instruções dentro do REPITA...ATÉ são executadas pelo menos uma vez. Os algoritmos
resolvidos com o comando PARA...FAÇA ou ENQUANTO podem ser descritos com
REPITA...ATÉ, desde que aqueles o código dentro do REPITA tenha de ser executado pelo
menos uma vez. Nem sempre será possível transformar um algoritmo REPITA...ATÉ num
comando PARA...ATÉ.
O teste de condição do comando REPITA fica no fim de sua estrutura. Assim, primeiro
executa-se um conjunto de instruções e, somente depois, realiza-se o teste de condição. Se a
condição for falsa, o fluxo de programa retorna para a linha da instrução REPITA e repete os
comandos descritos dentro do REPITA...ATÉ. Se a condição for verdadeira, o fluxo do
programa sai da estrutura REPITA...ATÉ e continua a execução na primeira linha,
imediatamente, após a cláusula ATÉ.
Figura 77 – Fluxograma de Comando Repetição REPITA

A Figura 78 apresenta a sintaxe do comando REPITA...ATÉ e a Figura 79 apresenta um

exemplo de seu uso.
REPITA
<instruções>;
ATÉ <condição>;
Figura 78 – Pseudocódigo do Comando de Repetição REPITA
10.1.1 Peculiaridades Importantes do REPITA ... ATÉ
O comando REPITA ... ATÉ possui peculiaridades que, comumente, levam o programador
a erros por falta de atenção.
 Peculiaridade 1 – deve-se atribuir um valor inicial a variável/contador utilizada na

condição, podendo ser uma atribuição ou leitura. Infelizmente, muitos programadores
desatentos se esquecem de atribuir um valor inicial.
 Peculiaridade 2 - o contador ou variável utilizada na condição NÃO possui incremento

automático, por isto o programador deverá fazer o incremento manualmente. Portanto,
toda vez que utilizar o comando REPITA...ATÉ, dentro dele deverá haver uma linha
contendo uma expressão matemática incrementando um valor ao contador variável.
 Peculiaridade 3 – A localização da linha de incremento dentro do REPITA pode

impactar no resultado do algoritmo. Faça sempre o Teste de Mesa.
 Peculiaridade 4 – A condição do REPITA...ATÉ é o complemento da condição do

ENQUANTO...FAÇA. Assim,
Se a condição do ENQUANTO for “X < > 15” então o complemento é “X = 15”.
Se a condição do ENQUANTO for “X >= 10”, o complemento é “X <10”.
Se a condição do ENQUANTO for “X < 10”, o complemento é “X >=10”.
A Figura 79 apresenta um algoritmo que imprime na tela os valores de 1 a 10, aplicando o

comando de repetição REPITA...ATÉ.
Respeitando a peculiaridade 1, foi atribuído o valor 1 a CONT. Na sequencia, executa-se a

linha REPITA, é impresso na tela “o valor do contador é: 1” e CONT é incrementado de 1,
passando a valer 2.
Em seguida, atinge-se a linha da condição “ATÉ (cont > 10)”. Como CONT vale 2, então
ele não é maior que 10, fazendo com que a execução volte para a linha REPITA. É impresso na
tela “o valor do contador é: 2” e CONT é incrementado de 1, passando a valer 3.

Logo após, atinge-se a linha da condição “ATÉ (cont > 10)”. Como CONT vale 3, então
ele não é maior que 10, fazendo com que a execução volte para a linha REPITA.
Analogamente, continua-se a execução, sucessivamente, até que CONT valha 11, tornando
a condição “ATÉ (cont > 10)” verdadeira.
Quando CONT torna-se maior que 11 o programa continua a execução na linha

imediatamente abaixo de “ATÉ (cont > 10)”, imprimindo na tela a mensagem “Saiu das
repetições do REPITA...ATÉ”.
Algoritmo Escreve_ate_10;
Obrigatório atribuir
Declare cont: inteiro; valor inicial ao contador
Inicio
cont  1;
REPITA
Obrigatório adicionar
cont  cont + 1;
algum valor ao
ATÉ ( cont > 10 );
Escreva (“Saiu das repetições do REPITA...ATÉ”); contador dentro do
Fim. REPITA
Figura 79 – Algoritmo de Comando ENQUANTO...FAÇA Para Escreva de 1 a 10 na tela
Exemplificando...
escreva ( “o valor do contador é: ”, cont ); cont  cont +1 ATÉ (CONT >10)

o valor do contador é: 1 1+1=2 2 é > 10 ? NÃO
o valor do contador é: 9 9 + 1 = 10 10 é > 10 ? NÃO
o valor do contador é: 10 10 + 1 = 11 11 é > 10 ? SIM
Saiu das repetições do REPITA.
Figura 80 – Teste de Mesa do trecho REPITA ... ATÉ

A tela de saída após execução do algoritmo contido na Figura 66 será:

Saiu das repetições do REPITA.
Figura 81 – Tela De Saída Após Execução do Algoritmo da Figura 66
10.1.2 Loop Infinito
Se o programador se esquecer de inserir uma linha variando o valor da variável que está na
condição ATÉ, o algoritmo entra em Loop infinito dentro do comando REPITA...ATÉ.
Após escrever um algoritmo com REPITA...ATÉ verifique se:
 Os comandos dentro do REPITA realmente poderão ser executados pelo uma vez
mesmo que a condição não seja satisfeita.
 As variáveis presentes na condição do REPITA tem um valor inicial lido ou atribuído
antes de chegar na condição.
 Certifique-se que pelo menos uma variável da condição tem o valor

incrementado/decrementado dentro do comando REPITA e que será possível sair da
repetição, evitando-se o Loop Infinito.
 O local onde ocorre o incremento/decremento está correto, evitando que possa ocorrer
uma repetição a mais ou a menos do projetado e/ou cálculos errados.

Exemplificando...
Faça um algoritmo que imprima na tela os números de 50 a 20.
Inicio
cont  50;
REPITA
cont  cont -1;
ATÉ ( cont < 20 );
Escreva (“Saiu das repetições do REPITA...ATÉ”);
Fim
Figura 82 – Algoritmo que imprime de 50 a 20 aplicando REPITA...ATÉ
Observe que o teste da condição “cont < 20” é executado somente após a execução dos
comandos dentro do REPITA...ATÉ. O fluxo do programa repetirá os comandos dentro do
REPITA...ATÉ sempre que a condição for falsa. Quando a condição for verdadeira o fluxo é
desviado para a primeira linha imediatamente após a cláusula ATÉ.

1. Faça um algoritmo que leia nome, nota 1 e nota 2 de 20 alunos, e imprima na tela o nome
do aluno e a sua média.
nome: literal;
n1, n2 : real;
Inicio
cont  1;
REPITA
Escreva ("Nome: ");
Leia (nome);
Leia (n1);
Leia (n2);
media  (n1+n2)/2;
cont  cont + 1;
ATÉ ( cont > 20 );
Fim.
Figura 83 – Exemplo de Algoritmo, usando Comando de Repetição REPITA...ATÉ
2. Faça um algoritmo que imprima na tela o resultado do somatório de 1 até 10.
Algoritmo soma;
declare soma, i: inteiro;
INICIO
soma  0;
i  1;
REPITA
soma  soma + i;
i  i + 1;
ATÉ ( i > 10 );
Escreva (soma);
FIM.
Figura 84 – Algoritmo Soma, usando REPITA...ATÉ

3. Faça um algoritmo que imprima na tela o valor do somatório de 1 até N, sendo N um

valor fornecido pelo usuário.
Inicio
Leia (N);
total  0;
i  1;
REPITA
i  i + 1;
ATÉ ( i > N );
Fim.
Figura 85 – Exemplo de Somatório de 1 a N usando Comando de Repetição REPITA...ATÉ
4. Faça um algoritmo que calcule o somatório de todos os múltiplos de 3 de 1 até N, sendo

N um valor fornecido pelo usuário. Imprimir o total do somatório na tela.
Declare i, total, N: inteiro;
Inicio
Leia (N);
total  0;
i  0;
REPITA
i  i + 3;
ATÉ ( i > N );
total);
Fim.
Figura 86 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando REPITA...ATÉ

5. Faça um algoritmo que calcule o somatório de N termos de fração, cujo denominador

varia de 5 em 5 e o denominador de 2 em 2. N é lido do teclado:
Somatório = 1 + 6/3 +11/5 + 16/7 + ...
total, denominador, numerador : real;
Inicio
Leia (N);
total  0;
numerador 1;
denominador  1;
cont  1;
REPITA
cont  cont + 1;
ATÉ ( cont > N );
total);
Fim.
Figura 87 – Exemplo de Somatório de 1 a N usando Comando de Repetição REPITA...ATÉ
6. Faça um algoritmo que leia a senha de um usuário. O algoritmo somente deve permitir
que o usuário continue a executar o sistema se a senha digitada for correta, caso
contrário, o algoritmo deve pedir a senha ao usuário.
...
Escreva (“Digite a senha”);
REPITA
Escreva (“Senha inválida”);
Escreva (“Digite a senha novamente”);
Leia (senha);
ATÉ (senha = “xyz”);
Escreva (“Acertou a Senha”);
...
Figura 88 – Exemplo de Algoritmo, usando Comando de Repetição REPITA...ATÉ

7. Faça um algoritmo que leia a descrição e preço de um produto. Atualize o preço em 30%
e escreva na tela a descrição e o novo preço. Caberá ao usuário a decisão de quantos
produtos deseja atualizar. Portanto, após cada entrada de dados e impressão na tela, o
algoritmo deve solicitar ao usuário a pressionar “S” ou “s” caso queira entrar com novo
produto para cálculo. O algoritmo deve parar a execução somente se o usuário não digitar
“S” e nem ”s”.
Declare resposta: caracter;
INICIO
resposta  „S‟;
REPITA
Leia (descricao);
Leia (preco);
leia (resposta);
ATÉ (resposta = „N‟) ou (resposta = „n‟)
FIM.
Figura 89 – Algoritmo atualizar_preco, usando REPITA
8. Faça um algoritmo que leia 20 números inteiros positivos e imprima na tela o maior.
Declare i, num, maior : inteiro;
INICIO
i  1;
maior  -1;
REPITA
Escreva(“Digite um número: “);
Leia (num);
Se ( num > maior ) então
maior  num;
Fim-se;
i  i + 1;
ATÉ ( i > 20 );
Escreva (“O maior número digitado é ”, maior);
FIM.
Figura 90 – Algoritmo Imprimir Maior Número usando ENQUANTO

Compare a seguir o uso das Estruturas de Repetição aprendidas:

Usando o ENQUANTO: Faça um algoritmo que leia 50 números fornecidos pelo usuário,
calcule e exiba a média.
Algoritmo media;
Declare soma, num, media: real;
cont : inteiro;
INICIO
soma  0;
cont  1;
ENQUANTO cont <= 50 FAÇA
leia (num);
soma  soma + num;
cont  cont + 1;
Media  soma / cont ;
FIMENQUANTO;
Escreva(“A média dos números digitados é: “, media);
FIM.
Usando o REPITA: Faça um algoritmo que leia 50 números fornecidos pelo usuário,
calcule e exiba a média.
Algoritmo media;
cont : inteiro;
INICIO
soma  0;
cont  1;
REPITA
leia (num);
cont  cont + 1;
ATÉ cont > 50;
FIM.

Usando o PARA: Faça um algoritmo que leia 50 números fornecidos pelo usuário, calcule
e exiba a média.
Algoritmo media;
cont : inteiro;
INICIO
soma  0;
PARA cont de 1 ATÉ 50 FAÇA
leia (num);
FIMPARA;
FIM.


1) Usando os comandos REPITA, ENQUANTO e PARA, construa um algoritmo que dado
um número inteiro (entre 1 e 10), apresente a tabuada deste número.
2) Usando os comandos REPITA, ENQUANTO e PARA, construa um algoritmo para
calcular a fatorial de um número. (exemplo: o fatorial de 5! = 1*2*3*4*5 = 120).
3) Usando os comandos REPITA, ENQUANTO e PARA, construa um algoritmo que leia
10 valores inteiros, ache e mostre o maior valor.
4) Uma empresa de marketing fez uma pesquisa de mercado para saber se as pessoas
gostaram ou não de um produto lançado no mercado. Os entrevistados informavam o
sexo e a resposta Sim ou Não. Sabendo-se que foram entrevistadas N pessoas, fazer um
algoritmo que calcule e exiba:
a) A qde de pessoas que responderam sim;
b) A qde de pessoas que responderam não;
c) A porcentagem de pessoas do sexo feminino que responderam sim; e
d) A porcentagem de pessoas do sexo masculino que responderam não.
5) Uma empresa decidiu fazer um recrutamento para preencher algumas vagas. Os
candidatos serão cadastrados por computador. Faça um algoritmo para:
a) Leia o número do candidato, a idade e o sexo, a experiência profissional (SIM /
NÃO);
b) Mostrar a idade média dos candidatos;
c) Mostrar o número total de candidatos e candidatas; e
d) Mostrar os candidatos (homens e mulheres) maiores de idade que tenham experiência
no profissional.
6) Construa um algoritmo que calcule a série descrita a seguir para um número de termo
informado pelo usuário via teclado. (12 + 1)/1 + (22 + 1)/3 + (32 + 1)/5 + (42 + 1)/7 + ...
7) Construa um algoritmo que calcule os 20 primeiros termos da Série de Fibonacci. A série

é formada começando-se com 0 e 1, a seguir, obtém-se o próximo número de Fibonacci
somando-se os dois anteriores e, assim, sucessiva e infinitamente. Exemplo da seqüência
de Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, .... Faça o Teste de Mesa do algoritmo.

11 VARIÁVEIS COMPOSTAS HOMOGÊNEAS: VETORES E

MATRIZES
Os Comandos de Repetições vistos mostraram-se úteis para evitar trabalhos repetitivos,
delegando para o computador a repetição automática de trechos de código. Porém, há problemas
que o comando de repetição não elimina a solução repetitiva braçal.
Na Figura 91 apresenta-se um algoritmo que lê o nome, a nota 1 e a nota 2 de 20 alunos, e
imprime na tela o nome do aluno e a sua média.
nome: literal;
n1, n2 : real;
Inicio
cont  1;
REPITA
Escreva ("Nome: ");
Leia (nome);
Leia (n1);
Leia (n2);
media  (n1+n2)/2;
cont  cont + 1;
ATÉ ( cont > 20 );
Fim.
Figura 91 – Algoritmo Media_Aluno, usando Comando de Repetição REPITA...ATÉ
Uma pequena variação na saída do algoritmo pode torná-lo bem mais complexo. Por
exemplo, se fosse solicitado um algoritmo que lesse o nome, a nota 1 e a nota 2 de 20 alunos, e
imprimisse na tela a média geral dos alunos e depois o nome, notas e média de cada aluno.
Neste caso, o Comando de Repetição não seria suficiente para resolver o problema. Seria
necessário declarar várias variáveis para armazenar todos os nomes e notas, para calcular e
imprimir a média geral e os dados digitados no final. Uma possível solução considerando apenas
3 alunos seria:
Algoritmo Media_Geral;
Declare n1,n2,n3,n4,n5,n6, Media, MediaGeral: real;
nome1, nome2, nome3: literal;
Inicio
Escreva(“Nome: ”);
Leia(nome1);
Escreva(“Nota 1: ”);
Leia(n1);

Leia(n2);
Leia(nome2);
Leia(n3);
Leia(n4);
Leia(nome3);
Leia(n5);
Leia(n6);
MediaGeral  (n1+n2+n3+n4+n5+n6)/6;
Escreva(“A Média Geral é ”, MediaGeral);
Media  (n1+n2)/2;
Escreva(nome1, n1, n2, Media);
Media  (n3+n4)/2;
Media  (n5+n6)/2;
FIM.
Figura 92 – Algoritmo Media_Geral, usando Comando de Repetição REPITA...ATÉ
Observa-se a necessidade de repetir a declaração da variável para guardar as notas dos

alunos, bem como seus nomes. Quando se declara variáveis do tipo inteiro, real, caractere,
dentre outros, apenas um valor pode ser armazenado em cada variável. Porém, existem
problemas que exigem Estrutura de Dados Compostas.
Até aqui, apresentaram-se declarações e atribuições de variáveis utilizando Tipos de Dados

Básicos, com variáveis simples: real, inteiro, literal, caractere e lógico. Entretanto, haverá
situações em que estes Tipos de Dados não serão suficientes para solução de problemas e será
necessário utilizar Estruturas de Dados diferentes dos Tipos Básicos.
No caso da estrutura Vetor e Matriz, pode-se armazenar diversos dados de um mesmo tipo
em uma única variável. O fato de armazenar dados do mesmo tipo, somente inteiro ou somente
real ou somente lógico etc, dá aos vetores e matrizes a classificação de Estruturas de Dados
Homogêneas (homogênea quer dizer do mesmo tipo de dado).
Como mostrado a seguir, classifica-se este tipo de estrutura em Vetores (unidimensionais) e

Matrizes (bidimensionais).

12 VETORES
Considere o algoritmo apresentado na Figura 93 que solicita ao usuário a entrada dos nomes
de 20 alunos e os imprime na tela na medida em que o dado é digitado.
Algoritmo nomes_alunos;
Declare nome: literal;
i : inteiro;
INICIO
Escreva ("Digite o nome do aluno ",i,":");
Leia (nome);
Escreva ("Aluno", i, “: “, nome);
FIMPARA;
FIM.
Figura 93 – Exemplo de Algoritmo usando Comando de Repetição REPITA
Porém, se pedir para leia o nome de 20 alunos e depois de lido todos, imprimi-los na tela,
não haveria solução com o que foi aprendido até o momento, a não ser que se declarasse 20
variáveis para nome.
O algoritmo da Figura 94 mostra claramente esta limitação. Ele lê 20 nomes de alunos um
a um, conforme o usuário os digita. Neste caso usamos apenas de uma variável inteira que serve
como contador (i) e uma variável do tipo literal para armazenar o nome.
O nome do aluno é digitado, armazenado na variável nome, exibido ao usuário, e a variável
é liberada para armazenar o próximo nome de aluno. Se você solicitar ao programa que exiba o
conteúdo da variável nome após o comando PARA, verá que somente o último nome digitado
será exibido.
Faça o teste. Insira o comando Escreva ("Nome do Aluno: ", nome) após o comando
FIMPARA.
Declare nome : literal;
i : inteiro; // declaração do contador
INICIO
Escreva ("Digite o nome do aluno ",i,":");
Leia (nome);
Escreva ("Aluno", i, “: “, nome);
FIMPARA;
FIM.
Escreva ("Nome do Aluno: ", nome); /* apresentará somente o último
nome de aluno digitado, que corresponde ao último valor armazenado na
variável nome. */
Figura 94 – Algoritmo nomes_alunos

Para que todos os nomes de alunos digitados sejam exibidos é preciso armazená-los em
uma estrutura de dados. Neste caso utiliza-se uma estrutura de dados homogênea
unidimensional, o vetor.
Um vetor é uma variável formada por vários espaços na memória, todos do mesmo tipo,
com o mesmo identificador (mesmo nome) e alocadas sequencialmente na memória.
12.1 Representação Gráfica de um Vetor

A representação gráfica de um vetor com espaço para guardar 5 valores, V[5], é:
V[1] V[2] V[3] V[4]

V[5]
V=
índices
1 2 3 4 5
Figura 95 – Representação Gráfica de um Vetor
A Figura 95 apresenta um vetor chamado V, que possui cinco posições. Pode-se armazenar
cinco valores neste vetor. Cada posição é representada pelo seu índice. Assim, para saber o valor
armazenado na primeira posição basta escreva V[1], na segunda posição, V[2], e assim
sucessivamente. Os números abaixo do vetor de 1 a 5 são denominados de índices e identificam
qual posição deseja-se manipular.
12.2 Declaração de Vetor

A declaração de um vetor em pseudocódigo segue a seguinte sintaxe:
Algoritmo teste;
Declare <nome da variável>[tamanho]: tipo;
...
INICIO
<comandos>;
FIM.
Figura 96 – Declaração de Vetor em pseudocódigo
Onde: nome é o nome da variável tipo vetor, tamanho é a quantidade de dados que será
armazenada na variável e tipo é o tipo de dado que poderá ser armazenado.

Exemplificando...
Declarando um vetor V do tipo inteiro de 5 posições.
Algoritmo teste;
Declare V[5]: inteiro;
...
INICIO
<comandos>;
FIM.
Figura 97 – Exemplo de Declaração de um Vetor de 5 posições do tipo inteiro
Declarou-se na Figura 97 um vetor chamado V com 5 posições e em cada posição pode-se

armazenar um inteiro.
12.3 Manipulação de Dados de um Vetor

Para inserir, calcular, modificar um valor em um Vetor é preciso escolher (identificar) um
índice e informar o valor que será colocado naquela posição indicada pelo índice. Veja alguns
exemplos:
V[1] ← 23; // Atribui o valor 23 para a primeira posição do vetor
V[5] ← -4; // Atribui o valor -4 para a quinta posição do vetor
V[3] ← V[1] + V[5]; // Soma os valores da posição 1 e da posição 5, guardando na posição 3
Após a execução destas três linhas acima, o vetor ficaria com a seguinte configuração:
V= 23 19 -4
1 2 3 4 5
O índice é um valor numérico do tipo inteiro, começando em 1 e cada valor corresponde a

uma posição do vetor.
12.4 Operações de Entrada e Saída de dados em um Vetor

Voltando ao nosso exemplo da Figura 94. Para que algoritmo armazene e exiba todos os 20
nomes de alunos, precisamos de um Vetor de tamanho 20 e que possa receber dados do tipo
literal.

A declaração desse nosso Vetor ficará assim:
...
Declare nome [20]: literal;
...
nome[1]
nome= Ana José Luiz Antonio Paula Bia

1 2 3 4 5 ... ... 20
Figura 98 – Vetor nome de 20 posições do tipo literal
Para Entrada de Dados em um vetor é preciso utilizar um comando de repetição como o

PARA, veja Figura 99. Observe que dentro do comando Leia coloca-se o nome do vetor seguido
de colchetes “[ ]” e o contador i usado no PARA.
A primeira vez que o comando Leia for executado i valerá 1, implicando que o valor
digitado pelo usuário ficará na posição 1 do vetor, analogamente os valores serão lidos e
colocados um após o outro até a posição 20.
Exemplificando...
Declare nome [20]: literal; /* trocamos a variável nome: literal por um
vetor de tamanho 20 do tipo literal */
i : inteiro;
Entrada dos
INICIO
dados Escreva ("Entre com o nome dos Alunos”);
Saída dos Escreva ("Aluno ", i, ":"); //solicita os nomes dos alunos um a um
Leia (nome[ i ]); //os dados são armazenados um a um, no vetor
dados FIMPARA;

Escreva (“Aluno: ”, nome[ i ]); /* todos os nomes armazenados no
vetor nome serão exibidos */
FIMPARA;
FIM.
Figura 99 – Algoritmo nomes_alunos utilizando Vetor, entrada e saída de dados
Para exibir (Saída) dados o procedimento é o mesmo, utiliza-se outro comando PARA e
no comando Escreva coloca-se o nome do vetor seguido de “[ ]” e o contador i usado no PARA.

O mesmo raciocínio é válido para guardar a nota 1 e nota 2 de cada aluno, bastando criar
um vetor de 20 posições para Nota1 e outro de 20 posições para Nota2. Deste modo, é possível
armazenar todos os valores digitados pelo usuário.
12.5 Processamento dos Dados de um Vetor

Um exemplo de processamento dos dados de um vetor seria multiplicar todos os valores
de um vetor de 10 posições pelo número 3. Deve-se utilizar o comando PARA, a fim de
processar todos os valores como mostrado no algoritmo da Figura 100:
Exemplificando...
Algoritmo Mult_tres;
Declare Num[10]: inteiro;
i : inteiro;
INICIO
Escreva ("Entre com os valores”);
PARA i de 1 ATÉ 10 FAÇA Processamento dos
Escreva ("Valor ", i, ":");
dados
Leia (Num[ i ]);
FIMPARA;

Num[i]  Num[i] * 3; // multiplica cada valor por três, guardando o resultado no próprio vetor.
FIMPARA;
Saída dos
Escreva (“Valor: ”, Num[ i ]); dados
FIMPARA;
FIM.
Figura 100 – Algoritmo nomes_alunos utilizando Vetor, processando dados


1) O algoritmo da Figura 54 lê as notas e calcula a média de 20 alunos. Altere-o para que
armazene e exiba o nome, as duas notas de cada aluno e sua média.
2) Faça um algoritmo que leia um vetor de 20 posições e uma variável inteira A. A seguir,
mostre o produto da variável A por cada valor do vetor.
3) Faça um algoritmo que leia dois vetores: F[20] e G[20]. Calcule e mostre, a seguir, a soma
dos valores de F com G, guardando o resultado em um 3º vetor H.
4) Faça um algoritmo que leia dois vetores: F[20] e G[20]. Calcule e mostre, a seguir, a soma
dos valores de F com G, guardando o resultado no vetor F.
5) Faça um algoritmo que leia um vetor de tamanho 20 e inverta seus elementos, trocando o
1º elemento com o último, o 2º elemento com o penúltimo. Mostre o vetor invertido.
6) Faça um algoritmo que leia um vetor de tamanho 6, conte quantos valores deste vetor são
negativos e mostre essa informação.
7) Faça um algoritmo que leia um vetor de 10 posições, substitua todos os valores iguais a
zero por 1 e escreva o vetor resultante.
8) Faça um algoritmo que leia um vetor de 20 posições e uma variável inteira A. Imprima na
tela “achou” se o valor A existe no vetor, e “não achou” se o valor não foi encontrado.
9) Faça um algoritmo que leia um vetor de 20 posições e uma variável inteira A. Imprima na
tela a(s) posição(ões) em que o valor A foi encontrado no vetor.

13 MATRIZES
Vimos que uma estrutura capaz de armazenar diversos dados de um mesmo tipo em uma
única variável é considerada uma Estrutura de Dados Homogênea, lembrando que homogênea
quer dizer do mesmo tipo de dado. E classificamos este tipo de estrutura em Vetores
(unidimensionais), visto na seção anterior, e Matrizes (bidimensionais).
Uma Matriz é uma Estrutura de Dados Homogênea Bidimensional que permite

armazenar diversos dados de um mesmo tipo em uma única variável. Este tipo de estrutura tem
sua principal utilização vinculada à criação de tabelas. E por se relacionar diretamente com a
utilização de tabelas, a matriz mais comum é a de duas dimensões (linha e coluna).
13.1 Representação Gráfica de uma Matriz

A representação gráfica de uma Matriz segue o formato de tabela. Para acessar um
elemento desta Matriz devemos fornecer o nome da matriz e o índice da linha e da coluna do
elemento desejado (um número de 1 a 5 para a linha e um número de 1 a 10 para a coluna, neste
caso).
Exemplificando...
Representação de uma Matriz M 5X10 da Figura 103:
M[1,1] M[1,2] M[1,10]
M 1
M[5,1] 5
M[5,10]
1 2 3 4 5 6 7 8 9 10
Figura 101 – Representação de uma Matriz 5X10
Onde:
 M[1,1] indica o primeiro elemento da primeira linha da matriz M;

 M[1,2] indica o segundo elemento da primeira linha da matriz M;
 M[1,10] indica o décimo elemento da primeira linha da matriz M; e
 M[5,10] indica o décimo elemento da última linha da matriz M.

13.2 Declaração de Matriz

As dimensões de uma matriz são representadas por valores inteiros positivos referentes às
linhas e colunas. A declaração de uma matriz em pseudocódigo segue a seguinte sintaxe:
Algoritmo teste;
Declare < nome da variável > [ <nº de linhas>, <nº de colunas>] : tipo;
...
INICIO
<comandos>;
FIM.
Figura 102 – Declaração de matriz em pseudocódigo
Exemplificando...
Declarando uma matriz M do tipo inteiro de 5 linhas e 10 colunas (5X10).
Algoritmo teste;
Declare M [5 , 10] : inteiro;
...
INICIO
<comandos>;
FIM.
Figura 103 – Exemplo de Declaração de uma Matriz 5X10 do tipo inteiro
Como no vetor o acesso a cada elemento de uma matriz é feito pela especificação de sua
posição por meio do seu índice.
Na Figura 103 apresenta a declaração de uma matriz M com 5 linhas e em cada linha 10
colunas que podem armazenar valores inteiros. No total, a matriz M pode armazenar 50 valores
inteiros.

Exemplificando...
Declarando vetor e matrizes de diferentes dimensões.
Algoritmo teste;
Declare A [4] : Inteiro;
B [20 , 4] : Inteiro;
C [5, 20 , 4] : Inteiro;
D [2 ,5, 20 , 4] : Inteiro;
E [3 , 2 , 5, 20 , 4] : Inteiro;
F [2 ,3 , 2 , 5, 20 , 4] : Inteiro;
...
INICIO
<comandos>;
FIM.
Figura 104 – Declaração de Matrizes de diferentes dimensões
No exemplo da Figura 104, cada estrutura pode ser utilizada para armazenar informações
como:
 No Vetor A pode se armazenar 4 notas de um aluno (vetor possui 1 dimensão sempre);
 Na Matriz B pode se armazenar 4 notas de 20 alunos;
 Na Matriz C pode se armazenar 4 notas de 20 alunos em 5 disciplinas;
 Na Matriz D pode se armazenar 4 notas de 20 alunos em 5 disciplinas, para 2 turmas;
 Na Matriz E pode se armazenar 4 notas, de 20 alunos em 5 disciplinas, para 2 turmas

de 3 cursos; e
 Na Matriz F pode se armazenar 4 notas de 20 alunos em 5 disciplinas para 2 turmas,

de 3 cursos, de 2 campus.

13.3 Manipulação de Dados de uma Matriz

Para inserir, calcular, modificar um valor em uma Matriz é preciso escolher (identificar) a
linha e coluna no qual o valor será inserido. Veja alguns exemplos de atribuição de valores a
Matriz M na Figura 105:
...
M[1,1]  24;
M[1,10]  3;
M[2,6]  14;
M[3,5]  44;
M[5,9]  M[1,1] + M[2,6];
...
Figura 105 – Atribuição de valores a Matriz M
Representação da Matriz M após atribuição de valores:
M 1 24 3
2 14
3 44
4
5 38
1 2 3 4 5 6 7 8 9 10
Figura 106 – Representação de uma Matriz 5X10
13.4 Operações de Entrada e Saída de dados em uma Matriz

Utiliza-se 2 (dois) comandos PARA aninhados/encadeados para Entrada e Saída de dados,
em cada estrutura PARA lendo um determinado elemento da Matriz.
Exemplificando...

Algoritmo entrada_matriz;
Entrada dos Declare num [3, 5] : inteiro;
dados i, j : inteiro;
INICIO
PARA j de 1 ATÉ 5 FAÇA
Escreva ("Digite os valores da posição[ ",i, " e “ ,j, “]:");
Leia (num[ i, j ];
FIMPARA;
FIMPARA;
FIM.
Figura 107 – Entrada de dados em uma Matriz 3X5
Teste de mesa da entrada de dados do algoritmo da Figura 107:

Na memória Na memória
Na tela
i j Valor digitado
1 1 Digite os valores da posição[ 1 e 1]: 13
2 Digite os valores da posição[ 1 e 2]: 24000
4 Digite os valores da posição[ 1 e 4]: -5
2 1 Digite os valores da posição[ 2 e 1]: -6
3 1 Digite os valores da posição[ 3 e 1]: 23

Representação da Matriz num após atribuição de valores:
num 1 13 24000 2 -5 48
2 -6 0 100 -27 154
3 23 1 5 87 -51
1 2 3 4 5
Figura 108 – Representação da Matriz num após atribuição de valores
Algoritmo entrada_e_saida_matriz;
Declare num [3, 5] : inteiro;
i, j : inteiro;
INICIO
Leia (num[ i, j ]);
FIMPARA;
Saída dos
FIMPARA;
dados
Escreva(num[ i , j ]);
FIMPARA;
FIMPARA;
FIM.
Figura 109 – Entrada e Saída de dados em uma Matriz 5X10
Teste de mesa da saída dos dados do algoritmo da Figura 109:
Na tela
13
24000
2
-5
48
-6
0
100
-27
154
23
1
5
87
-51

13.5 Processamento dos Dados de uma Matriz

Um exemplo de processamento dos dados de uma Matriz seria somar o número 100 à
todos os valores de uma Matriz 5X10 (de 5 linhas por 10 colunas). Também deve-se utilizar 2
(dois) comandos PARA, a fim de processar todos os valores como mostrado no algoritmo da
Figura 110:
Exemplificando...
Elaborar um algoritmo para leia uma matriz NUM de 5 linhas por 10 colunas de inteiros. Depois
somar 100 a cada valor da matriz.
Algoritmo Soma_100;
Declare Num[5, 10] ,i ,j : inteiro;
INICIO
Escreva ("Entre com os valores”);
// Lê os valores da matriz
Leia (Num[ i, j ];
Processamento FIMPARA;
FIMPARA;
dos dados
// Soma o número 100 a cada valor armazenado
Num[ i, j]  Num[ i, j] + 100;
FIMPARA;
FIMPARA;
// Imprime a saída
Escreva(“Posição[ “, i , “ “, j, “]:”, Num[ i, j] );
FIMPARA;
FIMPARA;
FIM.
Figura 110 – Algoritmo para somar número 5 a cada posição de uma matriz [5,10]

1) Elaborar um algoritmo para leia uma matriz MAT de 3 linhas por 5 colunas de inteiros.
Depois somar os elementos da 2ª linha e armazenar em uma variável A, multiplicar os
elementos da 3ª coluna e armazenar em uma variável B.
Algoritmo matriz_com_soma_e_multipli;
Declare mat[3,5], i, j, A, B: inteiro;
INÍCIO
Leia (mat [i,j] );
FIMPARA;
FIMPARA;
Escreva ("Exibindo os valores digitados na matriz:");

Escreva (mat [i,j] );
FIMPARA;
FIMPARA;
A  0;
B  1;
PARA j de 1 ATÉ 5 FAÇA // fixando a linha 2
A  A + mat [2,j];
FIMPARA;
PARA i de 1 ATÉ 3 FAÇA // fixando a coluna 3

B  B * mat [i,3];
FIMPARA;
Escreva (“A soma dos elementos da Linha 2 é= ”, A);

Escreva (“A multiplicação dos elementos da Coluna 3 é= ”, B);
FIM.
Figura 111 – Algoritmo para somar os elementos da linha 2 e multiplicar os elementos da coluna 3
2) Elaborar um algoritmo para leia uma Matriz 5x5 de inteiros, encontrar o maior valor
armazenado nela e multiplicar este valor pela matriz lida.
Algoritmo acha_maior_mult;
Declare M[5,5], RES[5,5], i, j, maior: inteiro;
INÍCIO


Leia (M [ i, j ] );
FIMPARA;
FIMPARA;
maior  M [1,1];

SE M [ i, j ] > maior ENTÃO
maior  M [ i, j ];
FIMSE;
FIMPARA;
FIMPARA;
Escreva (“O maior valor da matriz digitada é: “, maior);
Escreva (“Multiplicando o maior valor encontrado pela matriz...”);

RES [ i, j ]  maior * M [ i, j ] ;
FIMPARA;
FIMPARA;
Escreva (“A matriz resultante é: “);

Escreva (RES [ i, j ]);
FIMPARA;
FIMPARA;
FIM.
Figura 112 – Algoritmo para encontrar maior valor da matriz e multiplicá-lo pela matriz
3) Elaborar um algoritmo para somar duas matrizes 2x2 do tipo inteiro fornecidas pelo usuário.
Apresente as 2 matrizes lidas e o resultado em outra matriz.
Algoritmo soma_matrizes;
Declare A[2,2], B [2,2], RES[2,2], i, j: inteiro;
INÍCIO
Escreva (“Lendo a matriz A.”);

Escreva ("Digite os valores da Matriz A[ ",i, " e “ ,j, “]:");
Leia (A [ i, j ] );
FIMPARA;
FIMPARA;
Escreva (“Lendo a matriz B.”);



Escreva ("Digite os valores da Matriz B[ ",i, " e “ ,j, “]:");
Leia (B [ i, j ] );
FIMPARA;
FIMPARA;
Escreva (“Somando as duas matrizes...”);

RES [ i, j ]  A[ i , j] + B[ i , j ];
FIMPARA;
FIMPARA;
Escreva (“A matriz A é: “);

Escreva (A [ i, j ]);
FIMPARA;
FIMPARA;
Escreva (“A matriz B é: “);

Escreva (B [ i, j ]);
FIMPARA;
FIMPARA;
Escreva (“A matriz resultante é: “);

Escreva (RES [ i, j ]);
FIMPARA;
FIMPARA;
FIM.
Figura 113 – Algoritmo para somar duas matrizes


1) Elabore um algoritmo que leia uma matriz A[2,2] e uma variável X ambas do tipo inteiro.
Depois calcule o produto de X por A, colocando o resultado na matriz A.
2) Elabore um algoritmo que carregue duas matrizes fornecidas pelo usuário e informe se elas
são iguais. Lembrando que para duas matrizes serem iguais elas devem ter o mesmo
tamanho e os elementos correspondentes iguais.
3) Elabore um algoritmo que carregue uma matriz e mostre a sua transposta que é obtida
trocando-se as linhas da matriz pelas suas colunas.
4) Elabore um algoritmo que carregue uma matriz 2 x 4 com números inteiros e identifique
elementos negativos. Os elementos negativos encontrados devem ser armazenados em um
vetor.
5) Elabore um algoritmo que carregue uma matriz 10x10 e armazene em dois vetores
respectivamente, as somas das linhas e das colunas da matriz. Imprima a matriz e os
vetores.

14 VARIÁVEIS COMPOSTAS HETEROGÊNEAS: REGISTROS E

VETOR DE REGISTROS
Enquanto um Vetor e uma Matriz podem armazenar somente o mesmo tipo de dado, um
Registro permite declarar diferentes tipos de dados dentro de sua estrutura. Um Registro é uma
coleção de campos onde cada campo pode ser um tipo de dados diferente, por isso conhecido
como Variável Composta Heterogênea (diferentes tipos de dados).
Um Registro permite trabalhar com dados de tipos diferentes em uma mesma estrutura e
por isso é considerado heterogêneo.
14.1 Declaração de Registro

A declaração de um Registro em pseudocódigo segue a seguinte sintaxe:
Algoritmo registro;
Declare <nome_da_variável_registro> REGISTRO (<lista de campos e seus tipos>);
...
INICIO
<comandos>;
FIM.
Figura 114 – Declaração de Registro em pseudocódigo
Exemplificando ...
Considere um Registro com campos referentes a dados de alunos como: matrícula, nome, curso,
período e média.
Algoritmo registro_aluno;
Declare reg_aluno REGISTRO (matr, nome, curso: literal, periodo: inteiro, media: real);
...
INICIO
<comandos>;
FIM.
Figura 115 – Declaração de Registro Aluno
Considere um Registro PRODUTO os campos: código, descrição e preço.

Algoritmo registro_produto;
Declare produto REGISTRO (cod, descricao:literal, preco: real);
...
INICIO
<comandos>;
FIM.
Figura 116 – Declaração de Registro Produto

14.2 Representação Gráfica de um Registro

A representação gráfica de uma variável do tipo registro segue o formato similar ao de um
vetor, mas no lugar dos índices aparece o nome dos campos, como mostrado em Figura 117 e
Figura 118.
reg_aluno
matr nome curso periodo media
Figura 117 – Representação Gráfica do Registro reg_aluno
produto
cod descricao preco
Figura 118 – Representação Gráfica do Registro produto
14.3 Manipulação de Dados de Variável de Registro

Para inserir, calcular, modificar um valor em um Registro é preciso referenciar o nome do
registro e o campo que se deseja manipular, como mostrado na Figura 119.
...
produto.cod ”B002”;
produto.descricao ”tomada”;
produto.preco  1.99;
...
Figura 119 – Exemplo de comandos para manipular o Registro produto
A representação do registro após estas atribuições fica:
produto
B002 tomada 1.99
cod descricao preco
Figura 120 – Representação Gráfica do Registro produto após atribuições

14.4 Operações de Entrada e Saída Utilizando Registros

Para entrada e saída é preciso referenciar o nome do registro e o campo que se deseja leia
ou exibir.
Exemplificando...
Declare produto REGISTRO (cod, descricao:literal, preco: real);
INICIO
// Entrada de Dados no Registro Produto
Escreva(“Entre com o Código do Produto: ”);
Leia(produto.cod);
Escreva(“Entre com a Descrição do Produto: ”);
Leia(produto.descricao);
Escreva(“Entre com o Preço Unitário do Produto: ”);
Leia(produto.preco);
// Saída de Dados no Registro Produto

Escreva(“O Código do Produto é: ”, produto.cod);
Escreva(“A Código do Descrição é: ”, produto.descricao);
Escreva(“O Preço Unitário do Produto é: ”, produto.preco);
FIM.
Figura 121 – Entrada e Saída de Dados – Registro Produto

14.5 VETOR DE REGISTROS

Na maioria dos casos, quando se declara um Registro para aluno, produto, cliente etc, para
cada um destes registros existirão vários alunos, produtos e clientes cadastrados. Então o mais
comum é declarar um Vetor de Registros para aluno, produto, cliente etc, pois existirão vários
dados para cada um destes registros.
Exemplificando ...
Considere um Vetor de 20 posições para o Registro de alunos.
Algoritmo registro_aluno;
Declare reg_aluno [20] REGISTRO (matr, nome, curso: literal, periodo: inteiro, media: real);
i: inteiro;
...
INICIO
<comandos>;
FIM.
Figura 122 – Declaração de um Vetor de Registros para Aluno
Considere um Vetor de 100 posições para o Registro de produtos.

Declare produto [100] REGISTRO (cod, descricao:literal, preco: real);
i: inteiro;
...
INICIO
<comandos>;
FIM.
Figura 123 – Declaração de um Vetor de Registro para Produtos

14.6 Representação Gráfica de Vetor de Registro

A representação gráfica de um Vetor de Registro é apresentada como um Vetor onde cada
posição há um registro, como mostrado na Figura 124.
produto[100]
produto produto produto produto

cod B002 cod C024 cod H112 cod A223
descricao tomada descricao abajur ... descricao torradeira descricao fita
preco 1.99 preco 85.00 preco 122.00 preco 0.50
1 2 ... 99 100
Figura 124 – Representação Gráfica do Vetor de Registros produto

14.7 Manipulação de Dados do Vetor de Registro

Para inserir, calcular, modificar um valor em um Registro de uma determinada posição do
Vetor é preciso referenciar a posição do Vetor e o Campo que se deseja manipular. Portanto,
utiliza-se a Notação de Vetor para indicar qual posição se deseja manipular e o campo para
indicar em que parte do registro haverá modificação, como mostrado na Figura 125:
...
produto[2].cod ” C024”;
produto[2].descricao  “abajur”;
produto [2].preco  85.00;
...
produto[99].cod ” H112”;
produto[99].descricao  “torradeira”;
produto [99].preco  122.00;
...
Figura 125 – Exemplo de comandos para manipular o Vetor de Registros produto
14.8 Operações de Entrada e Saída Utilizando Vetor de Registros

Como no caso de vetores, visto na seção 12.4, utiliza-se um comando de repetição como o
PARA, percorrendo assim todo Vetor de Registros.
Exemplificando...
Considere um algoritmo para leia 100 registros de produtos e imprimi-los na tela. Cada registro
deverá conter o código do produto, sua descrição e seu preço unitário.
Declare produto[100] REGISTRO (cod, descricao:literal, preco: real);
i: inteiro;
INICIO
// Entrada de Dados de 100 Registros de Produto
PARA i DE 1 ATÉ 100 FAÇA
Escreva(“Entre com o Código do Produto: ”);
Leia(produto[ i ].cod);
Leia(produto[ i ].descricao);
Escreva(“Entre com o Preço Unitário do Produto: ”);
Leia(produto[ i ].preco);
FIMPARA;
// Imprimindo os 100 registros Produto

Escreva(“O Código do Produto é: ”, produto[ i ].cod);

Escreva(“A Código do Descrição é: ”, produto[ i ].descricao);

Escreva(“O Preço Unitário do Produto é: ”, produto[ i ].preco);
FIMPARA;
FIM.
Figura 126 – Operações de Entrada e Saída, utilizando Vetor de Registros
1. Elabore um algoritmo que leia informações de descrição, preço, quantidade e ano de
vencimento dos produtos de um supermercado. O algoritmo deverá fazer: a) o cadastro
de 100 produtos; b) listar todos os produtos cuja quantidade em estoque seja maior que
20 unidades; e c) listar todos os produtos cujo vencimento seja menor que 2011.
Algoritmo produto_supermercado;
Declare prod[100] REGISTRO (
descricao : literal
preco: real
qde: inteiro
venc:inteiro);
i: inteiro;
INICIO
Leia(prod[ i ].descricao);
Escreva(“Entre com o preço: ”);
Leia(prod[ i ].preco);
Escreva(“Entre com a quantidade: ”);
Leia(prod[ i ].qde);
Escreva(“Entre com o ano de vencimento: ”);
Leia(prod[ i ].venc);
FIMPARA;
Escreva(“Produtos com quantidade em estoque maior que 20 unidades. ”);

SE (prod[ i ].qde > 20) ENTÃO
Escreva(prod[i].descricao);
FIMSE;
FIMPARA;
Escreva(“Produtos com data de vencimento menor que 2011. ”);

SE (prod[ i ].venc < 2011) ENTÃO
Escreva(prod[i].descricao);
FIMSE;
FIMPARA;
FIM.
Figura 127 – Algoritmo produto_supermercado, usando Vetor de Registros

2. A prefeitura de uma cidade fez uma pesquisa entre seus habitantes, coletando dados sobre
o salário, sexo, idade e número de filhos. Considerando 100.000 habitantes na cidade,
faça um algoritmo que calcule e mostre:
a. A média do número de filhos da população;
b. A maior idade;
c. A média do salário das mulheres.
Algoritmo pesquisa;
Declare pesq[100000] REGISTRO (
sal: real;
sexo: caractere;
idade: inteiro;
filhos: inteiro;);
i, maior: inteiro;
MF, SalF, cont : real;
INICIO
Escreva(“Informe o salário: ”);
Leia(pesq[i].sal);
Escreva(“Informe o sexo, usando F para feminino e M para masculino: ”);
Leia(pesq[i].sexo);
Escreva(“Informe a idade: ”);
Leia(pesq[i].idade);
Escreva(“Informe o número de filhos: ”);
Leia(pesq[i].filhos);
FIMPARA;
MF 0;
MF  MF + pesq[ i ].filhos; // acumula qde de filhos para calcular media
FIMPARA;
MF  MF / 100000;
Escreva(“A média do número de filhos da população: ”, MF);
maior pesq[ 1 ].idade;

SE (pesq[ i ].idade > maior) ENTÃO
maior  pesq[ i ].idade;
FIMSE;
FIMPARA;
Escreva(“A maior idade é: ”, maior);
SalF 0;
cont 0;
SE (pesq[ i ].sexo = „F‟) E (pesq[ i ].sal > 2000)ENTÃO
SalF  SalF + pesq[ i ].sal; // acumula salário feminino maior que 2000
para calcular media
cont cont +1;
FIMSE;
FIMPARA;

SalF  (SalF / cont) ;

Escreva(“A média do salário das mulheres é: ”, SalF);
FIM.
Figura 128 – Algoritmo pesquisa, usando Vetor de Registros

1. Elabore um algoritmo para leia 30 registros de funcionários e imprimi-los na tela. Cada
registro deverá conter a matrícula do funcionário, nome, sexo, ano de contratação e
salário.
2. Para o exercício anterior calcule e mostre os funcionários do sexo feminino e atribua 15%
de aumento ao salário dos funcionários contratados de 2008 a 2011 inclusive.

15 MODULARIZAÇÃO: PROCEDIMENTOS E FUNÇÕES

A estruturação de um algoritmo em módulos é uma boa prática que facilita a construção e a
manutenção de programas grandes e complexos.
O método de modularização consiste na divisão do algoritmo em módulos (também
chamados de sub-algoritmos, subprogramas ou sub-rotinas) que realizam tarefas específicas.
Algumas vantagens da aplicação da modularização na programação são:

1. Maior legibilidade - permite a divisão e a estruturação de um algoritmo em partes
logicamente coerentes, simplificando seu entendimento;
2. Independência na escrita e teste dos módulos do algoritmo - permite que diferentes
programadores trabalhem simultaneamente, através da codificação separada dos
diferentes módulos;
3. Criação única de um módulo frequentemente solicitado – se uma mesma sequência
de comandos é utilizada várias vezes no programa, ela pode ser solicitada e
executada para diferentes valores; e
4. Reutilização de módulos - programas complexos podem ser elaborados a partir de
unidades menores já desenvolvidas e testadas.
Algoritmo
Algoritmo Procedimento Procedimento Procedimento Função Função Função

Principal 1 2 n 1 2 n
Figura 129 – Representação Gráfica de um algoritmo modularizado
Cada módulo, além de ter acesso às variáveis do algoritmo que o chamou (variáveis
globais), pode ter suas próprias variáveis (variáveis locais), que existem apenas durante sua
chamada.
A modularização pode ser feita declarando-se Procedimentos e Funções, chamados em
qualquer parte do algoritmo. Para entender a diferença entre procedimentos e funções e como
declará-las, necessita-se compreender os conceitos retorno de valor e parâmetro, melhor
explicado por meio de exemplos.
Vimos na seção 5.5.2 em Funções pré-definidas a função que calcula a raiz quadrada de um
número denominada SQRT(x). Portanto, quando se faz a chamada desta função usando a
expressão SQRT(25) no programa, espera-se obter a resposta da raiz quadrada de 25. A resposta,
o valor 5, é denominado de retorno de valor ou retorno da função. O valor 25 passado dentro
de parênteses na chamada da função SQRT denomina-se parâmetro ou argumento.

parâmetro ou
argumento
resp  SQRT(25);
A função retorna o
valor 5
Figura 130 – Exemplo de retorno de valor e parâmetro
Uma função retorna um único valor e pode possuir vários parâmetros. Tendo consciência
destes conceitos, torna-se fácil diferenciar Procedimentos de Funções.
Procedimentos são sub-rotinas que NUNCA retornam um valor como resultado, apenas
executam uma tarefa. Por exemplo, o comando escreva imprime uma mensagem na tela, mas não
retorna nenhum valor. O comando leia é um procedimento que lê um valor do teclado e o
armazena numa variável, sem retornar valor.
Funções são sub-rotinas que SEMPRE retornam um valor como resultado. O tipo
retornado por uma função pode ser do tipo básico como inteiro, real, literal, caractere ou lógico,
ou pode ser do tipo declarado pelo usuário como um vetor, matriz, registro dentre outros.
A declaração de procedimentos e funções é bastante similar, diferenciando apenas pelo fato
de que em Função deve-se informar o tipo de dado a ser retornado, enquanto procedimento não
existe a declaração o tipo de retorno, pois ele não nunca retorna valor.
Ressalta-se que o aluno deve guardar e não esquecer esta definição: A diferença entre o uso
de um Procedimento e uma Função é: um Procedimento NUNCA retorna valor, enquanto uma
Função SEMPRE retornará um valor.
15.1 PROCEDIMENTOS
Um procedimento é um conjunto de comandos que realiza alguma operação ao qual se dá
um nome e NUNCA retorna valor.
Pode-se dizer que um procedimento possui vida própria, com suas próprias variáveis
(variável local), mas que para ser processado, deve ser chamado pelo algoritmo principal ou por
outro procedimento.
Um procedimento pode acessar as variáveis declaradas no algoritmo principal (variáveis

globais), desde que não estejam declaradas dentro do procedimento. Se uma variável for
declarada dentro de um procedimento com o mesmo nome declarado no programa principal, é
criada uma nova variável local e a variável global deixa de ser visível dentro do procedimento.

Deste conceito, define-se o termo escopo de variável, o qual pode ser de escopo global ou
escopo local.
15.1.1 Declaração de Procedimentos

Um procedimento possui um cabeçalho de identificação com o nome do procedimento,
uma lista opcional de parâmetros, um bloco de declarações e um bloco de comandos.
A sintaxe para declaração de procedimentos está apresentada na Figura 131.

...
PROCEDIMENTO <nome_do_procedimento> (<lista_de_parâmetros> : <tipo>);
declare < lista-de-variáveis> : <tipo>;
<comandos>;
FIMPROCEDIMENTO;
...
Figura 131 – Declaração de Procedimento
Na declaração de um procedimento, o <nome_do_procedimento> obedece às mesmas

regras de nomenclatura de variáveis, constantes e algoritmos, vide seção 4.3.
A declaração da lista de parâmetros é opcional. Caso não haja parâmetros nada é escrito
dentro dos parênteses.
De modo análogo ao algoritmo principal, um procedimento possui a seção opcional de

declaração de variáveis (variáveis locais) utilizando a palavra-chave declare, e segue a sintaxe:
<lista_de_variáveis> : <tipo>;
Figura 132 – Declaração de Variável em Procedimentos
Exemplificando...
Declaração do procedimento SEPARADOR sem parâmetros. Este procedimento cria uma
linha como separador na tela usando asteriscos (*).
...
PROCEDIMENTO SEPARADOR ( );
declare i : inteiro;
escreva (“*”);
FIMPARA;
FIMPROCEDIMENTO;
...
Figura 133 – Declaração do Procedimento SEPARADOR

Declaração do procedimento IMPRIMIR sem parâmetros. Este procedimento imprime

todos os números de 1 até 1000.
...
PROCEDIMENTO IMPRIMIR ( );
escreva (i);
FIMPARA;
FIMPROCEDIMENTO;
...
Figura 134 – Declaração do Procedimento IMPRIMIR
Declaração do procedimento SEPARADOR com 1 parâmetro. Este procedimento cria uma

linha como separador na tela usando o símbolo passado como parâmetro.
...
PROCEDIMENTO SEPARADOR ( símbolo : caractere);
escreva (simbolo);
FIMPARA;
FIMPROCEDIMENTO;
...
Figura 135 – Declaração do Procedimento SEPARADOR
Declaração do procedimento IMPRIMIR com 2 parâmetros. Este procedimento imprime

todos os números entre x1 e x2.
...
PROCEDIMENTO IMPRIMIR(x1, x2:inteiro);
PARA i de x1 ATÉ x2 FAÇA
escreva (i);
FIMPARA;
FIMPROCEDIMENTO;
...

Declaração do procedimento IMPRIMIR com 3 parâmetros. Este procedimento imprime o

nome, salário e idade de um funcionário.
...
PROCEDIMENTO IMPRIMIR(nome:caractere; salario:real; idade:inteiro);
escreva (“nome:”, nome);
escreva (“salario:”, salario);
escreva (“idade: ”, idade);
FIMPROCEDIMENTO;
...
15.1.2 Procedimentos sem Passagem de Parâmetros

Procedimentos sem passagem de parâmetros são procedimentos declarados sem nenhum
parâmetro. Isto ocorre em dois casos. No primeiro caso, o procedimento repete sempre as
mesmas linhas de comando. No segundo caso, o procedimento possui variação e se utiliza de
variáveis globais para capturar o valor a ser utilizado em sua execução.
Na Figura 138, apresenta-se o exemplo do primeiro caso, em que o procedimento não possui
parâmetro e sua execução será sempre idêntica.
Algoritmo teste_procedimento;
declare nome : literal;
escreva (“*”);
FIMPARA;
FIMPROCEDIMENTO;
INICIO
escreva (“Algoritmo para testar chamada de um procedimento”);
separador;
escreva (“Aula de AEDI”);
separador;
escreva (“Digite seu nome:”);
leia (nome);
separador;
escreva (“O nome é:”, nome);
separador;
FIM.
Figura 138 – Chamada ao Procedimento SEPARADOR
A Figura 138 mostra um procedimento que imprime uma linha com 20 asteriscos. Toda vez
que o procedimento SEPARADOR for chamado, ele sempre fará a mesma coisa sem nenhuma
variação, ou seja, imprimirá uma linha com 20 asteriscos.

Na Figura 139, apresenta-se o exemplo do segundo caso, em que o procedimento utiliza o

valor de uma variável global para alterar o caractere impresso na tela.
Algoritmo teste_procedimento;
simbolo: caractere;
escreva (simbolo);
FIMPARA;
FIMPROCEDIMENTO;
INICIO
escreva (“Algoritmo para testar chamada de um procedimento”);
escreva (“Digite o caractere que deseja imprimir como separador de linha: ”);
leia(simbolo);
separador;
escreva (“Digite novo caractere que deseja imprimir como separador de linha: ”);
leia(simbolo);
separador;
FIM.
Figura 139 – Chamado ao Procedimento SEPARADOR
A Figura 139 mostra um algoritmo em que o usuário fornece o caractere que deseja
imprimir como separador de linha. Este caractere é armazenado na variável símbolo declarada
como de escopo global. A primeira vez que o procedimento SEPARADOR é chamado, uma
linha com o caractere armazenado em símbolo será impresso. Em seguida, novo caractere é
solicitado ao usuário e, na sequencia, o procedimento SEPARADOR utilizará esse novo símbolo
para imprimir a linha com 20 caracteres. Observe que a variação do comportamento do
procedimento sem parâmetro, somente foi possível por que o procedimento utiliza uma variável
global que pode ser alterada.
15.1.3 Procedimentos com Passagem de Parâmetros

Ao chamar um procedimento, também é possível passar-lhe determinadas informações
que recebem o nome de parâmetros. Estes parâmetros são valores passados na linha de chamada
entre parênteses e separados por vírgulas (quando houver mais de um).
A quantidade dos parâmetros, sua sequência e respectivos tipos não podem mudar,
devendo estar de acordo com o especificado na declaração. Portanto, se o programador definir
um procedimento com dois parâmetros um inteiro e um real, nesta ordem, então ao chamar o
procedimento, obrigatoriamente, deverá ser passado um valor inteiro e um real, nesta ordem.

Exemplificando...
Voltemos ao exemplo da Figura 138 que declara um procedimento que cria uma linha como
separador na tela usando asteriscos (*). Mas agora alterando-o, permitindo o uso de diferentes
símbolos como separador.
Algoritmo teste_procedimento_com_parametro;
PROCEDIMENTO SEPARADOR (simbolo : caractere);
PARA i de i ATÉ 20 FAÇA
escreva (simbolo);
FIMPARA;
FIMPROCEDIMENTO;
INICIO
escreva (“Testando chamada de procedimento com passagem de parâmetro!”);
separador (“-”);
escreva (“Aula de AEDI”);
separador (“=”);
escreva (“Digite seu nome:”);
leia (nome);
separador (“+”);
escreva (“O nome é:”, nome);
separador (“#”);
FIM.
Figura 140 – Algoritmo, usando Procedimento COM passagem de Parâmetros
15.2 FUNÇÕES
Uma função é um conjunto de comandos que realiza alguma operação para a qual dá-se um
nome e SEMPRE retorna um valor.
Como o Procedimento, uma Função permite organizar um conjunto de comandos que

estariam repetidos em várias partes do algoritmo
E também como no caso dos procedimentos, as funções precisam ser chamadas pelo
algoritmo principal para serem executadas. Ao se chamar uma função, desvia-se a execução do
algoritmo principal para realizar uma tarefa específica. Após sua execução, no local onde foi
feita a chamada da função atribui-se o valor retornado por ela.
O conceito de Função vem da idéia de função matemática, como raiz quadrada, seno,
cosseno, tangente, logaritmo etc, onde calcula-se um valor a partir de outro(s) fornecido(s) à
função.

Lembre-se que como uma função sempre retorna um valor, elas devem ser chamadas de
forma a fazer sentido a substituição da chamada da função pelo valor que ela retorna.
Por isso, em uma função deve-se declarar tipos, consistentes com o tipo de valor por ela
calculado (inteiro, real, caractere, literal ou Lógico).
Alguns exemplos de chamadas são:
variavel  Funcao(parâmetros);
variavel  Funcao(parâmetros) + Z;
Figura 141 – Exemplo de chamada de função
A chamada de uma função é feita através da citação do seu nome, seguido pelos
parâmetros entre parênteses (se houver), dentro de uma expressão.
15.2.1 Declaração de Funções
Uma função possui um cabeçalho de identificação com o nome da função, uma lista
opcional de parâmetros, o tipo de dado do valor retornado, um bloco de declarações e um
bloco de comandos.
A sintaxe para declaração de funções está apresentada na figura a seguir.

...
FUNCAO <nome_da_funcao> (<lista-de-parâmetros> : <tipo>): <tipo_retornado>;
<comandos>;
retorne <valor de retorno>;
FIMFUNCAO;
...
Figura 142 – Sintaxe para Declaração de Funções
Na declaração de uma função, o <nome-da-função> obedece às mesmas regras de

nomenclatura de variáveis, constantes e algoritmos, vide seção 4.3.
A declaração da lista de parâmetros é opcional. Caso não haja parâmetros nada é escrito
dentro dos parênteses.
O número de parâmetros e seu respectivo tipo devem ser respeitados, podendo-se construir
funções com e sem parâmetros.
De modo análogo ao algoritmo principal, uma função possui a seção opcional de

declaração de variáveis (variáveis locais) utilizando a palavra-chave declare, e segue a sintaxe
...
declare <lista-de-variáveis> : <tipo>;
...
Figura 143 – Declaração de Variável em Funções

Exemplificando...
Declaração da função DIVIDIR com 2 parâmetros. Esta função divide dois números
inteiros e retorna um número real.
Algoritmo Exemplo_funcao_com_parametro;
declare calc: real;
X,Y: inteiro;
FUNCAO DIVIDIR ( a, b : inteiro) : real;
retorne a/b;
FIMFUNCAO;
INICIO
Escreva ("Digite 2 números inteiros para serem divididos”);
Escreva ("Digite o 1º número= ”);
Leia(X);
Leia(Y);
calc  DIVIDIR( X ,Y );
Escreva ("A divisão de ", x, "por ", y, "é ", calc);
FIM.
Figura 144 – Algoritmo com chamada a Função com 2 parâmetros
15.2.2 Funções sem Passagem de Parâmetros

Funções sem passagem de parâmetros são funções declaradas sem nenhum parâmetro.
Na declaração de uma função, informe o <nome-da-função>. A declaração da lista de

parâmetros é opcional, então se não há passagem de parâmetros nada é escrito dentro dos
parênteses. Após define-se o tipo de dado do valor que esta função retorna, se será: inteiro, real,
caractere, literal ou Lógico.
De modo análogo ao algoritmo principal, a seção de declaração internas começa com a

palavra-chave declare, e continua com a seguinte sintaxe: <lista-de-variáveis> : <tipo>; e segue
com os comandos a serem executados pela função.
...
FUNCAO <nome_da_funcao>:<tipo_do_valor_retornado>;
<comandos>;
FIMFUNCAO;
...
Figura 145 – Declaração de Função SEM passagem de parâmetros

Exemplificando...
Algoritmo para calcular dividir dois números reais, cuja função NÃO possui parâmetros.
Algoritmo Exemplo_funcao_sem_parametro;
declare calc, X,Y : real;
FUNCAO DIVIDIR : real;
retorne X/Y;
FIMFUNCAO;
INICIO
Escreva ("Digite 2 números para serem divididos”);
Leia(X);
Leia(Y);
calc  DIVIDIR;
Escreva ("A divisão de “, x, “por “, y, “é ", calc);
FIM.
Figura 146 – Algoritmo com chamada a Função sem parâmetros
15.2.3 Funções com Passagem de Parâmetros

Pode-se utilizar função com passagem de parâmetros. Para isso, ao se chamar uma função
deve-se atribuir os parâmetros.
...
FUNCAO <nome_da_funcao> (<lista-de-parâmetros> : <tipo>): <tipo_retornado>;
<comandos>;
FIMFUNCAO;
...
Figura 147 – Declaração de Função COM passagem de parâmetros

Exemplificando...
Algoritmo _funcao_com_parametros;
declare calc, X,Y : real;
FUNCAO MULTIPLICAR (a,b: real) : real;

retorne a*b;
FIMFUNCAO;
INICIO
Escreva ("Digite 2 números para serem multiplicados!”);
Leia(X);
Leia(Y);
calc  MULTIPLICAR( X , Y );
Escreva ("A multiplicação de “, x, “por “, y, “é ", calc);
FIM.
Figura 148 – Algoritmo com chamada a Função COM parâmetros
O algoritmo a seguir é um exemplo de declaração e uso de uma função para calcular o

valor de um número inteiro elevado ao quadrado.
Algoritmo Exemplo_funcao;
declare X, Y : inteiro;
Funcao QUAD(num : inteiro) : inteiro;

declare Z : inteiro;
Z  num * num;
retorne Z;
Fimfuncao;
inicio
Escreva ("Digite um número inteiro”);
Leia(X);
Y  QUAD(X);
Escreva (X, " elevado ao quadrado é = ", Y);
Fim.
Note que:
 A função QUAD recebe num como parâmetro do tipo inteiro, terá um valor de retorno
do tipo inteiro e possui Z como uma variável local do tipo inteiro;

 O comando de chamada da função QUAD aparece no comando de atribuição () no do

algoritmo principal.
1. Usando função, escreva um algoritmo que calcule a potencia cúbica de um número

inteiro.
PROGRAMA Uso_Funcao;
declare num:inteiro;
FUNCAO POTENCIA (valor : inteiro) : inteiro;

declare resul: inteiro;
resul  valor*valor*valor;
retorne resul;
FIMFUNCAO;
INICIO
Escreva ("Digite um número inteiro”);
leia (num);
escreva ( POTENCIA(num) );
FIM.
2. Usando função, escreva um algoritmo que dado um valor de salário e um informado o

percentual de aumento, calcule o novo salário.
Algoritmo aumento_salario;
declare sal, aum, novo_sal: real;
FUNCAO CALC (salario: real) : real;

declare perc, valor: real;
Escreva (“Digite o percentual de aumento: “);
Leia (perc);
valor  (salario * perc) / 100;
retorne valor;
FIMFUNCAO;
INICIO
Escreva (“Digite o salário: “);
Leia (sal);
aum  CALC (sal);
novo_sal  sal + aum;
Escreva (“O nomo salário é: “,novo_sal);
FIM.
Figura 149 – Algoritmo, usando Função CALC_SAL (com passagem de parâmetro)

3. Usando funções e procedimentos, escreva um algoritmo que receba:

 O código de um produto comprado, supondo que a digitação do código do produto seja
sempre válida (um número inteiro entre 1 e 10);
 O peso do produto em quilos, e o código do país de origem, supondo que a digitação do
código do país seja sempre válida, segundo as tabelas a seguir.
Código do país de origem Imposto

Código do produto Preço por grama
1 0%
1a4 R$ 10,00
2 15%
5a7 R$ 25,00
3 25%
8 a 10 R$ 35,00
Depois calcule e mostre:

 O peso do produto convertido em gramas;
 O preço total do produto comprado;
 O valor do imposto, sabendo-se que o imposto é cobrado sobre o preço total do produto
comprado e que depende do país de origem; e
 O valor total, preço total do produto mais imposto.
Algoritmo Calcula_Preco;
declare peso_kg, peso_grama, preco_total, valor_imposto: real;

codigo, cod_pais:inteiro;
INICIO
lerdados;
peso_grama ← kg2grama( peso_kg );
preco_total ← CalcularPrecoTotal( codigo, peso_grama );
valor_imposto ← Imposto( cod_pais, preco_total );
valor_total ← ValorTotal( preco_total, valor_imposto );
ImprimirDados;
FIM.
PROCEDIMENTO lerdados( )
escreva("Digite o código do produto: ");
leia(codigo);
escreva("Digite o peso do produto(kg): ");
leia(peso_kg);
escreva("Digite o código do país de origem: ");
leia(cod_pais);
FIMPROCEDIMENTO;
FUNCAO kg2grama(pesokg:real):real
retorne TRUNC(pesokg) * 1000 + FRAC(pesokg);
FIMFUNÇÃO;
FUNCAO CalcularPrecoTotal(cod:inteiro; pesogr:real):real

declare valor:real;

escolha (cod)
caso 1..4 : valor ← pesogr * 10;
caso 5..7 : valor ← pesogr * 25;
caso 8..10: valor ← pesogr * 35;
fimescolha;
retorne valor;
FIMFUNÇÃO;
FUNCAO Imposto(pais:inteiro, PTotal:real ):real;

declare imp:real;
escolha (pais)
caso 1: imp ← 0;
caso 2: imp ← PTotal * 0,15;
caso 3: imp ← PTotal * 0,25;
fimescolha;
retorne imp;
FIMFUNÇÃO;
FUNCAO ValorTotal(PTotal, imp:real):real;

retorne Ptotal + imp;
FIMFUNÇÃO;
PROCEDIMENTO ImprimirDados()
escreva("Peso em gramas: ", peso_grama);
escreva("Preco Total do Produto: "preco_total);
escreva("Valor do Imposto ",valor_imposto);
escreva("Valor Total ", valor_total);
FIMPROCEDIMENTO;

15.3 ESCOPO DE VARIÁVEIS – VARIÁVEIS LOCAIS E GLOBAIS

Variáveis Locais são declaradas dentro dos procedimentos e funções e existem apenas
dentro do procedimento e da função onde foram declaradas. Elas não podem ser utilizadas em
outra parte do algoritmo.
Variáveis Globais são declaradas normalmente no início do algoritmo e existem em

qualquer parte do algoritmo, podendo ser utilizadas no principal do algoritmo, nos
procedimentos e funções.
Recomenda-se não usar variáveis globais dentro de procedimentos e funções, pois esta
prática cria dependência do procedimento ou função em relação à variável. Neste caso, se o
programador tentar reutilizar o procedimento ou função em outro algoritmo, então ele terá que
declarar uma variável global com o mesmo nome no novo algoritmo que está construindo.
Recomenda-se que o programador sempre declare parâmetros para passar valor do
algoritmo principal para as funções e procedimentos.
O algoritmo da Figura 150 apresenta um procedimento que imprimi na tela todos os

números contidos no intervalo x1 e x2.
Algoritmo imprimir;
declare x1, x2 inteiro;
INICIO
escreva(“Leia valor inicial: ”);
leia(x1);
escreva(“Leia valor final: ”);
leia(x2);
imprimir;
FIM.
PROCEDIMENTO IMPRIMIR;
PARA i de x1 ATÉ x2 FAÇA
escreva (i);
FIMPARA;
FIMPROCEDIMENTO;
Na Figura 150, observa-se o trecho principal do algoritmo entre as palavras reservadas início
e fim. Deve-se compreender que x1 e x2 são variáveis de escopo global. Isto implica que estas
variáveis são visíveis e utilizáveis em qualquer parte do programa, inclusive dentro de
procedimentos e funções. Por isto, pode-se utilizá-las no procedimento IMPRIMIR sem declará-
las, pois já foram declaradas no algoritmo principal e existem em todo algoritmo. Observa-se
ainda que dentro do procedimento IMPRIMIR declarou-e a variável i.
Quando variáveis são declaradas dentro de sub-rotinas como funções e procedimentos, elas
são denominadas de Variáveis de Escopo Local. Isto implica que estas variáveis são visíveis e

utilizáveis apenas dentro do procedimento ou função onde foram declaradas. Por isto, a variável i
não pode ser utilizada dentro do algoritmo principal. Caso o programador tente utilizar a variável
de Escopo Local fora da função ou procedimento onde ela foi declarada, o compilador informará
que a variável não existe.
Caso o programador declarasse a variável i no algoritmo principal, então o algoritmo teria

duas variáveis i. Quando o i utilizado estiver dentro do dentro do procedimento IMPRIMIR,
onde existe a declaração da variável local i, o algoritmo usa a Variável Local. Quando o i
utilizado estiver no algoritmo principal ou em outro procedimento ou função que não há variável
i declarada, então, o algoritmo utiliza a variável i de escopo global.
Para melhor compreender o que ocorre na execução do algoritmo, o programador deve
guardar em mente que Variáveis Locais existem apenas quando o procedimento ou função está
em execução, assim que a execução volta para o algoritmo principal, toda Variável Local é
destruída e seus valores perdidos. Quando se chama novamente o procedimento ou função, estas
variáveis são criadas novamente. Apenas as Variáveis Globais são criadas uma única vez,
quando o algoritmo começa, e deixam de existir apenas quando o algoritmo encerra sua
execução.
15.4 PASSAGEM DE PARÂMETROS POR VALOR E POR REFERÊNCIA

Procedimentos e Funções podem ser criadas com ou sem parâmetros, como apresentado em
seções anteriores. Quando declaram-se Procedimentos e Funções com parâmetros, o
programador deve decidir se tais parâmetros serão passados por valor ou por referência. Até o
momento, foram ensinados Procedimentos e Funções com passagem de parâmetros por valor,
apesar desta nomenclatura não ter sido apresentada.
Nesta seção, apresentam-se as diferenças entre os conceitos, para que o programador tome
a melhor decisão de acordo com as necessidades do projeto
15.4.1 Passagem de Parâmetros por Valor

Este é o formato mais simples de se passar parâmetros. Para melhor exemplificar a
passagem de parâmetros por valor, considere a função somar com a seguinte declaração:
FUNÇÃO SOMAR( X : inteiro, Y : inteiro) : inteiro
Além da declaração da função, imagine uma linha chamando a função com a seguinte
declaração:
N1  10;
N2  20;
S  SOMAR(N1, N2);

Quando o programa começa a ser executado, aloca-se na memória do computador as

variáveis globais, e de acordo com a linha executada do programa, a memória modifica-se. Na
Figura 151, observa-se uma representação gráfica da memória de um computador e a declaração
das variáveis N1 e N2 com os valores alocados de 10 e 20, respectivamente. Porém, a função
ainda não foi chamada, por isto, omite-se as variáveis X e Y.
1 2 3 4 5 6
1 N1=10
2
3 N2=20
4
5
Figura 151 – Memória do Computador com as Variáveis Globais
Quando ocorre a chamada a função Somar(N1, N2), então o computador copia o valor 10
do primeiro parâmetro N1 para a primeira variável declarada no parâmetro da função,
denominada X. Logo em seguida, o computador copia o valor 20 do segundo parâmetro N2 para
a segunda variável declarada no parâmetro da função, denominada Y. A Figura 152 apresenta o
estado da memória após copiar os valores de N1 e N2 para X e Y, respectivamente.
Após compreender o que ocorre na memória do computador quando se passa parâmetros
por valor, torna-se fácil explicar este tipo de passagem de parâmetros. Define-se passagem de
parâmetros por valor quando o computador copia o valor das variáveis contidas na chamada de
uma função ou procedimento para os parâmetros declarados na função. Portanto, as variáveis são
distintas, e quando se altera o valor de X e Y dentro da função ou procedimento, as variáveis N1
e N2 não têm seus valores alterados, pois estão alocadas em locais diferentes na memória
1 2 3 4 5 6
1 N1=10
2
3 N2=20
4 X=10
5 Y=20
Figura 152 – Memória do Computador Contendo os Parâmetros X e Y

15.4.2 Passagem de Parâmetros por Referência

Um conceito importante para entender passagem de parâmetros por referência consiste em
compreender que duas variáveis podem ocupar o mesmo espaço de memória, ou ainda, pode-se
afirmar que um valor guardado na memória pode ser referenciado por variáveis com nomes
distintos A e B, por exemplo.
O leitor deve aceitar que o computador consegue guardar o número 10 na memória e que
para acessar o número 10 você pode chamar a variável A ou B, veja a Figura 153.

C
A B
1 2 3 4 5 6
1 10
2 30
3
4
5
Figura 153 – Variáveis Ocupando o Mesmo Espaço de Memória
A Figura 153 apresenta o valor 10 armazenado na posição 1x1 da memória, tendo as

variáveis A e B associadas a esta posição. Neste caso, se for alterado o valor de A,
automaticamente, altera-se o valor de B e vice versa, pois A e B estão referenciando o mesmo
local da memória. Se for alterado o valor da variável C, localizada na posição 2x4 da memória,
nem o valor de A e nem o de B serão afetados, pois elas estão em posição distintas na memória.
Uma analogia para esta situação é imaginar que o apelido de seu irmão Francisco é Chico.
Se Chico se formar em engenharia e alguém lhe perguntar qual a profissão de Francisco, você
responderá: engenheiro. Logo, se você chamá-lo de Francisco ou Chico, estará referenciando a
mesma pessoa, o que acontece com Chico também se aplica a Francisco e vice versa.
Para exemplificar a passagem de parâmetros por referência, considere a função

somar com a seguinte declaração:
FUNÇÃO SOMAR( var X : inteiro, var Y : inteiro) : inteiro
A palavra var destacada na declaração informa que X e Y são variáveis que receberão
parâmetros por referência. Quando não se coloca a palavra var, automaticamente, o computador
entenderá que o programador quer passagem de parâmetros por valor. Além da declaração da
função SOMA, considera as linhas a seguir contendo atribuições e chamada a função:
N1  10;
N2  20;
S  SOMAR(N1, N2);
Quando o programa começa a ser executado, aloca-se na memória do computador as

variáveis globais, e de acordo com a linha executada do programa, a memória modifica-se. Na
Figura 154, observa-se a memória de um computador e a declaração das variáveis N1 e N2 com
os valores alocados de 10 e 20, respectivamente, porém a função ainda não foi chamada, por isto,
omite-se as variáveis X e Y.

N1 N2
1 2 3 4 5 6
1 10
2
3 20
4
5
Figura 154 – Memória do Computador com as Variáveis Globais
Quando ocorre a chamada a função Somar(N1, N2), cujos parâmetros foram declarados
com var, então o computador cria as variáveis X e Y, apontando para o mesmo local das
variáveis N1 e N2, respectivamente, como mostrado na Figura 155. Portanto, ao referenciar a
variável X, referencia-se também a variável N1, e quando se referencia a variável Y referencia-
se também a variável N2, e vice versa.
X N2 Y
N1
1 2 3 4 5 6
1 10
2
3 20
4
5
Figura 155 – Memória do Computador com Passagem de Parâmetros Por Referência

16 RECURSIVIDADE
Um módulo (Procedimento ou Função) recursivo é aquele que chama a si próprio n vezes
para resolver um problema. A utilização da técnica de recursividade em um algoritmo tem por
objetivo diminuir a complexidade do problema, aplicando-se o princípio de dividir para
conquistar.
Para aplicar a recursividade, deve-se dividir o problema sucessivamente em problemas
mais simples, até que a simplicidade do problema permita resolvê-lo de forma direta, sem que a
função ou procedimento tenham de chamar a si mesmos novamente.
Um exemplo simples de compreender a recursividade é compreender o cálculo de numero

fatorial. Por definição, o fatorial de um número natural n, representado por n!, é o produto de
todos os inteiros positivos menores ou iguais a n. Por definição, 0!=1, caso contrário o fatorial de
qualquer número seria 0 (zero), pois zero vezes qualquer número é zero. Matematicamente,
define-se que:
4! = 4 . 3!
3! = 3 . 2!
2! = 2 . 1!
1! = 1 . 0!
Na última linha acima, basta substituir o 0! por 1, então tem-se o resultado da conta de 4!.
Assim, tem-se a seguinte definição:
n! = 1 se n =0
n . (n-1)! se n>0
Portanto, para resolver 4! é preciso multiplicar 3 por 3!, o que implica em recursividade,
pois para resolver qualquer fatorial de n, é preciso calcular outro fatorial até se chegar a 0! que
por definição será 1. Quando n vale 0, no caso do fatorial, diz-se que o algoritmo atingiu uma
condição de parada, não sendo necessário calcular outro fatorial, apenas retornar um valor de
definição. Esta condição de parada deve estar presente em pelo menos um local dentro algoritmo
para que ele possa encerrar o cálculo e não entrar em loop infinito.

Exemplificando...
Sabe-se que o fatorial de um número N (positivo) pode ser obtido multiplicando-o pelo
fatorial de seu predecessor:
Pela definição: FAT(N) = N * FAT(N - 1)
Algoritmo teste_recursividade;
declare num: inteiro;
FUNCAO FAT (n: inteiro): inteiro;

SE (n=0) ENTAO
FAT  1;
retorne FAT;
SENAO
FAT  n * FAT(n-1);
retorne FAT;
FIMSE;
FIMFUNCAO;
INICIO
escreva (“Digite um número para obter seu fatorial: “);
leia (num);
escreva (“Fatorial de “ ,num, “:“ , FAT(num) );
FIM.
Figura 156 – Função Recursiva que calcula o fatorial de um número
Pela definição 4! é calculado como:

4! = 4*3! = 4*(3*2!) = 4*(3*(2*1!)) = 4*(3*(2*(1*0!))) = 4*(3*(2*(1*1))) = 24
Note que função é chamada recursivamente com parâmetro decrescente até chegar no caso
final, ou seja, 0!, cujo valor é 1.
Este caso final é a condição de parada que encerra a seqüência de chamadas recursivas.
Exemplificando...
A Figura 157 apresenta um exemplo de um procedimento recursivo que recebe como

parâmetro um valor N inteiro, imprime-o na tela e chama novamente o próprio procedimento,
recursão. No exemplo a seguir, a condição de parada será o valor zero, pois para valores maiores

que zero o procedimento recursão chamará novamente o próprio procedimento recursão.

Quando o parâmetro n valer zero, o procedimento nada fará, encerrando as chamadas recursivas.
É importante o programador compreender que o funcionamento da recursão é o mesmo

quando se chama uma função somar num programa principal. O programa principal suspende
sua execução e começa a executar a função somar. Após executar a função somar, ela retorna um
valor o qual é colocado no lugar da chamada da função e o programa continua sua execução.
Portanto, na Figura 157, observa-se que dentro da condição SE, o procedimento recursão é
chamado. Neste caso, a execução é congelada (suspensa) e inicia-se outra execução do mesmo
procedimento recursão com parâmetro "n-1". Como, na nova execução, há outra chamada ao
procedimento recursão, então esta nova chamada também é congelada, e outra execução se
inicia do próprio procedimento. Somente após atingir a condição de parada e o procedimento não
for chamado novamente, é que as execuções anteriormente congeladas continuarão a execução
do ponto em que pararam.
PROCEDIMENTO recursao (n : inteiro);

SE n > 0 ENTAO
escreva (n);
recursao (n - 1);
FIMSE;
FIMPROCEDIMENTO;
Figura 157 – Procedimento Recursivo que imprime um número em ordem decrescente
Para um valor inicial igual a 5 saída gerada será:

SAÍDA
5
4
3
2
1
O lugar onde se faz a chamada da recursão alterará o comportamento do algoritmo recursivo.

Exemplificando...
A Figura 158 apresenta o mesmo exemplo, alterando apenas a posição da chamada de

recursão. Após executá-lo, manualmente, observe que a saída será diferente, imprimindo-se o
valor recebido em ordem crescente, de 1 até N.
PROCEDIMENTO recursao (n : inteiro);

SE n > 0 ENTAO
recursao (n - 1);
escreva (n); //Esta linha será executada ao final de cada execução da rotina recursiva
FIMSE;
FIMPROCEDIMENTO;
Figura 158 – Procedimento Recursivo que imprime um número em ordem crescente
Exemplificando...
A seqüência 0, 1, 1, 2, 3, 5, 8, 13, 21, ... é conhecida como sequencia ou série de Fibonacci.

Esta sequência de números tem a característica da recursividade, onde:
O 1º termo somado ao 2º termo gera o 3º termo

e continua ...
A série de Fibonacci pode ser obtida através da seguinte definição recursiva:
FUNCAO Fib (n : inteiro) : inteiro;

SE (n = 0) OU (n = 1) ENTAO
retorne n;
SENAO
retorne Fib(n-2) + Fib(n-1);
FIMFUNCAO;
Figura 159 – Função Recursiva para obter a série de Fibonacci


1) Escreva uma função recursiva que retorne o somatório de um intervalo de n1 até n2.
2) Escreva um procedimento recursivo para imprimir na tela todos os números primos de 1
até 100.
3) Escreva um procedimento recursivo para imprimir na tela todos os números primos de n1
até n2. Teste o algoritmo para n1=n2 também e veja se ele funciona. Caso não funcione,
faça correções.
4) Escreva um procedimento recursivo que imprima na tela os valores de um vetor de 100
posições.
5) Escreva uma função recursiva que retorne a posição que contém o maior valor de um
vetor de 100 posições.
6) Escreva uma função recursiva que retorne o segundo menor valor de um vetor de 100
posições.
7) Escreva uma função recursiva que retorne a soma dos dígitos de um inteiro positivo n. A
soma dos dígitos de 652, por exemplo é 13.
8) Escreva uma função recursiva que retorne o somatório dos números inteiros positivos de
um vetor de 100 posições.
9) O algoritmo a seguir representa uma função que calcula o maior divisor comum (MDC)
dos inteiros positivos utilizando o algoritmo de Euclides. Escreva uma função recursiva
equivalente.
FUNÇÃO Euclides (m:inteiro, n:inteiro) : inteiro;
declare r : inteiro;
REPITA
r = m % n;
m = n;
n = r;
ATÉ (r = 0);
retorne m;
FIMFUNÇÃO;
10) Escreva uma função recursiva que imprima na tela todos os números fatoriais de 1 até 20,
utilizando apenas uma função.
11) Escreva uma função recursiva que imprima na tela todos os números fatoriais de n1 até
n2, utilizando apenas uma função. N2 é MAIOR OU IGUAL a n1.

17 ÍNDICE DE FIGURAS
Figura 1 - Algoritmo de Euclides para calcular o MDC ................................................................................. 7
Figura 2 - Algoritmo Erastótenes para encontrar números primos de 2 até N. ........................................... 8
Figura 3 – Formulário de Assinatura de Revista ......................................................................................... 11
Figura 4 – Estrutura de dados Cliente ........................................................................................................ 11
Figura 5 – Variação de uma Estrutura de dados Cliente ............................................................................ 12
Figura 6 - Exemplo de algoritmo usando Descrição Narrativa ................................................................... 14
Figura 7 - Fluxograma Fritar um ovo .......................................................................................................... 15
Figura 8 - Fluxograma Média ...................................................................................................................... 16
Figura 9 - Algoritmo Média em Pseudocódigo ........................................................................................... 17
Figura 10 – Execução de Teste de Mesa do Algoritmo Soma .................................................................... 18
Figura 13 - Exemplo de declarações de variáveis ....................................................................................... 22
Figura 14 - Exemplo Alteração de valor de variável ................................................................................... 23
Figura 15 – Representação de criação de variáveis na memória do computador ..................................... 23
Figura 16 - Exemplo de declarações de constantes ................................................................................... 25
Figura 21 – Fluxograma de Comando Condicional SE ENTÃO SENÃO........................................................ 37
Figura 22 – Exemplo de Comando Condicional SE ENTÃO SENÃO ............................................................. 37
Figura 23 – Sintaxe do Comando Condicional Simples .............................................................................. 42
Figura 24 – Exemplo de Algoritmo usando Comando Condicional Simples ............................................... 42
Figura 25 – Sintaxe do Comando Condicional Composto .......................................................................... 43
Figura 26 – Exemplo de Algoritmo usando Comando Condicional Composto........................................... 43
Figura 27 – Exemplo de Algoritmo usando Comando Condicional Simples ............................................... 44
Figura 28 – Exemplo de Comando Condicional SE ENTÃO SENÃO, usando operador NÃO....................... 44
Figura 29 – Exemplo de Comando Condicional SE ENTÃO SENÃO, usando operador OU ......................... 44
Figura 30 – Exemplo de Indentação em Texto Comum ............................................................................. 46
Figura 31 – Exemplo de Indentação ........................................................................................................... 47
Figura 32 – Exemplo de Aninhamento de Comandos SE...ENTÃO...SENÃO, Algoritmo Maior .................. 48

Figura 33 – Exemplo de Aninhamento de Comandos SE...ENTÃO...SENÃO, Algoritmo Aprovacao_Aluno .... 50
Figura 34 – Exemplo de Aninhamento de Comandos SE...ENTÃO...SENÃO, Algoritmo triangulo ............. 51
Figura 35 – Fluxograma de Comando Condicional ESCOLHA CASO ........................................................... 52
Figura 36 – Sintaxe do Comando Condicional ESCOLHA CASO .................................................................. 53
Figura 37 – Algoritmo Aplicando o Comando SE...ENTÃO...SENÃO ........................................................... 53
Figura 38 – Algoritmo Aplicando o Comando ESCOLHA...CASO................................................................. 54
Figura 39 – Sintaxe do Comando Condicional ESCOLHA CASO – Outra sintaxe 2...................................... 54
Figura 40 – Exemplo de Algoritmo usando Escolha Caso ........................................................................... 55
Figura 41 – Exemplo de Algoritmo usando Escolha Caso ........................................................................... 56
Figura 42 – Exemplo de Algoritmo de Tabuada Sem Comando de Repetição ........................................... 59
Figura 43 – Saída na tela do Algoritmo da Figura 42.................................................................................. 59
Figura 44 – Categorização dos Comandos de Repetição ........................................................................... 61
Figura 45 – Fluxograma de Comando de Repetição PARA ......................................................................... 62
Figura 46 – Pseudocódigo do Comando de Repetição PARA ..................................................................... 62
Figura 47 – Exemplo Do PARA...FAÇA Sem A Cláusula PASSO ................................................................... 63
Figura 48 – Mensagens Impressas Na Tela Após Execução do Algoritmo da Figura 47............................. 63
Figura 49 – Pseudocódigo do Comando de Repetição PARA ..................................................................... 64
Figura 50 – Exemplo Do PARA...FAÇA com A Cláusula PASSO ................................................................... 64
Figura 52 – Exemplo Do PARA...FAÇA Sem A Cláusula PASSO ................................................................... 65
Figura 54 – Exemplo de Algoritmo usando Comando de Repetição PARA ................................................ 66
Figura 55 – Exemplo de Somatório de 1 a 50 usando Comando de Repetição PARA ................................ 66
Figura 56 – Exemplo de Somatório de 1 a N usando Comando de Repetição PARA ................................. 67
Figura 57 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando a Cláusula PASSO ..................... 67
Figura 58 – Exemplo de Somatório dos múltiplos de 3 de 1 a N SEM a Cláusula PASSO .......................... 68

Figura 61 – Exemplo de Algoritmo Tabuada, usando PARA ....................................................................... 70
Figura 62 – Algoritmo atualizar_preco, usando PARA .................................................................................. 70
Figura 63 – Fluxograma de Comando Repetição ENQUANTO ................................................................... 71
Figura 64 – Pseudocódigo do Comando de Repetição ENQUANTO ........................................................... 71
Figura 65 – Exemplo genérico de Comando Repetição ENQUANTO.......................................................... 72
Figura 66 – Algoritmo de Comando ENQUANTO...FAÇA Para Escreva de 1 a 10 na tela ........................... 73
Figura 67 – Tela De Saída Após Execução do Algoritmo da Figura 66........................................................ 74
Figura 68 – Algoritmo que imprime de 50 a 20 aplicando ENQUANTO...FAÇA ......................................... 75
Figura 69 – Exemplo de Algoritmo, usando Comando de Repetição ENQUANTO ..................................... 75
Figura 70 – Algoritmo Soma usando ENQUANTO ...................................................................................... 76
Figura 71 – Exemplo de Somatório de 1 a N usando Comando de Repetição ENQUANTO ....................... 76
Figura 72 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando ENQUANTO ............................. 77
Figura 73 – Exemplo de Somatório de 1 a N usando Comando de Repetição ENQUANTO ....................... 77
Figura 74 – Exemplo de Algoritmo, usando Comando de Repetição ENQUANTO ..................................... 77
Figura 75 – Algoritmo atualizar_preco, usando ENQUANTO ..................................................................... 79
Figura 76 – Algoritmo Imprimir Maior Número usando ENQUANTO ........................................................ 80
Figura 77 – Fluxograma de Comando Repetição REPITA ........................................................................... 81
Figura 78 – Pseudocódigo do Comando de Repetição REPITA .................................................................. 82
Figura 79 – Algoritmo de Comando ENQUANTO...FAÇA Para Escreva de 1 a 10 na tela ........................... 83
Figura 80 – Teste de Mesa do trecho REPITA ... ATÉ.................................................................................. 83
Figura 81 – Tela De Saída Após Execução do Algoritmo da Figura 66........................................................ 84
Figura 82 – Algoritmo que imprime de 50 a 20 aplicando REPITA...ATÉ.................................................... 85
Figura 83 – Exemplo de Algoritmo, usando Comando de Repetição REPITA...ATÉ ................................... 86
Figura 84 – Algoritmo Soma, usando REPITA...ATÉ .................................................................................... 86
Figura 85 – Exemplo de Somatório de 1 a N usando Comando de Repetição REPITA...ATÉ ..................... 87
Figura 86 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando REPITA...ATÉ ............................ 87

Figura 87 – Exemplo de Somatório de 1 a N usando Comando de Repetição REPITA...ATÉ ..................... 88
Figura 88 – Exemplo de Algoritmo, usando Comando de Repetição REPITA...ATÉ ................................... 88
Figura 89 – Algoritmo atualizar_preco, usando REPITA ............................................................................. 89
Figura 90 – Algoritmo Imprimir Maior Número usando ENQUANTO ........................................................ 89
Figura 91 – Algoritmo Media_Aluno, usando Comando de Repetição REPITA...ATÉ ................................ 93
Figura 92 – Algoritmo Media_Geral, usando Comando de Repetição REPITA...ATÉ ................................. 94
Figura 93 – Exemplo de Algoritmo usando Comando de Repetição REPITA ............................................. 95
Figura 94 – Algoritmo nomes_alunos ............................................................................................................. 95
Figura 95 – Representação Gráfica de um Vetor ....................................................................................... 96
Figura 96 – Declaração de Vetor em pseudocódigo................................................................................... 96
Figura 97 – Exemplo de Declaração de um Vetor de 5 posições do tipo inteiro ....................................... 97
Figura 98 – Vetor nome de 20 posições do tipo literal .............................................................................. 98
Figura 99 – Algoritmo nomes_alunos utilizando Vetor, entrada e saída de dados ................................... 98
Figura 100 – Algoritmo nomes_alunos utilizando Vetor, processando dados........................................... 99
Figura 101 – Representação de uma Matriz 5X10 ................................................................................... 101
Figura 102 – Declaração de matriz em pseudocódigo ............................................................................. 102
Figura 103 – Exemplo de Declaração de uma Matriz 5X10 do tipo inteiro .............................................. 102
Figura 104 – Declaração de Matrizes de diferentes dimensões .............................................................. 103
Figura 105 – Atribuição de valores a Matriz M ........................................................................................ 104
Figura 106 – Representação de uma Matriz 5X10 ................................................................................... 104
Figura 107 – Entrada de dados em uma Matriz 3X5 ................................................................................ 105
Figura 108 – Representação da Matriz num após atribuição de valores ................................................. 106
Figura 109 – Entrada e Saída de dados em uma Matriz 5X10 .................................................................. 106
Figura 110 – Algoritmo para somar número 5 a cada posição de uma matriz [5,10] .............................. 107
Figura 111 – Algoritmo para somar os elementos da linha 2 e multiplicar os elementos da coluna 3 ... 108
Figura 112 – Algoritmo para encontrar maior valor da matriz e multiplicá-lo pela matriz ..................... 109
Figura 113 – Algoritmo para somar duas matrizes .................................................................................. 110

Figura 114 – Declaração de Registro em pseudocódigo .......................................................................... 112
Figura 115 – Declaração de Registro Aluno ............................................................................................. 112
Figura 116 – Declaração de Registro Produto .......................................................................................... 112
Figura 117 – Representação Gráfica do Registro reg_aluno .................................................................... 113
Figura 118 – Representação Gráfica do Registro produto ....................................................................... 113
Figura 119 – Exemplo de comandos para manipular o Registro produto................................................ 113
Figura 120 – Representação Gráfica do Registro produto após atribuições............................................ 113
Figura 121 – Entrada e Saída de Dados – Registro Produto ..................................................................... 114
Figura 122 – Declaração de um Vetor de Registros para Aluno............................................................... 115
Figura 123 – Declaração de um Vetor de Registro para Produtos ........................................................... 115
Figura 124 – Representação Gráfica do Vetor de Registros produto ...................................................... 116
Figura 125 – Exemplo de comandos para manipular o Vetor de Registros produto ............................... 117
Figura 126 – Operações de Entrada e Saída, utilizando Vetor de Registros ............................................ 118
Figura 127 – Algoritmo produto_supermercado, usando Vetor de Registros .................................................. 118
Figura 128 – Algoritmo pesquisa, usando Vetor de Registros ...................................................................... 120
Figura 129 – Representação Gráfica de um algoritmo modularizado ..................................................... 121
Figura 130 – Exemplo de retorno de valor e parâmetro .......................................................................... 122
Figura 131 – Declaração de Procedimento .............................................................................................. 123
Figura 132 – Declaração de Variável em Procedimentos ......................................................................... 123
Figura 133 – Declaração do Procedimento SEPARADOR ......................................................................... 123
Figura 134 – Declaração do Procedimento IMPRIMIR ............................................................................. 124
Figura 135 – Declaração do Procedimento SEPARADOR ......................................................................... 124
Figura 138 – Chamada ao Procedimento SEPARADOR ............................................................................ 125
Figura 139 – Chamado ao Procedimento SEPARADOR ............................................................................ 126
Figura 140 – Algoritmo, usando Procedimento COM passagem de Parâmetros..................................... 127

Figura 141 – Exemplo de chamada de função ......................................................................................... 128
Figura 142 – Sintaxe para Declaração de Funções ................................................................................... 128
Figura 143 – Declaração de Variável em Funções .................................................................................... 128
Figura 144 – Algoritmo com chamada a Função com 2 parâmetros ....................................................... 129
Figura 145 – Declaração de Função SEM passagem de parâmetros ........................................................ 129
Figura 146 – Algoritmo com chamada a Função sem parâmetros........................................................... 130
Figura 147 – Declaração de Função COM passagem de parâmetros ....................................................... 130
Figura 148 – Algoritmo com chamada a Função COM parâmetros ......................................................... 131
Figura 149 – Algoritmo, usando Função CALC_SAL (com passagem de parâmetro) ............................... 132
Figura 151 – Memória do Computador com as Variáveis Globais ........................................................... 137
Figura 152 – Memória do Computador Contendo os Parâmetros X e Y .................................................. 137
Figura 153 – Variáveis Ocupando o Mesmo Espaço de Memória ............................................................ 139
Figura 154 – Memória do Computador com as Variáveis Globais ........................................................... 140
Figura 155 – Memória do Computador com Passagem de Parâmetros Por Referência.......................... 140
Figura 156 – Função Recursiva que calcula o fatorial de um número ..................................................... 142
Figura 157 – Procedimento Recursivo que imprime um número em ordem decrescente...................... 143
Figura 158 – Procedimento Recursivo que imprime um número em ordem crescente .......................... 144
Figura 159 – Função Recursiva para obter a série de Fibonacci .............................................................. 144

18 ÍNDICE DE TABELAS
Tabela 1 - Execução do algoritmo de Euclides para calcular o MDC dos números 48 e 30 ......................... 8
Tabela 2 - Execução do algoritmo de Erastótenes para encontrar os números primos de 2 a 30 ............... 9
Tabela 3 – Simbologia utilizada em Fluxogramas ...................................................................................... 14
Tabela 4 – Tipo de Dados ........................................................................................................................... 24
Tabela 5 - Exemplo de nomes válidos e inválidos ...................................................................................... 26
Tabela 6 – Operadores Aritméticos............................................................................................................ 31
Tabela 7 – Hierarquia das Operações Aritméticas ..................................................................................... 31
Tabela 8 – Funções pré-definidas ............................................................................................................... 32
Tabela 9 – Operadores Relacionais ............................................................................................................ 38
Tabela 10 – Operadores Relacionais aplicados ao tipo INTEIRO................................................................ 38
Tabela 11 – Operadores Relacionais aplicados ao tipo REAL ..................................................................... 38
Tabela 12 – Operadores Relacionais aplicados ao tipo CARACTERE .......................................................... 39
Tabela 13 – Operadores Relacionais aplicados a CARACTERES maiúsculo e minúsculo ............................ 39
Tabela 14 – Operadores Relacionais aplicados ao tipo LITERAL ................................................................ 39
Tabela 15 – Operadores Lógicos ................................................................................................................ 41
Tabela 16 – Variação de Sintaxe para o Comando ESCOLHA...CASO ......................................................... 54

19 RELAÇÃO DE ÍCONES
Indicadores de ações requisitadas durante o estudo
FAÇA. Determina a existência de tarefa a ser executada. Este ícone indica que há uma
atividade de estudo para ser realizada.
BUSQUE. Indica a exigência de busca por mais informação, seja ela em anexos do módulo
impresso, em bibliografia específica ou em endereços de Internet.
REFLITA. Indica a necessidade de se pensar mais detidamente sobre o(s) assunto(s)

abordado(s) e suas relações com o objeto de estudo.
SAIBA MAIS. Apresenta informações adicionais sobre o tema abordado de forma a

possibilitar a obtenção de novas informações ao que já foi referenciado.
REVEJA. Indica a necessidade de rever conceitos ou procedimentos abordados

anteriormente.
ACESSE. Indica a necessidade de acessar endereço(s) específico(s), apontado(s) logo após o

ícone.
COMUNIQUE-SE. Indica a necessidade de diálogo com o tutor e/ou com os colegas.
TRABALHE EM EQUIPE. Indica a necessidade de ação colaborativa para a execução de

atividade(s).
CONCLUSÃO OU CONSIDERAÇÕES FINAIS. Todas as unidades de estudo se encerram com

uma síntese das principais ideias abordadas, conclusão ou considerações finais acerca do
que foi tratado.
IMPORTANTE. Aponta uma observação significativa. Pode ser encarado como um sinal de
alerta que o orienta para prestar atenção à informação indicada.
EXEMPLO OU CASO. Indica a existência de um exemplo ou estudo de caso, para uma

situação ou conceito que está em estudo.
SUGESTÃO DE LEITURA. Indica bibliografia de referência e também sugestões para leitura

complementar.
CHECKLIST ou PROCEDIMENTO. Indica um conjunto de ações (um passo a passo) a ser

realizado.
Ícones desenhados por Web Design Creatives Inc (http://www.webdesigncreatives.com/freebies/)


Apostila de Algoritmos e Estruturas de Dados

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila de Algoritmos e Estruturas de Dados

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos e Estruturas de Dados I

Tecnologias de Informação e Comunicação na Educação

Prof. Antônio Maria e Profa. Ana Rubélia 1

Ficha catalográfica preparada pela Divisão de Processos

Espaço a ser preenchido pela biblioteca

Prof. Antônio Maria e Profa. Ana Rubélia 2

ALGORITMO E ESTRUTURAS DE DADOS I

1.1 Algoritmo ...................................................................................................................................... 7

1.2 Estrutura de Dados ..................................................................................................................... 10

1.3 Algoritmo e Estrutura de Dados ................................................................................................. 12

1.4 Orientações para um Melhor Aprendizado de AED ................................................................... 13

2.1 Notações para Construção de Algoritmos.................................................................................. 14

2.1.1 Notação em Descrição Narrativa........................................................................................ 14

2.1.2 Notação Gráfica .................................................................................................................. 14

2.1.3 Notação em Pseudocódigo ................................................................................................. 16

2.1.4 EXERCÍCIOS PROPOSTOS .................................................................................................... 17

2.2 Teste de Mesa ............................................................................................................................ 18

2.3 Fases de desenvolvimento de um Algoritmo ............................................................................. 19

3 ALGORITMOS EM PSEUDOCÓDIGO .................................................................................................... 21

3.1 Estrutura Básica de um Algoritmo.............................................................................................. 21

4 DECLARAÇÃO DE VARIÁVEIS E CONSTANTES ..................................................................................... 22

4.1 Variáveis ..................................................................................................................................... 22

4.1.1 Tipos de Dados ................................................................................................................... 24

4.1.2 EXERCÍCIO PROPOSTO ........................................................................................................ 25

4.2 Constantes .................................................................................................................................. 25

4.3 Regras para nomear Variáveis, Constantes e Algoritmos .......................................................... 26

4.3.1 EXERCÍCIOS PROPOSTOS .................................................................................................... 27

5 COMANDOS SEQUENCIAIS ................................................................................................................. 28

5.1 Comando de Entrada .................................................................................................................. 28

5.2 Comando de Saída ...................................................................................................................... 28

5.3 Comando de Atribuição .............................................................................................................. 29

Prof. Antônio Maria e Profa. Ana Rubélia 3

5.4 Boas Práticas para os Comandos Sequenciais............................................................................ 30

5.5 Operadores e Funções pré-definidas ......................................................................................... 31

5.5.1 Operadores Aritméticos ..................................................................................................... 31

5.5.2 Funções pré-definidas ........................................................................................................ 32

5.5.3 EXERCÍCIOS PROPOSTOS .................................................................................................... 35

6 COMANDOS CONDICIONAIS ............................................................................................................... 37

6.1 Operadores Relacionais e Lógicos .............................................................................................. 37

6.1.1 Operadores Relacionais ...................................................................................................... 38

6.1.2 Operadores Lógicos ............................................................................................................ 40

6.1.3 EXERCÍCIO PROPOSTO ........................................................................................................ 42

6.2 Comando Condicional Simples SE ... ENTÃO .............................................................................. 42

6.3 Comando Condicional Composto SE ... ENTÃO ... SENÃO .......................................................... 43

6.5 Aninhamento de Comandos SE...ENTÃO...SENÃO ..................................................................... 48

6.6 Comando Condicional ESCOLHA ... CASO ................................................................................... 52

6.6.1 EXERCÍCIOS PROPOSTOS .................................................................................................... 57

8 Comando de Repetição: Número Definido de Repetições e Teste de Condição no Início ................ 61

8.1 Comando de REPETIÇÃO PARA ... FAÇA ..................................................................................... 61

9 Comando de Repetição: Número Indefinido de Repetições e Teste de Condição no Início .............. 71

9.1 Comando de REPETIÇÃO ENQUANTO ... FAÇA ........................................................................... 71

9.1.1 Peculiaridades Importantes do ENQUANTO..FAÇA ............................................................ 72

9.1.2 Loop Infinito ....................................................................................................................... 74

10 Comando de Repetição: Número Indefinido de Repetições e Teste de Condição no Final ........... 81

10.1 Comando de repetição REPITA ... ATÉ........................................................................................ 81

10.1.1 Peculiaridades Importantes do REPITA ... ATÉ ................................................................... 82

10.1.2 Loop Infinito ....................................................................................................................... 84

Prof. Antônio Maria e Profa. Ana Rubélia 4

10.1.3 EXERCÍCIOS PROPOSTOS .................................................................................................... 92

11 VARIÁVEIS COMPOSTAS HOMOGÊNEAS: VETORES E MATRIZES ................................................... 93

12.1 Representação Gráfica de um Vetor .......................................................................................... 96

12.2 Declaração de Vetor ................................................................................................................... 96

12.3 Manipulação de Dados de um Vetor .......................................................................................... 97

12.4 Operações de Entrada e Saída de dados em um Vetor .............................................................. 97