APOSTILA DE ALGORITMO E PROGRAMAÇÃO DE COMPUTADORES

Prévia do material em texto

Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 1 
 
 
 
 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 2 
 
 
 
 
 
Espaço a ser preenchido pela biblioteca 
 
 
Ficha catalográfica preparada pela Divisão de Processos 
Técnicos da Biblioteca Central da UFLA 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 3 
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 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 4 
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.4 Indentação .................................................................................................................................. 46 
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 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 5 
10.1.3 EXERCÍCIOS PROPOSTOS .................................................................................................... 92 
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 
13.5.1 EXERCÍCIOS PROPOSTOS .................................................................................................. 111 
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 
14.8.1 EXERCÍCIOS PROPOSTOS .................................................................................................. 120 
15 MODULARIZAÇÃO: PROCEDIMENTOS E FUNÇÕES ...................................................................... 121 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 6 
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 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 7 
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. 
 
Figura1 - Algoritmo de Euclides para calcular o MDC 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 8 
 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; 
30 18 12 
Passo 2 - Valor de b colocado em a; 
Passo 3 - Valor de r colocado em b;. 
Passo 1- Divide-se novamente a por b colocando o resto em r; 
18 12 6 
Passo 2 - Valor de b colocado em a; 
Passo 3 - Valor de r colocado em b;. 
Passo 1- Divide-se novamente a por b colocando o resto em r; 
12 6 0 
Passo 2 - Valor de b colocado em a; 
Passo 3 - Valor de r colocado em b;. 
Passo 1- Divide-se novamente a por b colocando o resto em r; 
6 0 -X- 
Passo 2 - Valor de b colocado em a; 
Passo 3 - Valor de r colocado em b;. 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 9 
 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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 10 
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; 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 11 
- 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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 12 
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 
definidosque 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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 13 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 14 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 15 
 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 16 
 
 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 17 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 18 
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 determinao 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 19 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 20 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 21 
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. 
 
 
Algoritmo <nome do algoritmo>; 
[Const <declare uma constante>;] 
[Declare <declare uma variável>;] 
Início 
 <comandos>; 
 Fim. 
 /*Este algoritmo calcula a área de um círculo 
qualquer e imprime o resultado */ 
Algoritmo AreaCirculo; // π*r2 
Declare area, R: real; 
Início 
 R  2; // raio recebe o valor 2 
 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 22 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 23 
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. 
 
 
Algoritmo teste2; 
Declare salario, comissao: real; 
Início 
 salario  1200,00; 
 Escreva (“Entre com valor da comissão: “); 
 Leia (comissao); 
 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 
 
 
 
Após a execução da instrução: salario  salario + comissao; 
 
 
 
 1 2 3 4 5 6 7 
1 700,00 
2 
3 1900,00 
4 
 
Figura 15 – Representação de criação de variáveis na memória do computador 
salario 
comissao 
Nome da variável 
Valor da variável 
Alterando o valor 
da variável 
salario 
comissao 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 24 
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 saberquais 
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; 
Caractere 
Armazena um único (1) caractere podendo ser letras 
maiúsculas, minúsculas, números (não utilizados 
para cálculos) e caracteres especiais como (&, #, $, 
@, [, {, dentre outros). O caractere sempre é 
representado entre aspas simples. 
„1‟; „L‟; „a‟; „!‟; „%‟; „~‟ 
Literal 
Armazena um conjunto de caracteres como um nome 
de pessoa, data, cor, descrição de um produto, etc. 
Uma literal sempre é representado entre aspas 
simples ou dupla. 
“PEDRO”; “Rua das Flores”; 
“São Paulo”; “Amarelo”; “Pacote 
de Macarrão 500gr”; “21/12/2011” 
Lógico Armazena o valor verdadeiro ou falso 
V; F; Verdadeiro; 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 25 
 
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 
2-Real 
3-Caractere 
4-Literal 
5-Lógico 
( ) „K‟ 
( ) V 
( ) „V‟ 
( ) 2,1345 
( ) „mecanismo de destruição‟ 
( ) 325.472 
( ) „21/02/2548‟ 
( ) „02/02/22‟ 
( ) „*‟ 
( ) -352,254 
( ) „Roxo‟ 
( ) falso 
( ) -95 
( ) „-95‟ 
( ) „6‟ 
( ) „234‟ 
( ) „a‟ 
( ) „aaaa‟ 
( ) „$‟ 
( ) „UFLA‟ 
( ) „325.654.387,35987412569874521‟ 
( ) 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. 
 
 
Algoritmo teste; 
Const pi = 3,1415; 
 e = 2,71828; 
Declare idade : inteiro; 
 salario : real; 
Início 
 <comandos>; 
Fim. 
Figura 16 - Exemplo de declarações de constantes 
nome da constante 
valor da constante 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 26 
 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 27 
 
4.3.1 EXERCÍCIOS PROPOSTOS 
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 
( ) nome aluno 
( ) _d20 
( ) Minimo 
( ) aula_03 
( ) SALARIO 
( ) nota*final 
( ) km/h 
( ) “nota” 
( ) cia3a3 
( ) xyz 
( ) Data_Nascimento 
( ) achou! 
( ) A + B 
( ) 3notas 
( ) nota_bimestral 
( ) e-mail 
( ) estado_civil( ) 
( ) comissao% 
( ) nota_bimestral 
( ) 360hs 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 28 
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” */ 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa.Ana Rubélia 29 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 30 
 
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 
fazer 
// pois não foi enviada mensagem a ele 
Leia(nome); 
// Envia mensagem e lê o nome 
Escreva(“Nome: ”); 
Leia(nome); 
 
// Usuário não sabe se temperatura é C, F ou K. 
Escreva(“Digite a temperatura: ”); 
Leia(temp); 
// Envia mensagem e lê o salário 
Escreva(“Digite a temperatura em Celsius: ”); 
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 
não 
// sabe se é em metros, centímetros etc. 
Escreva(“Altura: ”, altura); 
// Informar a unidade de medida e o que o dado 
// representa 
Escreva(“Altura: “, altura, “ (metros)”); 
// Usuário vê um número na tela e não sabe do 
que se trata. 
Escreva(temperatura); 
// Informar a temperatura explicitando ser em 
Celsius. 
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. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 31 
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) 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 32 
Exemplificando... 
 
area_triangulo  (Base * Altura) / 2; 
X  5*(7-9)+3*7; 
Z  1 + 7 * 2 ** 3 –1; 
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 
 
X=11 
Z=56 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 33 
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; 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 34 
 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ível3) 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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 35 
 
5.5.3 EXERCÍCIOS PROPOSTOS 
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 + B + Z 
( ) NOME + RUA 
( ) A B 
( ) A Y 
( ) NOME RUA 
( ) A + B / C 
( ) A + X / Z 
( ) A + Z / A 
( ) A B = L1 
( ) (A = B) 
( ) X + Y / Z 
 ( ) X = Z / A 
( ) L1 ** L2 
( ) A + B / L2 
( ) 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ê. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 36 
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 
b) X
3 
– 4 
c) (X * Y)
 2
 
d) X
Y 
+ 2 
e) Raiz quadrada de Y
 
 
 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 37 
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. 
 
 
 
 
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. 
Escrever ( “ X é maior ou igual a 10”) 
Escrever ( “ X é ,menor a 10” ) 
 X >= 10 ? 
sim 
não 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 38 
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 
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 
. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 39 
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: 
Expressão Resultado 
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: 
Expressão Resultado 
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 
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 
. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 40 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 41 
 
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 x E y 
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 
. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 42 
 
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. 
 
... 
SE (condição) ENTÃO 
 comando 1; 
 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 
; (ponto e vírgula) marca o 
fim deste comando. 
 ; (ponto e vírgula) marca o 
fim do comando SE. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 43 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 44 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 45 
 Exercícios Resolvidos: 
 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 46 
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 entendimentode 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 47 
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; 
INÍCIO 
 Escreva (“Digite um número: ”); 
 Leia (x); 
 
 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. 
 
As 3 linhas de comando do 
ENTÃO foram indentadas para 
facilitar a visualização. E o 
mesmo foi feito para o SENÃO. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 48 
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); 
 
 SE (x>y) ENTÃO 
escreva (x,“ é maior que “, y); 
 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 
Comando SE...ENTÃO...SENÃO dentro 
de outro comando SE...ENTÃO...SENÃO 
denomina-se aninhamento. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 49 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 50 
Exercícios Resolvidos: 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 51 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 52 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 53 
 
ESCOLHA <variável> 
 CASO 1: < comandos >; 
 CASO 2: < comandos >; 
 CASO 3: < 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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 54 
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. 
Caso 2, 7, 21: 
Verifica se o valor é um dos valores contidos na lista 2, 7, 9, 21. Portanto, o valor 
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 1: < comandos >; 
 CASO 2, 4: < comandos >; 
 CASO 3: < comandos >; 
 CASO 5 ..10: < comandos >; 
 CASO CONTRÁRIO: < comandos >; 
FIMESCOLHA; 
... 
Figura 39 – Sintaxe do Comando Condicional ESCOLHA CASO – Outra sintaxe 2 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 55 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 56 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 57 
 
6.6.1 EXERCÍCIOS PROPOSTOS 
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 
a) X 8; Y10; Z3; 
(X = Y) E (Y > Z) 
b) X13; Y 2; Z5; 
(X <> Y) OU (Y < Z) 
c) X 4; Y 7; Z9; 
 NÃO (X > Y) 
d) X 6; Y 4; Z4; 
(X < Y) E (Y > Z) 
e) X „a‟; Y „k‟; Z‟D‟; 
(X >= Y) OU (Y = Z) 
f) X “Rosana”; Y “Roseane”; Z”Rosária”; 
NÃO (X <= Y) 
 
2) Para as variáveis a seguir e seus respectivos valores: 
a  1 
b  2 
c  3 
 
x  3.0 
y  2.0 
z  -1.0 
 
L1  V 
nome  “PEDRO” 
rua  “PEDRINHO” 
L2  F 
Determine o resultado das expressões a seguir: 
a) a + c / b 
b) a + b + c 
c) c / b / a 
d) -x ** b 
e) - (x ** b) 
f) (-x) ** b 
g) nome + rua 
h) nome = rua 
i) L1 OU L2 
j) (L1 E(NÃO L2)) 
k) (L2 E (NÃO L1)) 
l) (L1 E (NÃO L2)) OU (L2 E (NÃO L1)) 
m) (x -y) E (c - b) 
n) (c - 3 * a) (x + 2 * z) 
o) rua <> nome
 
3) Elabore um algoritmo para receber 3 números e mostre o maior. 
 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 58 
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 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 59 
7 COMANDOS DE REPETIÇÃO 
Para compreender a necessidade de comandosde 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: 
0 x 5 = 0 
1 x 5 = 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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 60 
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É 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 61 
 
 
 
 
 
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. 
Número de Repetições Definidas 
Número de Repetições Indefinidas Teste de Condição no Início 
Teste de Condição no Final 
 
Teste de Condição no Início PARA...FAÇA 
ENQUANTO...FAÇA 
Condição no Início 
REPITA...ATÉ 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 62 
 
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; 
... 
PARA contador DE <valor inicial> ATÉ <valor final> FAÇA 
 <instruções>; 
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. 
Contador 
utilizado no 
comando 
PARA...FAÇA 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 63 
 
... 
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 
o valor do contador é: 2 
o valor do contador é: 3 
o valor do contador é: 4 
o valor do contador é: 5 
o valor do contador é: 6 
o valor do contador é: 7 
o valor do contador é: 8 
o valor do contador é: 9 
o valor do contador é: 10 
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. Estaclá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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 64 
 
... 
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 
 escreva ( “o valor do contador é: ”, cont ); 
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: 
o valor do contador é: 1 
o valor do contador é: 4 
o valor do contador é: 7 
o valor do contador é: 10 
Saiu das repetições do PARA...FAÇA 
Figura 51 – Mensagens Impressas Na Tela Após Execução do Algoritmo da Figura 50 
Determina o valor de 
variação do contador 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 65 
Exemplificando... 
Faça um algoritmo que imprima na tela os números de 50 a 20. 
Algoritmo Inverso_50_20; 
Declare cont: inteiro; 
... 
PARA cont DE 50 ATÉ 20 PASSO -1 FAÇA 
 escreva ( “o valor do contador é: ”, cont ); 
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á: 
o valor do contador é: 50 
o valor do contador é: 49 
o valor do contador é: 48 
... 
... 
o valor do contador é: 22 
o valor do contador é: 21 
o valor do contador é: 20 
Saiu das repetições do PARA...FAÇA 
Figura 53 – Mensagens Impressas Na Tela Após Execução do Algoritmo da Figura 52 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 66 
 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. 
 
... 
Declare i : inteiro; 
 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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 67 
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 
 total  total + i; 
 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; 
Declare i, total, N : inteiro; 
Inicio 
 Escreva ("Digite valor de N: "); 
 Leia (N); 
 total  0; 
 PARA i de 0 ATÉ N PASSO 3 FAÇA 
 total  total + i; 
 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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 68 
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. 
Algoritmo Somatorio_3_de_1_N; 
Declare i, total, N, num : inteiro; 
Inicio 
 Escreva ("Digite valor de N: "); 
 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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 69 
 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; 
Declare cont: inteiro; 
 total : real; 
Inicio 
 Escreva ("Digite valor de N: "); 
 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. 
Figura 59 – Exemplo de Somatório de 1 a N usando Comando de Repetição PARA 
 
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 + ... 
Algoritmo Somatorio_fracao; 
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; 
 Escreva ("O somatório é: “, total); 
Fim. 
Figura 60 – Exemplo de Somatório de 1 a N usando Comando de Repetição PARA 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 70 
3. Construir um algoritmo que monte a tabuadade 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; 
Declare i : inteiro; 
 descricao : literal; 
 preco, n_preco : real; 
INICIO 
Escreva (“Este programa permite a atualização do preço em 20% de 30 
produtos.”); 
PARA i de 1 ATÉ 30 FAÇA 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 71 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 72 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 73 
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”. 
 
Algoritmo Escreve_ate_10; 
Declare cont: inteiro; 
Inicio 
 cont  1; 
 ENQUANTO (cont <= 10) FAÇA 
 escreva ( “o valor do contador é: ”, cont ); 
 cont  cont + 1; 
 FIM-ENQUANTO; 
 Escreva (“Saiu das repetições do 
ENQUANTO...FAÇA”); 
Fim. 
Figura 66 – Algoritmo de Comando ENQUANTO...FAÇA Para Escreva de 1 a 10 na tela 
 
Obrigatório adicionar 
algum valor ao 
contador dentro do 
ENQUANTO 
Obrigatório atribuir valor 
inicial ao contador 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 74 
A tela de saída após execução do algoritmo contido na Figura 66 será: 
o valor do contador é: 1 
o valor do contador é: 2 
o valor do contador é: 3 
o valor do contador é: 4 
o valor do contador é: 5 
o valor do contador é: 6 
o valor do contador é: 7 
o valor do contador é: 8 
o valor do contador é: 9 
o valor do contador é: 10 
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 possaocorrer 
uma repetição a mais ou a menos do projetado e/ou cálculos errados. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 75 
Exercícios Resolvidos: 
1. Faça um algoritmo que imprima na tela os números de 50 a 20. 
 
Algoritmo Inverso_50_20; 
Declare cont: inteiro; 
Inicio 
 cont  50; 
 ENQUANTO ( cont >=20 ) FAÇA 
 escreva ( “o valor do contador é: ”, cont ); 
 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); 
 Escreva ("Primeira nota:"); 
 Leia (n1); 
 Escreva ("Segunda nota:"); 
 Leia (n2); 
 media  (n1+n2)/2; 
 Escreva ("O aluno ",nome," teve média igual a: ",media); 
 cont  cont + 1; 
 FIM-ENQUANTO; 
Fim. 
Figura 69 – Exemplo de Algoritmo, usando Comando de Repetição ENQUANTO 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 76 
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. 
 
Algoritmo Somatorio_1_N; 
Declare i, total, N : inteiro; 
Inicio 
 Escreva ("Digite valor de N: "); 
 Leia (N); 
 total  0; 
 i  1; 
 ENQUANTO ( i <= N ) FAÇA 
 total  total + i; 
 i  i + 1; 
 FIM-ENQUANTO; 
 Escreva ("O somatório de 1 até “, N, “ é: “, total); 
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. 
 
Algoritmo Somatorio_3_de_1_N; 
Declare i, total, N: inteiro; 
Inicio 
 Escreva ("Digite valor de N: "); 
 Leia (N); 
 total  0; 
 i  0; 
 ENQUANTO ( i <= N ) FAÇA 
 total  total + i; 
 i  i + 3; 
 FIM-ENQUANTO; 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 77 
 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 + ... 
Algoritmo Somatorio_fracao; 
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; 
 cont  1; 
 ENQUANTO ( cont <= N ) FAÇA 
 total  total + ( numerador / denominador); 
 numerador  numerador + 5; 
 denominador  denominador + 2; 
 cont  cont + 1; 
 FIM-ENQUANTO; 
 Escreva ("O somatório é: “, total); 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 78 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 79 
Exercícios Resolvidos: 
 
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”. 
 
Algoritmo atualizar_preco; 
Declare resposta: caracter; 
 descricao : literal; 
 preco, n_preco : real; 
INICIO 
Escreva (“Digite S para atualizar o preço ou N para sair”); 
resposta  „S‟; 
ENQUANTO ( resposta = „S‟ ) ou ( resposta = „s‟ ) FAÇA 
Escreva(“Descrição: “); 
Leia (descricao); 
Escreva(“Preço Atual: “); 
Leia (preco); 
n_preco  preco * 1.30; 
Escreva(“O novo preço de “,descricao,” é = “, n_preco); 
Escreva (“Digite S para atualizar o preço ou N para sair”); 
leia (resposta); 
FIM-ENQUANTO; 
FIM. 
Figura 75 – Algoritmo atualizar_preco, usando ENQUANTO 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 80 
2. Faça um algoritmo que leia 20 números inteiros positivos e imprima na tela o maior. 
 
Algoritmo atualizar_preco; 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 81 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 82 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 83 
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; 
Declare cont: inteiro; 
Inicio 
 cont  1; 
 REPITA 
 escreva ( “o valor do contador é: ”, cont ); 
 cont  cont + 1; 
 ATÉ ( cont > 10 ); 
 Escreva (“Saiu das repetições do REPITA...ATÉ”); 
Fim. 
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 é: 2 2 + 1 = 3 3 é > 10 ? NÃO 
o valor do contador é: 3 3 + 1 = 4 4 é > 10 ? NÃO 
o valor do contador é: 4 4 + 1 = 5 5 é > 10 ? NÃO 
o valor do contador é: 5 5 + 1 = 6 6 é > 10 ? NÃO 
o valor do contador é: 6 6 + 1 = 7 7 é > 10 ? NÃO 
o valor do contador é: 7 7 + 1 = 8 8 é > 10 ? NÃO 
o valor do contador é: 8 8 + 1 = 9 9 é > 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É 
 
Obrigatório adicionar 
algum valor ao 
contador dentro do 
REPITA 
Obrigatório atribuir 
valor inicial ao contador 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 84 
A tela de saída após execução do algoritmo contido na Figura 66 será: 
o valor do contador é: 1 
o valor do contador é: 2 
o valor do contador é: 3 
o valor do contador é: 4 
o valor do contador é: 5 
o valor do contador é: 6 
o valor do contador é: 7 
o valor do contador é: 8 
o valor do contador é: 9 
o valor do contador é: 10 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 85 
Exemplificando... 
Faça um algoritmo que imprima na tela os números de 50 a 20. 
 
Algoritmo Inverso_50_20; 
Declare cont: inteiro; 
Inicio 
 cont  50; 
 REPITA 
 escreva ( “o valor do contador é: ”, cont ); 
 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É. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 86 
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. 
 
Algoritmo Media_Aluno; 
Declare cont : inteiro; 
 nome: literal; 
 n1, n2 : real; 
Inicio 
 cont  1; 
 REPITA 
 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); 
 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É 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 87 
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; 
 i  1; 
 REPITA 
 total  total + i; 
 i  i + 1; 
 ATÉ ( i > N ); 
 Escreva ("O somatório de 1 até “, N, “ é: “, total); 
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. 
 
Algoritmo Somatorio_3_de_1_N; 
Declare i, total, N: inteiro; 
Inicio 
 Escreva ("Digite valor de N: "); 
 Leia (N); 
 total  0; 
 i  0; 
 REPITA 
 total  total + i; 
 i  i + 3; 
 ATÉ ( i > N ); 
 Escreva ("O somatório dos múltiplos de 3 de 1 até “, N, “ é: “, 
total); 
Fim. 
Figura 86 – Exemplo de Somatório dos múltiplos de 3 de 1 a N Usando REPITA...ATÉ 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 88 
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 + ... 
 
Algoritmo Somatorio_fracao; 
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; 
 cont  1; 
 REPITA 
 total  total + ( numerador / denominador); 
 numerador  numerador + 5; 
 denominador  denominador + 2; 
 cont  cont + 1; 
 ATÉ ( cont > N ); 
 Escreva ("O somatório dos múltiplos de 3 de 1 até “, 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É 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 89 
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”. 
 
Algoritmo atualizar_preco; 
Declare resposta: caracter; 
 descricao : literal; 
 preco, n_preco : real; 
INICIO 
Escreva (“Digite S para atualizar o preço ou N para sair”); 
resposta  „S‟; 
REPITA 
Escreva(“Descrição: “); 
Leia (descricao); 
Escreva(“Preço Atual: “); 
Leia (preco); 
n_preco  preco * 1.30; 
Escreva(“O novo preço de “,descricao,” é = “, n_preco); 
Escreva (“Digite S para atualizar o preço ou N para sair”); 
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. 
 
Algoritmo atualizar_preco; 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 90 
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 
Escreva (“Digite um número: ”); 
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; 
Declare soma, num, media: real; 
 cont : inteiro; 
INICIO 
soma  0; 
cont  1; 
REPITA 
Escreva (“Digite um número: ”); 
leia (num); 
soma  soma + num; 
cont  cont + 1; 
Media  soma / cont ; 
ATÉ cont > 50; 
Escreva(“A média dos números digitados é: “, media); 
FIM. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 91 
Usando o PARA: 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; 
PARA cont de 1 ATÉ 50 FAÇA 
Escreva (“Digite um número: ”); 
leia (num); 
soma  soma + num; 
Media  soma / cont ; 
FIMPARA; 
Escreva(“A média dos números digitados é: “, media); 
FIM. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 92 
 
10.1.3 EXERCÍCIOS PROPOSTOS 
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. (1
2 
+ 1)/1 + (2
2 
+ 1)/3 + (3
2 
+ 1)/5 + (4
2 
+ 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. 
 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 93 
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çãorepetitiva 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. 
 
Algoritmo Media_Aluno; 
Declare cont : inteiro; 
 nome: literal; 
 n1, n2 : real; 
Inicio 
 cont  1; 
 REPITA 
 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); 
 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); 
Escreva(“Nota 2: ”); 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 94 
Leia(n2); 
 
Escreva(“Nome: ”); 
Leia(nome2); 
Escreva(“Nota 1: ”); 
Leia(n3); 
Escreva(“Nota 2: ”); 
Leia(n4); 
 
Escreva(“Nome: ”); 
Leia(nome3); 
Escreva(“Nota 1: ”); 
Leia(n5); 
Escreva(“Nota 2: ”); 
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; 
Escreva(nome2, n3, n4, Media); 
 
Media  (n5+n6)/2; 
Escreva(nome3, n5, n6, Media); 
 
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). 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 95 
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 
PARA i de 1 ATÉ 20 FAÇA 
 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. 
Algoritmo nomes_alunos; 
Declare nome : literal; 
 i : inteiro; // declaração do contador 
 INICIO 
PARA i de 1 ATÉ 20 FAÇA 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 96 
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 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. 
V[2] V[3] V[4] 
V[5] 
V[1] 
índices 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 97 
 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ídade 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 98 
A declaração desse nosso Vetor ficará assim: 
... 
Declare nome [20]: literal; 
... 
 
 
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... 
 
Algoritmo nomes_alunos; 
Declare nome [20]: literal; /* trocamos a variável nome: literal por um 
vetor de tamanho 20 do tipo literal */ 
 i : inteiro; 
INICIO 
 Escreva ("Entre com o nome dos Alunos”); 
PARA i de 1 ATÉ 20 FAÇA 
Escreva ("Aluno ", i, ":"); //solicita os nomes dos alunos um a um 
Leia (nome[ i ]); //os dados são armazenados um a um, no vetor 
FIMPARA; 
 
PARA i de 1 ATÉ 20 FAÇA 
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. 
nome[1] 
Entrada dos 
dados 
 
Saída dos 
dados 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 99 
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 
Escreva ("Valor ", i, ":"); 
Leia (Num[ i ]); 
FIMPARA; 
 
PARA i de 1 ATÉ 10 FAÇA 
Num[i]  Num[i] * 3; // multiplica cada valor por três, guardando o resultado no próprio vetor. 
FIMPARA; 
PARA i de 1 ATÉ 10 FAÇA 
Escreva (“Valor: ”, Num[ i ]); 
FIMPARA; 
FIM. 
Figura 100 – Algoritmo nomes_alunos utilizando Vetor, processando dados 
Processamento dos 
dados 
 
Saída dos 
dados 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 100 
 
12.5.1 EXERCÍCIOS PROPOSTOS 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 101 
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 
 2 
 3 
 4 
 5 
 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. 
M[1,1] M[1,2] M[1,10] 
M[5,10] 
M[5,1] 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 102 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 103 
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. 
 Figura104 – 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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 104 
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... 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 105 
 
Algoritmo entrada_matriz; 
Declare num [3, 5] : inteiro; 
 i, j : inteiro; 
INICIO 
PARA i de 1 ATÉ 3 FAÇA 
 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 tela 
Na memória 
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 
 3 Digite os valores da posição[ 1 e 3]: 2 
 4 Digite os valores da posição[ 1 e 4]: -5 
 5 Digite os valores da posição[ 1 e 5]: 48 
2 1 Digite os valores da posição[ 2 e 1]: -6 
 2 Digite os valores da posição[ 2 e 2]: 0 
 3 Digite os valores da posição[ 2 e 3]: 100 
 4 Digite os valores da posição[ 2 e 4]: -27 
 5 Digite os valores da posição[ 2 e 5]: 154 
3 1 Digite os valores da posição[ 3 e 1]: 23 
 2 Digite os valores da posição[ 3 e 2]: 1 
 3 Digite os valores da posição[ 3 e 3]: 5 
 4 Digite os valores da posição[ 3 e 4]: 87 
 5 Digite os valores da posição[ 3 e 5]: -51 
 
Entrada dos 
dados 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 106 
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 
PARA i de 1 ATÉ 3 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
Escreva ("Digite os valores da posição[ ",i, " e “ ,j, “]:"); 
Leia (num[ i, j ]); 
FIMPARA; 
FIMPARA; 
 
PARA i de 1 ATÉ 3 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
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 
 
Saída dos 
dados 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 107 
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 
 PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 10 FAÇA 
 Escreva ("Digite os valores da posição[ ",i, " e “ ,j, “]:"); 
 Leia (Num[ i, j ]; 
 FIMPARA; 
 FIMPARA; 
 
 // Soma o número 100 a cada valor armazenado 
 PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 10 FAÇA 
 Num[ i, j]  Num[ i, j] + 100; 
 FIMPARA; 
 FIMPARA; 
 
 // Imprime a saída 
 PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 10 FAÇA 
 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] 
 
Processamento 
dos dados 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 108 
 Exercícios Resolvidos: 
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 
PARA i de 1 ATÉ 3 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 Escreva ("Digite os valores da posição[ ",i, " e “ ,j, “]:"); 
 Leia (mat [i,j] ); 
 FIMPARA; 
FIMPARA; 
 
Escreva ("Exibindo os valores digitados na matriz:"); 
PARA i de 1 ATÉ 3 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 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 
 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 Escreva ("Digite os valores da posição[ ",i, " e “ ,j, “]:"); 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 109 
 Leia (M [ i, j ] ); 
 FIMPARA; 
FIMPARA; 
 
maior  M [1,1]; 
 
 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 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...”); 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 RES [ i, j ]  maior * M [ i, j ] ; 
 FIMPARA; 
FIMPARA; 
 
Escreva (“A matriz resultante é: “); 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 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ÍCIOEscreva (“Lendo a matriz A.”); 
 
PARA i de 1 ATÉ 2 FAÇA 
 PARA j de 1 ATÉ 2 FAÇA 
 Escreva ("Digite os valores da Matriz A[ ",i, " e “ ,j, “]:"); 
 Leia (A [ i, j ] ); 
 FIMPARA; 
FIMPARA; 
 
Escreva (“Lendo a matriz B.”); 
PARA i de 1 ATÉ 2 FAÇA 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 110 
 PARA j de 1 ATÉ 2 FAÇA 
 Escreva ("Digite os valores da Matriz B[ ",i, " e “ ,j, “]:"); 
 Leia (B [ i, j ] ); 
 FIMPARA; 
FIMPARA; 
 
Escreva (“Somando as duas matrizes...”); 
 
PARA i de 1 ATÉ 2 FAÇA 
 PARA j de 1 ATÉ 2 FAÇA 
 RES [ i, j ]  A[ i , j] + B[ i , j ]; 
 FIMPARA; 
FIMPARA; 
 
Escreva (“A matriz A é: “); 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 Escreva (A [ i, j ]); 
 FIMPARA; 
FIMPARA; 
 
Escreva (“A matriz B é: “); 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 Escreva (B [ i, j ]); 
 FIMPARA; 
FIMPARA; 
 
Escreva (“A matriz resultante é: “); 
PARA i de 1 ATÉ 5 FAÇA 
 PARA j de 1 ATÉ 5 FAÇA 
 Escreva (RES [ i, j ]); 
 FIMPARA; 
FIMPARA; 
 
FIM. 
Figura 113 – Algoritmo para somar duas matrizes 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 111 
 
13.5.1 EXERCÍCIOS PROPOSTOS 
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. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 112 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 113 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 114 
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... 
 
Algoritmo registro_produto; 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 115 
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. 
Algoritmo registro_produto; 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 116 
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 
cod B002 
descricao tomada 
preco 1.99 
 
 
produto 
cod C024 
descricao abajur 
preco 85.00 
 
 
 
 
... 
 
produto 
cod H112 
descricao torradeira 
preco 122.00 
 
 
produto 
cod A223 
descricao fita 
preco 0.50 
 
1 2 ... 99 100 
Figura 124 – Representação Gráfica do Vetor de Registros produto 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 117 
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. 
Algoritmo registro_produto; 
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); 
 Escreva(“Entre com a Descrição do Produto: ”); 
 Leia(produto[ i ].descricao); 
 Escreva(“Entre com o Preço Unitário do Produto: ”); 
 Leia(produto[ i ].preco); 
 FIMPARA; 
 
 // Imprimindo os 100 registros Produto 
 PARA i DE 1 ATÉ 100 FAÇA 
 Escreva(“O Código do Produto é: ”, produto[ i ].cod); 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 118 
 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 
 Exercícios Resolvidos: 
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 
 PARA i DE 1 ATÉ 100 FAÇA 
 Escreva(“Entre com a Descrição do Produto: ”); 
 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. ”); 
 PARA i DE 1 ATÉ 100 FAÇA 
 SE (prod[ i ].qde > 20) ENTÃO 
 Escreva(prod[i].descricao); 
 FIMSE; 
 FIMPARA; 
 
 Escreva(“Produtos com data de vencimento menor que 2011. ”); 
 PARA i DE 1 ATÉ 100 FAÇA 
 SE (prod[ i ].venc < 2011) ENTÃO 
 Escreva(prod[i].descricao); 
 FIMSE; 
 FIMPARA; 
FIM. 
Figura 127 – Algoritmo produto_supermercado, usando Vetor de Registros 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 119 
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 
 PARA i DE 1 ATÉ 100000 FAÇA 
 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; 
 PARA i DE 1 ATÉ 100000 FAÇA 
 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; 
 PARA i DE 1 ATÉ 100000 FAÇA 
 SE (pesq[ i ].idade > maior) ENTÃO 
 maior  pesq[ i ].idade; 
 FIMSE; 
 FIMPARA; 
 Escreva(“A maior idade é: ”, maior); 
 
 SalF 0; 
 cont 0; 
 PARA i DE 1 ATÉ 100000 FAÇA 
 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; 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 120 
 SalF  (SalF / cont) ; 
 Escreva(“A média do salário das mulheres é: ”, SalF); 
FIM. 
Figura 128 – Algoritmo pesquisa, usando Vetor de Registros 
 
 
14.8.1 EXERCÍCIOS PROPOSTOS 
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. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 121 
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. 
 
 
 
 
 
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. 
Algoritmo 
Algoritmo 
Principal 
Procedimento 
1 
Procedimento 
 2 
Procedimento 
 n 
Função 
 1 
Função 
 2 
Função 
 n 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 122 
 
 
 
 
resp SQRT(25); 
 
 
 
 
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. 
parâmetro ou 
argumento 
A função retorna o 
valor 5 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 123 
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; 
PARA i de 1 ATÉ 20 FAÇA 
 escreva (“*”); 
FIMPARA; 
FIMPROCEDIMENTO; 
... 
Figura 133 – Declaração do Procedimento SEPARADOR 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 124 
Declaração do procedimento IMPRIMIR sem parâmetros. Este procedimento imprime 
todos os números de 1 até 1000. 
 
... 
PROCEDIMENTO IMPRIMIR ( ); 
declare i : inteiro; 
PARA i de 1 ATÉ 1000 FAÇA 
 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); 
declare i : inteiro; 
PARA i de 1 ATÉ 20 FAÇA 
 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); 
declare i : inteiro; 
PARA i de x1 ATÉ x2 FAÇA 
 escreva (i); 
FIMPARA; 
FIMPROCEDIMENTO; 
... 
Figura 136 – Declaração do Procedimento IMPRIMIR 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 125 
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); 
declare i : inteiro; 
escreva (“nome:”, nome); 
escreva (“salario:”, salario); 
escreva (“idade: ”, idade); 
FIMPROCEDIMENTO; 
... 
Figura 137 – Declaração do Procedimento IMPRIMIR 
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; 
 
PROCEDIMENTO SEPARADOR ( ); 
declare i : inteiro; 
PARA i de 1 ATÉ 20 FAÇA 
 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 126 
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; 
declare nome : literal; 
 simbolo: caractere; 
 
PROCEDIMENTO SEPARADOR ( ); 
declare i : inteiro; 
PARA i de 1 ATÉ 20 FAÇA 
 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ímbolopara 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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 127 
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; 
declare nome : literal; 
 
PROCEDIMENTO SEPARADOR (simbolo : caractere); 
declare i : inteiro; 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 128 
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>; 
declare < lista-de-variáveis> : <tipo>; 
<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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 129 
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); 
Escreva ("Digite o 2º número= ”); 
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>; 
declare < lista-de-variáveis> : <tipo>; 
<comandos>; 
retorne <valor de retorno>; 
FIMFUNCAO; 
... 
Figura 145 – Declaração de Função SEM passagem de parâmetros 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 130 
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”); 
Escreva ("Digite o 1º número= ”); 
Leia(X); 
Escreva ("Digite o 2º número= ”); 
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>; 
declare < lista-de-variáveis> : <tipo>; 
<comandos>; 
retorne <valor de retorno>; 
FIMFUNCAO; 
... 
Figura 147 – Declaração de Função COM passagem de parâmetros 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 131 
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!”); 
Escreva ("Digite o 1º número= ”); 
Leia(X); 
Escreva ("Digite o 2º número= ”); 
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çãoe 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; 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 132 
 O comando de chamada da função QUAD aparece no comando de atribuição () no do 
algoritmo principal. 
 
 Exercícios Resolvidos: 
 
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) 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 133 
 
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 
1 0% 
2 15% 
3 25% 
 
 
Código do produto Preço por grama 
1 a 4 R$ 10,00 
5 a 7 R$ 25,00 
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; 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 134 
 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; 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 135 
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; 
declare i : inteiro; 
PARA i de x1 ATÉ x2 FAÇA 
 escreva (i); 
FIMPARA; 
FIMPROCEDIMENTO; 
Figura 150 – Declaração do Procedimento IMPRIMIR 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 136 
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 oalgoritmo 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); 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 137 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 138 
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. 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 139 
 
 
 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. 
A B 
C 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 140 
 
 
 
 
 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. 
 
 
 
 
 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 
 
 
 
 
 
 
 
 
N1 N2 
N1 
N2 X Y 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 141 
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. 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 142 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 143 
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. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 144 
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 
O 2º termo somado ao 3º termo gera o 4º termo 
O 3º termo somado ao 4º termo gera o 5º 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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 145 
 
16.1.1 EXERCÍCIOS PROPOSTOS 
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. 
 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 146 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 147 
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 51 – Mensagens Impressas Na Tela Após Execução do Algoritmo da Figura 50 ............................. 64 
Figura 52 – Exemplo Do PARA...FAÇA Sem A Cláusula PASSO ................................................................... 65 
Figura 53 – Mensagens Impressas Na Tela Após Execução do Algoritmo da Figura 52 ............................. 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 59 – Exemplo de Somatório de 1 a N usando Comando de Repetição PARA ................................. 69 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 148 
Figura 60 – Exemplo de Somatório de 1 a N usando Comando de Repetição PARA ................................. 69 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 149 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 150 
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 136 – Declaração do Procedimento IMPRIMIR ............................................................................. 124 
Figura 137 –Declaração do Procedimento IMPRIMIR ............................................................................. 125 
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 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 151 
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 150 – Declaração do Procedimento IMPRIMIR ............................................................................. 135 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 152 
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 
 
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 153 
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/)
Algoritmos e Estruturas de Dados I 
Prof. Antônio Maria e Profa. Ana Rubélia 154