Upload
jotaulio
View
76
Download
3
Embed Size (px)
Citation preview
Apostila de Algoritmos e Estrutura de Dados
INDÍCE
PREFÁCIO........................................................................................................................................................3
CAPÍTULO 1 – FUNDAMENTOS...................................................................................................................4
1.1 CONCEITO DE ALGORITMO..........................................................................................................4
1.2 ESTRUTURA DE DADOS................................................................................................................5
1.3 ALGORITMO E PROGRAMAS DE COMPUTADOR....................................................................6
1.3.1 CLASSIFICAÇÃO DAS LINGUAGENS DE PROGRAMAÇÃO............................................7
1.3.2 COMPILADORES E INTERPRETADORES.............................................................................8
1.3.3 CRITÉRIOS DE QUALIDADE DE UM PROGRAMA DE COMPUTADOR.........................9
CAPÍTULO 2 – ESTRUTURAÇÃO DE ALGORITMOS.............................................................................10
2.1 FLUXOGRAMA...............................................................................................................................10
2.2 PSEUDOCÓDIGOS..........................................................................................................................11
2.3 FUNDAMENTOS PARA PROGRAMAÇÃO.................................................................................12
2.3.1 VARIÁVEIS..............................................................................................................................12
2.3.2 CONSTANTES..........................................................................................................................13
2.3.3 TIPO DE DADOS PRIMITIVOS..............................................................................................13
2.3.4 NOMENCLATURA DAS VARIÁVEIS...................................................................................14
2.3.5 OPERADORES ARITMÉTICOS..............................................................................................15
2.3.6 OPERADORES RELACIONAIS..............................................................................................16
2.3.7 OPERADORES LÓGICOS.......................................................................................................16
CAPÍTULO 3 – ESTRUTURAS DE CONTROLE.........................................................................................19
3.1 ESTRUTURA SEQUENCIAL.........................................................................................................19
3.2 ESTRUTURA CONDICIONAL.......................................................................................................22
3.2.1 ESTRUTURA CONDICIONAL SIMPLES..............................................................................23
3.2.2 ESTRUTURA CONDICIONAL COMPOSTA.........................................................................23
3.2.3 ESTRUTURA CONDICIONAL MÚLTIPLA ESCOLHA.......................................................24
3.3 ESTRUTURAS DE REPETIÇÃO....................................................................................................25
3.3.1 ESTRUTURA DE REPETIÇÃO PARA...................................................................................25
3.3.2 ESTRUTURA DE REPETIÇÃO ENQUANTO........................................................................26
3.3.3 ESTRUTURA DE REPETIÇÃO REPITA................................................................................27
CAPÍTULO 4 – VETORES, MATRIZES E REGISTROS.............................................................................28
4.1 VETORES.........................................................................................................................................29
4.2 MATRIZES.......................................................................................................................................31
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
1
Apostila de Algoritmos e Estrutura de Dados
4.3 REGISTROS.....................................................................................................................................34
CAPÍTULO 5 – MODULARIZAÇÃO............................................................................................................36
5.1 PASSAGEM DE PARÂMETRO......................................................................................................39
5.1.1 PASSAGEM DE PARÂMETRO POR VALOR...........................................................................40
5.1.2 PASSAGEM DE PARÂMETRO POR REFERÊNCIA................................................................40
5.1.3 RECURSIVIDADE.......................................................................................................................40
REFERÊNCIAS BIBLIOGRÁFICAS.............................................................................................................43
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
2
Apostila de Algoritmos e Estrutura de Dados
PREFÁCIO
Esta apostila foi desenvolvida especialmente para o Curso Técnico em Informática do PRONATEC da
Escola Estadual Geraldo Gomes Ribeiro.
PERFIL DO PROFISSIONAL TÉCNICO EM INFORMÁTICA
Desenvolve programas de computador, seguindo as especificações e paradigmas da lógica de programação e
das linguagens de programação. Utiliza ambientes de desenvolvimento de sistemas, sistemas operacionais e
banco de dados. Realiza testes de programas de computador, mantendo registros que possibilitem análises e
refinamento dos resultados. Executa manutenção de programas de computadores implantados.
POSSIBILIDADE DE ATUAÇÃO
Instituições públicas, privadas e do terceiro setor que demandem sistemas computacionais, especialmente
envolvendo programação de computadores.
A disciplina algoritmos e estrutura de dados é a base para iniciarmos com a programação de computadores.
O seu aprendizado possibilita desenvolver algoritmos para resolver qualquer problema solicitado
independente da linguagem de programação no qual será implantado futuramente.
Os capítulos 1 e 2 tratam dos conceitos básicos que temos que compreender para iniciarmos a construir
algoritmos. O capítulo 3 apresenta as estruturas de controle disponíveis para utilizarmos na resolução de
diversos problemas com algoritmos. O capítulo 4 apresenta estruturas de dados mais avançadas como
vetores, matrizes e registros. O capítulo 5 traz o conceito de modularização e a importância de separar os
programas para facilitar na leitura e futura manutenção. A partir do capítulo 3 iremos exercitar técnicas de
rastreio e testes em sala de aula para confirmar a eficiência do algoritmo desenvolvido.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
3
Apostila de Algoritmos e Estrutura de Dados
CAPÍTULO 1 – FUNDAMENTOS
1.1 CONCEITO DE ALGORITMO
Atualmente, tem-se associado algoritmo à computação, mas esse não é um termo restrito a
computação ou que tenha nascido exclusivamente dela. O algoritmo pode ser descrito como o alicerce de
uma casa, uma receita culinária, um plano de ação para resolver um problema administrativo, uma bula de
medicamento etc.
Ou seja, é uma sequência de passos finitos que devem ser seguidos para alcançar um objetivo final.
A origem da palavra algoritmo vem do nome al-Khowarizmi. Abu Ja’Far Mohammed Ibn Musa al-
Khowarizmi (780–850), astrônomo e matemático árabe. Era membro da “Casa da Sabedoria”, uma academia
de cientistas em Bagdá. O nome al-Khowarizmi significa da cidade de Khowarizmi, que agora é chamada
Khiva e é parte do Uzbequistão. al-Khowarizmi
escreveu livros de matemática, astronomia e
geografia. A álgebra foi introduzida na Europa
ocidental através de seus trabalhos. A palavra
álgebra vem do árabe al-jabr, parte do título de seu
livro Kitab al-jabr w’al muquabala. Esse livro foi
traduzido para o latim e foi usado extensivamente.
Seu livro sobre o uso dos numerais hindus
descreve procedimentos para operações
aritméticas usando esses numerais. Autores
europeus usaram uma adaptação latina de seu nome, até finalmente chegar à palavra algoritmo para
descrever a área da aritmética com numerais hindus.
Na literatura existem várias definições para a palavra algoritmo, abaixo, segue algumas dessas
definições:
“Um algoritmo é a descrição de um padrão de comportamento, expressado em termos de um repertório bem
definido e finito de ações primitivas, das quais damos por certo que elas podem ser executadas.“
(GUIMARÃES; LAGES, 1994, p.4)
“Algoritmo é a descrição de um conjunto de comandos que, obedecidos, resultam numa sucessão finita de
ações.”
(FARRER et al., 1999 p.14)
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
4
Apostila de Algoritmos e Estrutura de Dados
“Um algoritmo pode ser definido como uma sequencia de passos que visam a atingir um objetivo bem
definido.”
(FORBELLONE; EBERSPACHER, 2005, p.3)
Já na computação, os computadores precisam receber ordens para funcionar, daí à necessidade de
algoritmos.
Para aprendermos a criar algoritmos, não basta estudar ou copiar algoritmos. Devemos escrever e
criar algoritmos, ou seja, praticar bastante.
1.2 ESTRUTURA DE DADOS
Estrutura de dados é um meio para armazenar e organizar os dados com o objetivo de facilitar o
acesso e as modificações. Nenhuma estrutura de dados única funciona bem para todos os propósitos, e assim
é importante conhecer os pontos fortes e as limitações de várias delas. Podemos fazer uma analogia com a
agenda de um celular. Uma agenda de celular pode ser vista como uma estrutura de dados, pois mantém os
dados organizados seguindo alguma lógica e disponibiliza operações para o usuário manipular os dados.
Quando pensamos em estruturar dados, devemos levar em consideração o desempenho. Se uma
agenda de celular armazena os dados de forma desorganizada, então será muito difícil por parte do usuário
localizar um contato de forma rápida e eficiente. A escolha de como guardar as informações deve levar em
consideração as operações que serão disponibilizadas pelo programa. Por exemplo, em uma agenda, seria
interessante manter os contatos em ordem alfabética para facilitar a busca. Mas a forma de como estão
organizados os dados não deve estar exposto ao usuário, ele só tem que utilizar funções como inserir,
recuperar, atualizar, remover contato, saber quantos contatos está na agenda, etc. É função de algum
algoritmo manipular esses dados de forma que facilite o uso das funções da agenda pelo usuário.
O importante, quando for programar um algoritmo, não misturar dado e estrutura de dados em uma
coisa só. Um dado é uma informação armazenada e estrutura de dados é quem administra os dados. Desta
forma a estrutura de dados fica o mais genérica possível, fazendo com que ela possa ser utilizada para
diversos tipos de dados. Por exemplo, é melhor ter uma agenda genérica do que uma agenda de telefones.
Uma agenda genérica pode ser utilizada para guardar telefones, ou e-mails, ou até mesmo guardar outra
estrutura dentro dela: contatos, que seriam compostos por nome, telefone e email.
Nessa apostila iremos ver algumas das estruturas de dados básicas e avançadas que serão utilizadas por
nossos algoritmos.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
5
Apostila de Algoritmos e Estrutura de Dados
1.3 ALGORITMO E PROGRAMAS DE COMPUTADOR
Informalmente, um algoritmo, é um procedimento computacional bem definido que toma como
entrada um valor (ou conjunto de valores) e produz como saída um valor (ou conjunto de valores) para a
solução de um problema computacional, ou seja, é uma sequencia de passos computacionais que transforma
entrada em saída.
Portanto nos computadores temos a parte física, que é chamada de hardware, essa é formada
basicamente por uma UCP (Unidade Central de Processamento), pela memória e pelos dispositivos de
entrada e saída e todos estão ligados através do barramento.
Um microprocessador executa um conjunto diferente de instruções que são buscados da memória
RAM. Essas instruções podem ser desde operações matemáticas até interações com os dispositivos de saída
(monitor ou impressora, etc.), exemplo: quando clicamos em um botão na tela para imprimir um documento.
Esse conjunto de instruções que serão executados pelo processador, podemos chamar de programa de
computador. Como podemos perceber, um programa de computador nada mais é que um algoritmo. Sua
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
6
Apostila de Algoritmos e Estrutura de Dados
particularidade é que suas operações são específicas para o computador e restrita a quantidade de instruções
que o processador possa executar.
1.3.1 CLASSIFICAÇÃO DAS LINGUAGENS DE PROGRAMAÇÃO
Esse conjunto de instruções que o processador irá executar, podemos dizer que estão em linguagem
de máquina. A linguagem de programação que o computador consegue entender é a linguagem composta
apenas de números, portanto desenvolver programas nesse nível de
linguagem torna-se algo muito complexo para nós seres humanos.
Por isso, que antigamente somente um número restrito de pessoas
possuía esse conhecimento e os programas eram restritos a
realizarem tarefas mais simples como operações aritméticas. Na
computação, a classificação das linguagens de programação é
definida de acordo com a proximidade com a linguagem de
máquina. Ou seja, quanto maior for à semelhança como o
computador “conversa”, mais baixo é o nível da linguagem de programação. Foi necessário então criar um
código que relacionasse a linguagem de máquina a uma linguagem mais fácil de ser compreendida, daí
surgiu às linguagens de alto nível.
Exemplos de linguagem de baixo e alto nível
Baixo Nível Alto Nível
Assembly C++, Java, Visual Basic, Pascal, PHP, etc...
Veja abaixo exemplo de dois códigos, os dois para somar dois números e exibir o resultado na tela.
CÓDIGO EM ASSEMBLY CÓDIGO EM PASCAL.model small .stack .data valor db ? .code .startup mov ah, 01h ; int 21h ; sub al, 30h ; mov value, al ; mov ah, 01h ; int 21h ; sub al, 30h ; add al, value ; mov dl, al ; add dl, 30h ; mov ah, 02h ; int 21h .exit end
Program Soma;
uses Crt;
var A,B,C:integer;
begin
ClrScr;
Writeln('Digite um número ');
Readln(A);
Writeln('Digite outro número ');
Readln(B);
C:=A+B;
Writeln('A soma é ',C);
end.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
7
Apostila de Algoritmos e Estrutura de Dados
Para serem processados por um computador, os comandos da linguagem de alto nível precisam ser
traduzidos para a linguagem de máquina. Essa tradução é feita por meio de um compilador ou interpretador,
dependendo do caso, como veremos abaixo.
1.3.2 COMPILADORES E INTERPRETADORES
O compilador através do código-fonte (algoritmo em linguagem de alto nível) gera um arquivo com
código em linguagem de máquina, conhecido como código-objeto. Esse arquivo fica armazenado no HD e é
carregado na memória assim que o programa é executado. Em seguida é necessário o uso de outro programa
(Link-Editor) que é responsável pela junção de diversos códigos-objeto em um único programa executável.
O código executável gerado pelo compilador é dependente do sistema operacional e da linguagem de
máquina para o qual o código fonte foi traduzido
As fases de um compilador consistem basicamente conforme a figura abaixo, vamos dar destaque aos
analisadores Léxico, Sintático e Semântico:
Análise léxica: A sua função básica é o reconhecimento e a classificação das estruturas elementares ou
classes sintáticas das linguagens.
Análise sintática: Verifica se a estrutura geral do texto ou programa fonte está correcta.
Análise semântica: Verifica se o programa fonte tem erros semânticos e reúne a informação dos tipos para a
fase de gerador de código subsequente. Uma componente importante da análise semântica é a verificação do
tipo.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
8
Apostila de Algoritmos e Estrutura de Dados
O interpretador tem a mesma função do compilador que é traduzir o código-fonte para linguagem de
máquina, só que o mesmo não gera o código-objeto. As instruções são traduzidas em tempo de execução.
Exemplos: HTML, Excel, Word Basic, Access, SmallTalk, etc.
Veja no quadro abaixo as vantagens e desvantagens de cada um dos tradutores.
COMPILADOR INTERPRETADOR
Vantagens:
O código compilado é mais rápido de ser
acessado;
Impossibilita ou pelo menos dificulta ser
quebrado e visualizado o código-fonte original;
Permite otimização do código por parte do
compilador;
Compila o código somente se estiver sem algum
erro.
Vantagens:
Correções e alterações são mais rápidas de
serem realizadas;
Código não precisa ser compilado para ser
executado;
Consomem menos memória.
COMPILADOR INTERPRETADOR
Desvantagens:
Para ser utilizado o código precisa passar por
muitos níveis de compilação;
Assim como vantagem a possibilidade de não
poder visualizar o código-fonte, pode ser uma
desvantagem;
Processo de correção ou alteração do código
requer que ele seja novamente recompilado.
Desvantagens:
Execução é mais lenta do programa;
Necessita sempre ser lido o código original
para ser executado.
1.3.3 CRITÉRIOS DE QUALIDADE DE UM PROGRAMA DE COMPUTADOR
Abaixo serão apresentados alguns critérios básicos que devemos levar em consideração para termos
programas de computador com qualidade:
Integridade: refere-se à precisão das informações manipuladas pelo programa, ou seja, os resultados
gerados pelo processamento do programa devem estar corretos, caso contrário o programa não tem sentido
algum.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
9
Apostila de Algoritmos e Estrutura de Dados
Clareza: refere-se à facilidade de leitura do programa. Se um programa for escrito com clareza, com
indentação, deverá ser possível a outro programador seguir a lógica do programa sem muito esforço, assim
como o próprio autor do programa entendê-los após ter estado um longo período afastado dele.
Simplicidade: a clareza e precisão de um programa são normalmente melhoradas tornando seu
entendimento o mais simples possível, consiste com os objetivos do programa. Muitas vezes torna-se
necessário sacrificar alguma eficiência de processamento, de forma a manter a estrutura do programa mais
simples possível.
Eficiência: refere-se à velocidade de processamento e a correta utilização da memória. Um programa deve
ter desempenho SUFICIENTE para atender as necessidades do problema e do usuário, bem como deve
utilizar os recursos de memória de forma moderada, dentro das limitações do problema;
Modularidade: consiste no particionamento do programa em módulos menores bem identificáveis e com
funções específicas, de forma que o conjunto desses módulos e a interação entre eles permite a resolução do
problema de forma mais simples e clara;
E por último,
Generalidade: é interessante que um programa seja tão genérico quanto possível de forma a permitir a
reutilização de seus componentes em outros projetos.
CAPÍTULO 2 – ESTRUTURAÇÃO DE ALGORITMOS
2.1 FLUXOGRAMA
Os fluxogramas representam os algoritmos em uma forma gráfica. São formados por caixas que
contêm as instruções a serem executadas. Tais caixas são ligadas por setas que indicam o fluxo das ações.
Algumas caixas especiais indicam a possibilidade de o fluxo seguir caminhos distintos, dependendo de
certas situações que podem ocorrer durante a execução do algoritmo. Também há representações para o
início do algoritmo e para o seu final, para que o fluxo do algoritmo possa ser determinado do seu princípio
até o seu término. A figura abaixo apresenta as caixas e o seus significados:
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
10
Apostila de Algoritmos e Estrutura de Dados
Abaixo segue um algoritmo na sua representação gráfica que resolve o seguinte problema:
Faça um algoritmo que obtenha três notas de provas, realize a média aritmética e depois informe para o
usuário se ele foi aprovado ou reprovado, seguindo a seguinte regra: Se a média for maior que sete, o aluno
foi aprovado. Se for menor que sete, ele foi reprovado.
Embora seja mais fácil entender o algoritmo através de sua representação gráfica, seu uso não é
aconselhável em problemas mais complexos onde uma simples mudança na linha de pensamento pode trazer
várias alterações no seu fluxo, tornando a atividade trabalhosa e cansativa.
2.2 PSEUDOCÓDIGOS
Algoritmos podem ser representados em códigos diretos na linguagem de programação, porém
devido à rigidez sintática e semântica, às vezes isso torna o trabalho um pouco custoso. Portanto definir um
pseudocódigo traz benefícios, por ser menos rígido e dependente das peculiaridades que todo compilador
exige.
Portanto, vejamos abaixo um pseudocódigo para solucionar o problema citado no item 2.1 deste
capítulo. Na disciplina Algoritmos e Estrutura de Dados iremos adotar o Pascal como linguagem de alto
nível para começarmos a implantar nosso algoritmo e ver os resultados, portanto todo algoritmo resolvido
nesta apostila terá ao lado o código em Pascal para que possa ser implementado em qualquer compilador
Pascal. Recomendo utilizar o PascalZIM.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
11
Apostila de Algoritmos e Estrutura de Dados
Algoritmo Media
var N1, N2, N3, MEDIA: real;
Inicio
Escreva (“Digite três números”);
Leia (N1, N2, N3);
MEDIA ← (N1+N2+N3)/3;
Se (MEDIA >= 7) então
Escreva ("Aprovado");
Senão
Escreva ("Reprovado");
Fim
Program Media;
var N1, N2, N3, MEDIA: real;
Begin
Write ('Digite três números');
Readln(N1, N2, N3);
MEDIA:=(N1+N2+N3)/3;
If (MEDIA >=7) then
Write ('Aprovado')
Else
Write ('Reprovado');
End.
2.3 FUNDAMENTOS PARA PROGRAMAÇÃO
Para iniciarmos a criar nossos algoritmos algumas informações básicas são essenciais:
2.3.1 VARIÁVEIS
Para que a memória possa armazenar dados, ela é dividida em partes, chamadas posições de
memória. O sistema operacional que gerencia o sistema de computação pode acessar cada uma destas
posições para armazenar tais dados. Para que isto seja possível, a cada posição de memória está associada
uma sequência de bit’s, chamada endereço da posição de memória. Como uma sequência de bits
corresponde a um número inteiro escrito no sistema binário, cada endereço pode ser visto como um inteiro
escrito no sistema decimal. Assim temos posições de memória de endereço 1209 ou 2114, por exemplo.
Em programação, uma variável é uma posição de memória cujo conteúdo pode ser modificado
durante a execução de um programa, devendo ser-lhe associados um identificador e um tipo de dado.
Exemplo: FATOR: inteiro, onde FATOR é o identificador (nome da variável) e inteiro é o tipo de
dado.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
12
Apostila de Algoritmos e Estrutura de Dados
2.3.2 CONSTANTES
Uma constante é uma posição de memória no qual o sistema armazena um valor fixo, valor este que
não pode ser alterado durante a execução. Uma constante é associada a um identificador e um valor. As
constantes são declaradas com a seguinte sintaxe:
const identificador ← valor;
Exemplo:
const advogado ← 6252365;
As variáveis como as constantes são declaradas antes do início do algoritmo/programa.
Algoritmo Maiorvar A: inteiro;const PI ← 3,14;
Início..
2.3.3 TIPO DE DADOS PRIMITIVOS
São os tipos de dados mais comuns, e que podem dar origem a outros tipos de dados mais complexos.
2.3.3.1 Inteiro
Números inteiros maiores ou menores que 0 representados por 2 bytes, em uma faixa que vai de -32768 até
32767.
Declaração:
var num: inteiro;
No exemplo acima foi declarada uma variável do tipo INTEIRO que atende pelo nome de “NUM”.
2.3.3.2 Real
Conjunto de números racionais, representados por 4 bytes em uma faixa de [–3,4x1038, –3,4x10-38]∪[3,4x10-
38, 3,4x1038].
Declaração:
var salario: real;
No exemplo acima foi declarada uma variável do tipo REAL que atende pelo nome de “SALARIO”.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
13
Apostila de Algoritmos e Estrutura de Dados
2.3.3.3 Caractere(Char/String)
Conjunto dos caracteres alfanuméricos (números, letras, símbolos, etc.). Representado por apenas um byte.
Ele pode armazenar apenas 1 caractere.
Declaração:
var opcao: caractere;
No exemplo acima foi declarada uma variável do tipo CARACTERE que atende pelo nome de “opcao”.
Temos também dados agrupados do tipo caractere, em pascal chamados esses dados de string, eles podem
armazenar mais de um caractere definidos na declaração da variável.
Declaração:
var endereco: caractere[30];
No exemplo acima foi declarada uma variável do tipo CARACTERE[30] que atende pelo nome de
“endereco” e pode receber até 30 caracteres alfanuméricos (números, letras, símbolos, etc.).
2.3.3.4 Lógico
Quando assume apenas dois estados: Verdadeiro ou Falso.
Declaração:
var flag: logico;
No exemplo acima foi declarada uma variável do tipo LÓGICO que atende pelo nome de “flag”.
2.3.4 NOMENCLATURA DAS VARIÁVEIS
Vamos adotar as seguintes regras para os nomes das variáveis:
Os nomes das variáveis devem representar o que será guardado dentro dela;
O primeiro caractere de um nome deverá ser sempre alfabético;
O nome da variável não pode conter caracteres especiais (!@#$%&*/-+<>?);
Não podem ser colocados espaços em branco no nome de variáveis, usar o UNDERSCORE ( _ );
Não pode haver nenhum nome de variável repetido;
As variáveis não podem ter o mesmo nome de palavras reservadas, exemplo: se, senão, inicio, fim,
real, inteiro, caractere, etc.;
A declaração de uma variável é feita no algoritmo, informando o seu nome, seguido pelo seu tipo,
separados por “:”.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
14
Apostila de Algoritmos e Estrutura de Dados
2.3.5 OPERADORES ARITMÉTICOS
Os operadores aritméticos são utilizados para efetuar operações aritméticas com números inteiros e
reais. A tabela abaixo apresenta os operadores existentes em Pascal e que também utilizaremos nos nossos
algoritmos em português:
Abaixo segue exemplo da utilização dos operadores aritméticos para realização de cálculos:
Algoritmo CALCvar A, B : inteiro;C, D : real;
InicioA ← 1;B ← 3;C ← 5;D ← 10;A ← 1 + B; A ← B + D; { errado, D é real }B ← 10 div 3; A ← 10 mod 3;C ← D / C; D ← 10 div C; { errado, o operado div é só para inteiros }A ← -1;B ← 5 + A;B ← -A;C ← D * A;B ← C * B; { errado, C é real }
Fim
Program CALC;var A, B : integer;C, D : real;
beginA := 1;B := 3;C := 5;D := 10;A := 1 + B; A := B + D; { errado, D é real }B := 10 div 3; A := 10 mod 3;C := D / C; D := 10 div C; { errado, o operado div é só para inteiros }A := -1;B := 5 + A;B := -A;C := D * A;B := C * B; { errado, C é real }
End.
Percebemos no algoritmo acima que um tipo de dado não pode receber valores maiores que sua capacidade
de armazenamento. Veja trechos retirados do código acima e sua explicação.
A ← B + D; { errado, D é real }
A variável A é do tipo inteiro, só pode receber valores inteiros, já o contrário é aceito, pois variável do tipo
inteiro não supera a capacidade de armazenamento de uma variável do tipo real.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
15
Apostila de Algoritmos e Estrutura de Dados
Para entendermos melhor, vejamos os exemplos abaixo:
Var A ← Var D {Errado, a variável A não tem o tamanho suficiente para armazenar o valor contido na
variável D}.
Memória
Var D Var A Var B Vazio Vazio Vazio Vazio Vazio
Var D ← Var A {Correto, pois a variável D tem a capacidade para armazenar o valor contido na variável A}.
MemóriaVar D Var A Var B Vazio Vazio Vazio Vazio Vazio
2.3.6 OPERADORES RELACIONAIS
Os operadores relacionais são utilizados para comparação de dados do mesmo tipo. Segue abaixo esses operadores:
Segue abaixo um exemplo de algoritmo utilizando operadores relacionais:
Algoritmo OPRELvar Nota1, Nota2 : real;Aluno1, Aluno2 : caractere[30];A, B, C : inteiro;
InicioA ← 2;B ← 3;C ← 1;Se B = A + C Então
Escreva(B);Nota1 ← 5.0;Nota2 ← 10.0; Se Nota1 < Nota2 Então
Escreva(Nota1);Aluno1 ← “Maria Jose”;Aluno2 ← “MariaJose”;Se Aluno1 < Aluno2 Então
Escreva(Aluno1);Fim
Program OPREL;var Nota1, Nota2 : real;
Aluno1, Aluno2 : string[30];A, B, C : integer;
beginA := 2;B := 3;C := 1;if B = A + C then
writeln(B);Nota1 := 5.0;Nota2 := 10.0; if Nota1 < Nota2 then
writeln(Nota1);Aluno1 := ‘Maria Jose’;Aluno2 := ‘MariaJose’;if Aluno1 < Aluno2 then
writeln(Aluno1);end.
2.3.7 OPERADORES LÓGICOS
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
16
Apostila de Algoritmos e Estrutura de Dados
Os operadores lógicos são utilizados para analisar duas expressões inter-relacionadas.
OPERADOR NO PASCAL
E AND
OU OR
NÃO NOT
Veja abaixo, exemplo de algoritmo utilizando operadores lógicos:
Algoritmo OPELOGICOSvar Nota1, Nota2 : real;Aluno1, Aluno2 : caractere[30];A, B, C : inteiro;
InicioA ← 2;B ← 3;C ← 1;Aluno1 ← “Maria Jose”;Aluno2 ← “MariaJose”;se ( B = A + C ) E ( NomeAluno1 <> NomeAluno2 ) então
Escreva( Aluno1, B );se ( A = C ) OU ( Aluno1 = Aluno2 ) então
Escreva( Aluno1 );se NÃO( A = C ) então
Escreva( Aluno1 );Fim
Program OPELOGICOS;var Nota1, Nota2 : real;Aluno1, Aluno2 : string[30];A, B, C : integer;
beginA := 2;B := 3;C := 1;Aluno1 := ‘Maria Jose’;Aluno2 := ‘MariaJose’;if ( B = A + C ) and ( Aluno1 <> Aluno2 ) then
writeln( Aluno1, B );if ( A = C ) or ( Aluno1 = Aluno2 ) then
writeln( Aluno1 );if not( A = C ) then
writeln( Aluno1 );end.
Sabemos que os resultados de duas operações inter-relacionadas dependem do seu operador, vejamos abaixo
três tabelas verdade uma para cada operador lógico:
Operador E (AND)
Condição 1 Condição 2 Resultado
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso
Falso Verdadeiro Falso
Falso Falso Falso
Operador OU (OR)
Condição 1 Condição 2 Resultado
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Falso Falso Falso
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
17
Apostila de Algoritmos e Estrutura de Dados
Operador NÃO (NOT)
Condição 1 Resultado
Verdadeiro Falso
Falso Verdadeiro
Neste capítulo foram apresentados todos os fundamentos necessários para iniciarmos a construção de
algoritmos, mas antes de passarmos para o próximo capítulo temos que nos atentar sobre as prioridades de
todos os operadores mostradas neste capítulo, veja na tabela abaixo.
De acordo com a tabela toda expressão que está entre parênteses será executada primeiro e assim por diante.
Com relação às expressões aritméticas, os operadores de multiplicação (*) e divisão (/) tem prioridade sobre
adição (+) e subtração (-).
Vejamos um exemplo, seguindo as regras de prioridade:
C ← (25+25)/2+5-2*2;1. 50/2+5-2*2;2. 50/2+5-4;3. 25+5-4;4. 30-4;5. 26;
O resultado de C é 26.
Exercícios:
1. Defina o que é um algoritmo.
2. Diferencie um algoritmo de um programa.
3. Defina o que é uma linguagem de programação de alto nível e uma linguagem de programação de baixo
nível.
4. Declare variáveis que sejam capazes de armazenar as seguintes informações:
a) Sua idade;
b) A média entre dois números;
c) O seu salário;
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
18
Apostila de Algoritmos e Estrutura de Dados
d) Seu nome;
e) Valores verdadeiro ou falso.
5. Seguindo a regra de prioridades, qual será o resultado da expressão (2+2)*5/2-5+6*2+(7*2), faça passo-
a-passo.
6. Quais operadores serão utilizados para comparar as seguintes condições:
a) A maior que B;
b) C menor que A;
c) D diferente de A;
d) A maior ou igual a B;
e) C menor ou igual a J.
7. Analise as expressões abaixo e informe qual será a saída (V ou F):
a) NÃO (V OU F);
b) V E NÃO (V E F);
c) V E F.
CAPÍTULO 3 – ESTRUTURAS DE CONTROLE
Estrutura de controle nada mais é que a forma como será executado o algoritmo. Veremos abaixo em
detalhes cada uma dessas estruturas.
3.1 ESTRUTURA SEQUENCIAL
A estrutura sequencial é a forma mais simples e fácil de entender das estruturas de controle. Para começar a
escrever os algoritmos nessa estrutura vamos adotar a seguinte regra. Primeiro damos o nome do algoritmo,
seguindo a mesma regra da nomenclatura das variáveis, vista no item 2.3.4, em seguida declaramos as
variáveis necessárias e entre Inicio e Fim colocamos os comandos que serão executados em sequência.
Algoritmo PASSOvar A, B, C : inteiro;
InicioA ← 2;B ← 3;C ← A+B;Escreva(C);C ← B/A;Escreva(C);C ← A-B;Escreva(C);C ← A*B;Escreva(C);
Fim
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
19
Apostila de Algoritmos e Estrutura de Dados
Veja abaixo, mais alguns exemplos de problemas que podem ser resolvidos com algoritmos sequenciais:
1) Faça um algoritmo que receba o salário de um funcionário, calcule e mostre o novo salário, sabendo que
este sofreu um aumento de 25%.
Algoritmo NOVO_SALARIOvar Sal, NSal : real;
InicioEscreva(“Digite o seu salário”);Leia(Sal);NSal ← (Sal*0.25)+Sal;Escreva(“O seu novo salário é”, Sal);
Fim
Program NOVO_SALARIO;var Sal, NSal : real;
beginWrite(‘Digite o seu salário’);Readln(Sal);NSal := (Sal*0.25)+Sal;Write(‘O seu novo salário é’, NSal);
end.
2) Faça um algoritmo que calcule a área de um triângulo, sabendo-se que: Área = Base * Altura / 2.
Algoritmo AREAvar A,B,H : real;
InicioEscreva(“Digite o valor da base”);Leia(B);Escreva(“Digite o valor da altura”);Leia(A);H ← (B*A)/2;Escreva(“A área do triângulo é ”,H);
Fim
Program AREA;var A,B,H : real;
beginWrite(‘Digite o valor da base’);Readln(B);Write(‘Digite o valor da altura’);Readln(A);H := (B*A)/2;Write(‘A área do triângulo é ‘,H);
end.
3) Faça um algoritmo que receba o salário de um funcionário e o percentual de aumento, calcule e mostre o
valor do aumento e o novo salário.
Algoritmo NOVO_SALARIOvar Sal, Perc, NSal, VAument : real;
InicioEscreva(“Digite o seu salário”);Leia(Sal);Escreva(“Digite o percentual de aumento”);Leia(Perc);Vaument ← (Sal*(Perc/100));NSal ← Vaument + Sal ;Escreva(“O aumento é de”, Vaument);Escreva(“O novo salário é”,NSal);
Fim
Program NOVO_SALARIO;var Sal, Perc, NSal, VAument : real;
beginWrite(‘Digite o seu salário’);Readln(Sal);Write(‘Digite o percentual de aumento’);Readln(Perc);Vaument := (Sal*(Perc/100));NSal := Vaument + Sal ;Write(‘O aumento é de’, Vaument);Write(‘O novo salário é’,NSal);
end.
4) Faça um algoritmo que receba o salário base de um funcionário, calcule e mostre o salário a receber, sabendo-se que esse funcionário tem gratificação de 5% sobre o salário base e paga imposto de 7% sobre o salário base.
Algoritmo NOVO_SALARIOvar SalB, Salliq: real;
Inicio
Program NOVO_SALARIO;var SalB, Salliq: real;
begin
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
20
Apostila de Algoritmos e Estrutura de Dados
Escreva(“Digite o seu salário”);Leia(SalB);Salliq ← ((SalB*0.05)+SalB)-(SalB*0.07);Escreva(“O salário a receber é”,Salliq);
Fim
Write(‘Digite o seu salário’);Readln(SalB);Salliq := ((SalB*0.05)+SalB)-(SalB*0.07);Write(‘O salário a receber é’,Salliq);
end.
Exercícios propostos:
1. Sabe-se que:
1 pé = 12 polegadas
1 jarda = 3 pés
1 milha = 1760 jardas
Faça um algoritmo que receba uma medida em pés, faça as conversões e mostre o resultado em
polegadas, jardas e milha.
2. Faça um algoritmo que receba o ano de nascimento de uma pessoa e o ano atual, calcule e mostre a
idade dessa pessoa e quantos ela terá em 2015.
3. Pedro comprou um saco de ração com peso em quilos, Pedro possui dois gatos, os quais fornece a
quantidade de ração em gramas. Faça um algoritmo que receba o peso do saco de ração e a quantidade
de ração fornecida para cada gato. Calcule e mostre quanto restará de ração no saco após cinco dias.
4. Sabe-se que o quilowatt de energia custa um quinto do salário mínimo. Faça um algoritmo que receba o
valor do salário mínimo e a quantidade de quilowatts consumida por uma resistência. Calcule e mostre:
a. O valor em reais que cada quilowatt vale;
b. O valor em reais a ser pago por essa resistência;
c. O valor em reais a ser pago com desconto de 15%.
5. Faça um algoritmo que converta o valor em dinheiro em reais (R$) informado pelo usuário para três
moedas, dólares, marco alemão e libras esterlinas. Segue abaixo tabela de conversão:
Moeda Cada R$ 1,00 equivale a
Dólares R$ 1,80
Marco Alemão R$ 2,00
Libras Esterlinas R$ 1,57
6. Faça um algoritmo em que o usuário informa a hora e depois os minutos. Calcule e converta a hora em
minutos, total de minutos e total de segundos.
7. Faça um algoritmo que calcule a potência necessária para um cômodo de uma casa, sabendo que a
fórmula para calcular a potência é:
Potência = Área do cômodo (m2) * 18;
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
21
Apostila de Algoritmos e Estrutura de Dados
Área do cômodo = Base (m) * Altura (m).
8. Faça um algoritmo que calcule o salário a receber de um funcionário, sabendo-se que o usuário deve
entrar com o número de horas trabalhadas, o valor do salário mínimo e a quantidade de horas extras e o
valor da hora trabalhada é igual ao salário mínimo/8 e o valor da hora extra é igual ao salário mínimo/4.
9. Faça um algoritmo que receba o peso de uma pessoa, calcule e mostre o peso dessa pessoa, se a mesma
engordar 15% e 20%.
3.2 ESTRUTURA CONDICIONAL
A estrutura condicional é utilizada quando é necessário fazer uma opção entre dois ou mais caminhos,
sendo que o fluxo do algoritmo é desviado segundo uma condição lógico relacional, ou seja, se a condição
for verdadeira o algoritmo irá realizar uma sequência, senão irá executar outra sequência. Na figura abaixo
mostra na forma gráfica.
As estruturas condicionais ou de seleção são controladas por expressões Lógicas, conforme item
2.3.7 desta apostila. Expressões lógicas são aquelas cujo resultado será verdadeiro ou falso. Utilizamos
também nesta estrutura de controle os operadores relacionais, conforme item 2.3.6 desta apostila.
Vejamos abaixo um exemplo de um problema que seria necessário utilizar a estrutura condicional para
resolvê-lo:
Faça um algoritmo que receba três notas dos alunos, se a média das notas for menor que 70 mostre a
mensagem na tela “Reprovado”, caso contrário mostre “Parabéns você foi aprovado”. Vejamos abaixo como
ficaria o algoritmo:
Algoritmo MEDIA_APROVvar Med, Nota1, Nota2, Nota3 : real;
InicioEscreva (“Digite três notas”);Leia (Nota1, Nota2, Nota3);Med ← (Nota1+Nota2+Nota3)/3;Se Med < 70 Então
Escreva(“Reprovado”);Senão
Escreva(“Parabéns você foi aprovado”);
Fim
Program MEDIA_APROV;var Med, Nota1, Nota2, Nota3 : real;
BeginWrite (‘Digite três notas’);Readln (Nota1, Nota2, Nota3);Med := (Nota1+Nota2+Nota3)/3;if Med < 70 then
Write(‘Reprovado’)Else
Write(‘Parabéns você foi aprovado’);
End.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
22
Apostila de Algoritmos e Estrutura de Dados
Existem dois tipos de estrutura condicional a simples e a composta:
3.2.1 ESTRUTURA CONDICIONAL SIMPLES
A estrutura de seleção simples permite que o programa tome uma determinada decisão de acordo
com o resultado da expressão lógica a ser avaliada, ou seja, se a expressão for verdadeira, ele deve executar
o(s) comando(s) interno(s) pertencente à estrutura de seleção.
Se for executado apenas um comando não é necessário colocar o Inicio e Fim, caso seja executado
mais de um comando é obrigatório colocar Inicio e Fim.
Se <condição> então
Comando 1;
Se <condição> então
Inicio
Comando 1;
Comando 2;
Fim
3.2.2 ESTRUTURA CONDICIONAL COMPOSTA
Já a estrutura de seleção composta permite que o programa execute um ou mais comandos para o
caso de o resultado da expressão lógica ser verdadeiro. E permite que o programa execute outro comando ou
bloco de comandos caso o resultado da expressão lógica seja falso.
Se <condição> então Comando 1;
SenãoComando 2;
Se <condição> então Inicio
Comando 1;Comando 2;
FimSenãoInicio
Comando 1;Comando 2;
Fim
Se for executado apenas um comando não é necessário colocar o Inicio e Fim, caso seja executado
mais de um comando é obrigatório colocar Inicio e Fim.
No Pascal na estrutura condicional composta, no comando anterior ao senão (else) não deve colocar ponto e
vírgula ( ; ).
If <condição> then Comando 1
elseComando 2;
If <condição> then begin
Comando 1;Comando 2;
endelsebegin
Comando 1;Comando 2;
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
23
Apostila de Algoritmos e Estrutura de Dados
End;
3.2.3 ESTRUTURA CONDICIONAL MÚLTIPLA ESCOLHA
A estrutura de múltipla escolha é utilizada quando existem várias possibilidades de resposta para uma
determinada variável. Entretanto, apenas uma delas deve ser a verdadeira e indicará os comandos a serem
executados. Se for executado apenas um comando não é necessário colocar o Inicio e Fim, caso seja
executado mais de um comando é obrigatório colocar Inicio e Fim para cada caso;
caso (expressão_de_controle) valor_1: comando1 ; valor_2: comando2 ; valor_3: comando3 ;senão
comando4;fim;
caso (expressão_de_controle) valor_1: Inicio comando1 ; comando2 ; Fim; valor_2: comando2 ; valor_3: comando3 ;senão
comando4;fim;
Exercícios propostos:
1. Faça um algoritmo que receba 5 notas, calcule a média e mostre a mensagem “Reprovado” para o
usuário, caso a média seja inferior a 7.
2. Faça um algoritmo que receba 2 notas de 0 a 10, calcule a média e mostre a mensagem “Reprovado”,
caso a média seja inferior a 4, “Em recuperação”, caso a média seja maior ou igual a 4 e menor que 7
e “Aprovado” quando a média foi maior ou igual a 7 e caso o valor da média seja superior a 10
mostre a mensagem “Notas digitadas inválidas”.
3. Faça um algoritmo que receba 3 números, calcule e mostre na tela do usuário qual é o maior.
4. Faça um algoritmo que apresente na tela do usuário o menu de opções abaixo, utilize o comando
Escreva
Menu de Opções
1- Somar;
2- Subtrair;
3- Multiplicar;
Solicite que o usuário entre com dois números e depois entre com a opção desejada de acordo com o
menu de opções e faça os cálculos e mostre na tela o resultado da operação. Caso o usuário digite
uma opção inexistente no menu mostre a mensagem “Opção inválida” e saia do programa.
5. Faça um algoritmo que receba o salário do usuário, calcule e mostre na tela o resultado de acordo
com as condições abaixo:
Faixa salarial Percentual de ajuste
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
24
Apostila de Algoritmos e Estrutura de Dados
Menor ou igual a R$ 1.500,00 5%
Maior ou igual a R$ 1.500,00 2%
6. Faça um algoritmo que receba o salário médio do usuário, calcule e mostre na tela o resultado do
crédito disponível, de acordo com as informações abaixo:
Faixa salarial Valor do crédito
Menor ou igual a R$ 500,00 30% do salário médio
Maior que R$ 500,00 e menor que R$ 600,00 40% do salário médio
Maior ou igual a R$ 600,00 50% do salário médio
3.3 ESTRUTURAS DE REPETIÇÃO
Existem situações onde é necessário repetir um determinado trecho de um programa, certo número de
vezes. Imagine que você tenha que executar um determinado bloco de instruções 5 vezes. Com os
conhecimentos que você tem até agora, seria necessário repetir as instruções CINCO vezes, tornando seu
trabalho muito cansativo. Assim, existem as estruturas de repetição, que permitem que você execute essas
tarefas de forma mais simplificada. Podemos chamar as estruturas de repetição de laços ou loops, sendo que
podem existir três tipos de laços de repetição, vamos ver com mais detalhes cada um deles.
3.3.1 ESTRUTURA DE REPETIÇÃO PARA
O comando PARA executa repetitivamente um comando enquanto é atribuída uma série de valores a
uma variável de controle (contador do PARA). Ele automaticamente incrementa a variável de controle.
Vejamos abaixo como utilizaremos essa estrutura em nossos algoritmos.
Para X ← Expressão1 até Expressão2 faça Inicio
Comando 1;Comando 2;
Fim;
For x:= Expressão1 to Expressão2 do Begin
Comando 1;Comando 2;
End;
Veja acima que X é a variável de controle, do tipo ordenado (inteiro, lógico ou caractere).
Expressão1 e Expressão2 são expressões cujos valores são do tipo de dado da variável de controle, na
maioria das vezes, Expressão1 e Expressão2 são valores constantes, quando são chamados Valor
Inicial e Valor Final. Os comandos dentro do bloco Inicio e Fim são executados até o valor de
Expressão2 ser maior que o valor de Expressão1.
Vamos ver um algoritmo utilizando a estrutura de repetição PARA.
Algoritmo EXEMPLO_FORvar A, B, R, I : inteiro;
InicioPara I ← 1 até 5 faça
Program EXEMPLO_FOR;varA, B, R, I : integer;
Beginfor I := 1 to 5 do
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
25
Apostila de Algoritmos e Estrutura de Dados
InicioEscreva(‘Entre um valor para A: ’);Leia(A);Escreva(‘Entre um valor para B: ’);Leia(B);R ← A + B;Escreva(‘O resultado corresponde a: ’,R);
Fim;Fim
beginwrite(‘Entre um valor para A: ’);readln(A);write(‘Entre um valor para B: ’);readln(B);R := A + B;writeln(‘O resultado corresponde a: ’,R);
end;End.
Exercícios propostos utilize a estrutura PARA:
1. Faça um algoritmo para receber 10 números e informar se são números pares ou impares. Utilize a
função mod (essa função retorna o resto da divisão).
2. Faça um algoritmo para mostrar na tela do usuário os números de 1 a 50, Ex.: 1 2 3 4 ...
3. Faça um algoritmo para receber as notas de 40 alunos e no final calcular a média da turma e mostrar
para o usuário.
4. Faça um algoritmo para receber um número positivo e inteiro esse número será o valor final do
contador da estrutura PARA e informe para o usuário a soma, seguindo a regra abaixo:
Soma = Soma + 1 / valor_informado_pelo_usuario.
3.3.2 ESTRUTURA DE REPETIÇÃO ENQUANTO
Prescreve que os comandos a ele subordinado deverão ser repetidos enquanto uma condição lógico-
relacional for verdadeira. O teste é feito no início do comando, e caso o resultado for verdadeiro os
comandos serão executados, logo em seguida outro teste será feito. Caso o teste seja falso, o algoritmo
continua a sua execução sequencial depois da estrutura de repetição ENQUANTO.
Enquanto <condição> faça Inicio
Comando 1;Comando 2;
Fim;
While <condição> faça Begin
Comando 1;Comando 2;
End;
Vamos ver um algoritmo utilizando a estrutura de repetição ENQUANTO.
Algoritmo EXEMPLO_ENQUANTOvar A, B, R, I : inteiro;
InicioI←1;Enquanto(I<=5) façaInicio
Escreva(‘Entre um valor para A: ’);
program EXEMPLO_ENQUANTO;var
A, B, R, I : integer;begin
I:=1;while (I <= 5) dobegin
write(‘Entre um valor para A: ’);readln(A);
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
26
Apostila de Algoritmos e Estrutura de Dados
Leia(A);Escreva(‘Entre um valor para B: ’);Leia(B);R ← A + B;Escreva(‘O resultado corresponde a: ’,R);I← I+1;
Fim;Fim
write(‘Entre um valor para B: ’);readln(B);R := A + B;writeln(‘O resultado corresponde a: ’,R);I := I + 1;
end;end.
Observe no algoritmo acima que o valor da variável I tem que ser incrementado no final da instrução
ENQUANTO, porque a variável não é incrementada automaticamente como no comando PARA. Se não for
incrementado o programa fica em loop infinito, pois o valor da variável I será sempre menor que 5.
Observe também que a variável I recebeu o valor de 1 antes da instrução ENQUANTO, isso é
necessário para darmos inicio ao contador.
Exercícios propostos utilize a estrutura ENQUANTO:
1. Faça um algoritmo capaz de calcular a media aritmética simples de uma série de números, sendo que
a. O usuário deve informa a quantidade de números da série;
b. Se a quantidade for zero ou negativa o algoritmo tem que informá-lo que esses valores não
são aceitos;
c. O usuário deve informar um por um todos os números da série;
d. O algoritmo deve mostrar como resultado a média aritmética simples.
2. Faça um algoritmo que receba do usuário um valor inteiro, esse algoritmo deve somar os números
digitados pelo usuário até ele digitar a palavra “S” como resposta para seguinte pergunta. Você
deseja terminar a execução do programa? No final mostre a soma dos números.
3. Faça um algoritmo que seja capaz de somar todos os números inteiros de 1 a 10 e mostre o resultado
da soma.
3.3.3 ESTRUTURA DE REPETIÇÃO REPITA
Esta estrutura caracteriza-se por efetuar um teste lógico no final de um loop, sendo parecida com a
estrutura ENQUANTO. Seu funcionamento é controlado também por uma condição lógico-relacional. Esta
instrução irá efetuar a execução de um conjunto de instruções pelo menos uma vez antes de verificar a
validade da condição estabelecida.
REPITA Comando 1;Comando 2;
ATÉ <condição>;
Repeat Comando 1;Comando 2;
Until <condição>;
Vamos ver um algoritmo utilizando a estrutura de repetição REPITA.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
27
Apostila de Algoritmos e Estrutura de Dados
Algoritmo EXEMPLO_REPITAvar A, B, R, I : inteiro;
InicioI←1;Repita
Escreva(‘Entre um valor para A: ’);Leia(A);Escreva(‘Entre um valor para B: ’);Leia(B);R ← A + B;Escreva(‘O resultado corresponde a: ’,R);I← I+1;
Até (I <= 5);Fim
program EXEMPLO_REPITA;var
A, B, R, I : integer;begin
I:=1;Repeat
write(‘Entre um valor para A: ’);readln(A);write(‘Entre um valor para B: ’);readln(B);R := A + B;writeln(‘O resultado corresponde a: ’,R);I := I + 1;
Until (I <= 5);end.
Exercícios propostos utilize a estrutura REPITA:
1. Faça um algoritmo que solicite 10 valores para o usuário e no final mostre:
a. A soma;
b. A média aritmética;
c. Quantidade de números pares, use a função mod;
d. Quantidade de números ímpares, use a função mod;
e. Maior número;
f. Menor número.
2. Faça um algoritmo que calcule o Índice de Massa Corporal de 5 pessoas e no final mostre o resultado
baseado na tabela abaixo:
IMC Classificação
abaixo de 18,5 Subnutrido ou abaixo do peso
entre 18,6 e 24,9 Peso ideal (parabéns)
entre 25,0 e 29,9 Levemente acima do peso
entre 30,0 e 34,9 Primeiro grau de obesidade
entre 35,0 e 39,9 Segundo grau de obesidade
acima de 40 Obesidade mórbida
Fórmula IMC = peso (Kg) / (altura (m) * altura (m)).
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
28
Apostila de Algoritmos e Estrutura de Dados
CAPÍTULO 4 – VETORES, MATRIZES E REGISTROS.
Ao utilizarmos variáveis, podemos armazenar somente um valor por vez, há situações em que é
necessário armazenar uma quantidade maior de valores, por exemplo, 10 notas do mesmo aluno. Utilizando
variáveis seriam necessárias 10 para tal.
var nota1, nota2, nota3, nota4, nota5, nota6, nota7, nota8, nota9, nota10: integer
Ufa! São muitas variáveis, imagina se fossem 20 notas do mesmo aluno, ficaria ruim escrever algoritmos
com tantas variáveis, em todos os aspectos, manutenção, leitura, etc. Existem outras estruturas de dados que
facilitariam a forma de armazenar esses dados, essas são chamadas de vetores, matrizes e registros. Vamos
ver abaixo a explicação de cada uma e exemplos de sua utilização.
4.1 VETORES
Esse tipo de estrutura é chamado de matriz unidimensional. Um vetor é representado por seu nome,
tamanho e seu tipo. Em nosso algoritmo vamos declará-los da seguinte forma:
Nosso algoritmo No Pascal
var notas[10] : inteiro; var notas:array[1..10] of integer;
A forma como vou ler ou exibir os valores são feitos indicando individualmente qual elemento se deseja ler
ou exibir. Vamos ver abaixo como inserir as 10 notas de um aluno:
Notas[1] ← 8;Notas[2] ← 5;Notas[3] ← 9;Notas[4] ← 7;Notas[5] ← 2;Notas[6] ← 3;Notas[7] ← 6;Notas[8] ← 9;Notas[9] ← 10;Notas[10] ← 6;
Verifique que o nome é um só o que muda é a informação indicada dentro dos colchetes. A esta
informação dá-se o nome de índice, sendo este o endereço onde o valor está armazenado, ou seja, a nota do
aluno. Podemos imaginar o vetor como uma tabela com dez colunas:
NOTAS8 5 9 7 2 3 6 9 10 6
Vamos ver um exemplo da utilização de vetores para resolver o problema abaixo:
Faça um algoritmo para receber do usuário 20 números. Salve esses dados em um vetor e calcule a
quantidade de números pares.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
29
Apostila de Algoritmos e Estrutura de Dados
Algoritmo PARESvar X[20], cont, qtp : inteiro;
Inicioqtp ← 0;Para cont ← 1 até 20 façaInicio
Escreva(‘Digite um número’);Leia(X[cont]);Se (X[cont] mod 2)= 0 entãoInicio
qtp ← qtp+1;Fim;
Fim;Escreva(‘A quantidade de números pares é ’, qtp);
Fim
program PARES;varX : array[1..20] of integer;cont, qtp : integer;
beginqtp:=0;For cont := 1 to 20 dobegin
write(‘Digite um número’);readln(X[cont]);if (X[cont] mod 2)= 0 thenbegin
qtp:=qtp+1;End;
End;Write(‘A quantidade de números pares é ’, qtp);
end.
Vamos analisar o código acima passo a passo:
Algoritmo PARESvar X[20], cont, qtp : inteiro;
Percebemos que foi declarado um vetor de 20 posições, com o nome de X e duas variáveis cont e qtp, a
variável cont será utilizada como variável de controle do laço de repetição Para e qtp para acumular a
quantidade de números pares.
Inicio
qtp ← 0;
Para cont ← 1 até 20 façaInicio
No trecho acima nós zeramos o valor da variável qtp, isso é necessário, pois iremos utilizá-la para
contar a quantidade de números pares e ela pode conter algum lixo de memória. Em seguida vamos utilizar o
laço de repetição Para de 1 até 20, ou seja, tudo que está dentro do Inicio e Fim do laço será executado 20
vezes.
Escreva(‘Digite um número’);Leia(X[cont]);Se (X[cont] mod 2)= 0 entãoInicio
qtp ← qtp+1;Fim;
Fim;
Ciente de que tudo que está dentro do laço de repetição será executado 20 vezes, controlados pela
variável de controle cont que será incrementada de 1 até 20, solicitamos o usuário a digitar um número,
esse valor é lido e armazenado no vetor X na posição cont que vai variar de 1 a 20. Em seguida utilizamos
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
30
Apostila de Algoritmos e Estrutura de Dados
a estrutura condicional para checar se o valor lido do vetor dividido por 2 resta 0, se sim ele soma o valor de
qtp mais um, perceba que quem recebe esse valor é a própria variável, ou seja, pegamos o último valor da
variável e incrementamos mais 1.
Escreva(‘A quantidade de números pares é ’, qtp);
Fim
No final fora do laço de repetição Para, depois de ser executado 20 vezes, mostramos para o usuário a
quantidade de números pares dos valores informados por ele.
4.2 MATRIZES
Outra estrutura de dados muito utilizada são as matrizes. Vamos imaginar que queremos reescrever o
algoritmo das notas do aluno, agora mantendo o controle para seis alunos ao invés de apenas um. Com os
conhecimentos adquiridos até agora seria necessário criar seis vetores (matrizes unidimensionais) de vinte
posições cada um, um para cada aluno. Esta é uma solução, e funciona, porém, torna nosso trabalho mais
cansativo.
Para facilitar o trabalho com estruturas deste porte, existem as chamadas matrizes (ou matrizes
multidimensionais, se você pensar que vetores são matrizes unidimensionais). A mais comum é a matriz de
duas dimensões. Uma matriz de duas dimensões estará sempre fazendo menção a linhas e colunas e será
representada por seu nome e seu tamanho.
Nosso algoritmo No Pascal
var notas[6,10]: inteiro; var notas:array[1..6, 1..10] of integer;
Percebemos que agora informamos o número de linhas e o número de colunas da matriz
multidimensional, diferente da matriz unidimensional (vetores) que informamos o número de colunas.
Vejamos abaixo como ficaria nossa estrutura utilizando matriz, conforme foi declarado acima:
10 notas
6 a
lun
os
5 10 7 8 9 5 5 6 8 9
10 5 6 9 8 10 10 10 5 8
8 8 8 101
09 9 10 10 10
6 8 7 9 5 10 10 10 5 10
9 9 9 10 7 8 9 10 10 10
9 8 9 8 9 10 7 8 9 10
Matriz [6x10]
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
31
Apostila de Algoritmos e Estrutura de Dados
Olhando a estrutura acima, como queremos armazenar 10 notas de 6 alunos, cada linha será utilizada por um
aluno e cada coluna para uma nota do aluno.
Vamos resolver o algoritmo abaixo utilizando matrizes.
Faça um algoritmo que receba 5 notas de 15 alunos, faça à média e mostre para cada aluno se foi aprovado
ou reprovado e ao final apresente a média das notas da turma e informe para o usuário o desempenho. Veja
as condições de aprovação de cada aluno e desempenho da turma.
Critério para aluno
Média notas Resultado
>=7 Aprovado
>=5 e <7 Recuperação
<5 Reprovado
Critério para turma
Média notas Resultado
>=9 Excelente
>=7 e <=8 Bom
< 7 Ruim
Algoritmo NOTASvar X[15,5],L,C,ST,SA: inteiro;MT, MA : real;
InicioST ← 0;SA ← 0;Para L ← 1 até 15 façaInicio
Para C ← 1 até 5 façaInicio
Escreva(‘Digite a ’,C,’ nota ’);Leia(X[L,C]);SA ← SA + X[L,C];
Fim;MA ← SA/5;ST ← ST + SA;Se MA >= 7.0 então Escreva (“Aprovado, sua média foi ”, MA);SenãoSe ((MA >=5.0) E (MA <7.0)) então
Escreva (“Recuperação, sua média foi ”, MA);
SenãoEscreva (“Reprovado, sua média foi ”, MA);
SA ← 0;Fim;
MT ← ST/75;Se (MT >=9.0) então
program NOTAS;varX : array[1..15,1..5] of integer;L,C,ST,SA: integer;MT, MA : real;
beginST := 0;SA := 0;For L := 1 to 15 doBegin
For C := 1 to 5 doBeginwrite(‘Digite a ’, C,’ nota ’);readln(X[L,C]);SA := SA + X[L,C];
End;MA := SA/5;ST := ST + SA;if (MA >= 7.0)thenWriteln (‘Aprovado, sua media foi ’, MA)Else
If ((MA>=5.0) AND (MA<7.0)) thenWriteln (‘Recuperação, sua media foi ’, MA)ElseWriteln(‘Reprovado, sua média foi’, MA);
SA:=0;End;MT := ST/75;If (MT>=9.0) Then
Writeln(‘Excelente a média da
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
32
Apostila de Algoritmos e Estrutura de Dados
Escreva (“Excelente a média da turma foi ”, MT);
SenãoSe ((MT>=7.0) E (MT <=8.0)) então
Escreva (“Bom, a média da turma foi ”,MT);
SenãoEscreva (“Ruim, a média da turma foi ”, MT);
Fim
turma foi ’, MT)Else
If ((MT >=7.0) AND (MT <=8.0)) Then
Writeln (‘Bom, a media da turma foi ’,MT)
ElseWriteln (‘Ruim, a média da turma foi’, MT);
End.
Vamos analisar o código acima passo a passo:
Algoritmo NOTASvar X[15,5],L,C,ST,SA: inteiro;MT, MA : real;
Primeiramente, declaramos a matriz com nome de X[15,5] isso significa que será uma matriz com 15
linhas e 5 colunas, em seguida declaramos as variáveis L e C como variáveis de controle para o laço de
repetição Para, um para linha (L) e outro para coluna (C) as variáveis ST para soma das notas da turma e a
variável SA para soma das notas do aluno, essas serão utilizadas para fazer o cálculo da média que é a soma
dividido pela quantidade. A variável MT será utilizada para guardar a média da turma e MA para guardar a
média do aluno.
InicioST ← 0;SA ← 0;Para L ← 1 até 15 façaInicio
Para C ← 1 até 5 façaInicio
Escreva(‘Digite a ’,C,’ nota ’);Leia(X[L,C]);SA ← SA + X[L,C];
Fim;MA ← SA/5;ST ← ST + SA;Se MA >= 7.0 então Escreva (“Aprovado, sua média foi ”, MA);SenãoSe ((MA >=5.0) E (MA <7.0)) então
Escreva (“Recuperação, sua média foi ”, MA);Senão
Escreva (“Reprovado, sua média foi ”, MA);
SA ← 0;Fim;
As variáveis ST e SA são zeradas, pois serão utilizadas para fazer a soma das notas e podem conter
algum lixo de memória. Iniciamos o primeiro laço de repetição de 1 até 15 para navegar nas linhas e o
segundo laço de repetição de 1 até 5 para navegar nas colunas. Como necessitamos trabalhar com os dados
que estão nas colunas, o código fica nessa estrutura e quando precisamos realizar algum cálculo depois que
navegamos em todas as colunas da linha o código fica dentro da estrutura do primeiro Para, logo abaixo do
Fim do segundo laço de repetição. Para resolver nosso algoritmo percorremos as 5 colunas de cada linha e
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
33
Apostila de Algoritmos e Estrutura de Dados
vamos somando as notas e depois de navegar nas colunas antes de passar para próxima linha fazemos os
cálculos da média e informamos para o usuário se o mesmo foi aprovado ou está em recuperação ou foi
reprovado. Depois zeramos a variável SA para somar agora as notas do próximo aluno (linha), se eu não
fizer isso ele vai somar as próximas 5 notas com as anteriores informando o resultado da média de forma
errada. Na variável ST somamos as notas para que no final tenhamos condições de saber qual a média da
turma.
MT ← ST/75;Se (MT >=9.0) então
Escreva (“Excelente a média da turma foi ”, MT);SenãoSe ((MT>=7.0) E (MT <=8.0)) então
Escreva (“Bom, a média da turma foi ”,MT);Senão
Escreva (“Ruim, a média da turma foi ”, MT);
Depois que percorremos toda a matriz e somamos todas as notas dos alunos na variável ST, temos agora fora
do laço de repetição saber qual a média da turma e depois informar para o usuário o desempenho da turma.
4.3 REGISTROS
Quando trabalhamos com matrizes percebemos que somente foi possível agrupar informações com o
mesmo tipo de dados. Caso fosse necessário trabalhar com mais de um tipo de dado, precisaríamos criar
matrizes diferentes. Para solucionar esta deficiência podemos utilizar uma estrutura de dados chamada de
Registro. Em um registro poderemos utilizar uma estrutura que agrupe várias informações, que podem ser de
tipos de dados diferentes. Por esta razão, este tipo de dado é considerado heterogêneo. A vantagem é que
esse tipo de estrutura de dados reduz o número de variáveis e é mais fácil para dar manutenção.
Nosso algoritmo No Pascal
var DADOS registro(cod, idade: inteiro, nome: caractere[40], nota : real);
typeDADOS = record
cod : integer;idade : integer;nome : string[40];nota : real;
end;var alunos: DADOS;
Vamos resolver o algoritmo abaixo utilizando matrizes.
Faça um algoritmo que leia os dados de 5 pessoas de uma cidade. Esses dados são salário, idade, número de
filhos. Calcule e mostre:
a) A média de salários;
b) O maior salário;
c) Quantas pessoas possuem salário maior que a média.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
34
Apostila de Algoritmos e Estrutura de Dados
Algoritmo CAD_PESSOAvar pessoa registro(sal: real, filhos, idade: inteiro);maior, soma, media: real;qt, x: inteiro;
Iniciosoma ← 0;maior ← 0;qt ← 0;Para x ← 1 até 5 façaInicio
Escreva(“Digite o seu salário ”);Leia (pessoa[x].sal);Escreva (“Digite a sua idade ”);Leia (pessoa[x].idade);Escreva(“Digite o número de filhos ”, pessoa[x].filhos);soma ← soma+ pessoa[x].sal;Se pessoa[x].sal > maior então
maior ← pessoa[x].sal;Fim;Media ← soma/5;Para x ← 1 até 5 façaInicio
Se pessoa[x].sal > media entãoqt ← qt+1;
Fim;Escreva(“A média é”, media);Escreva(“A qt. de pessoas é”, qt);Escreva(“O maior salário é”, maior);
Fim
program CAD_PESSOA;typedados = record
sal : real;filhos : integer;idade: integer;
end;var pessoa: array [1..5] of dados;maior, soma, media: real;qt, x: integer;
Beginsoma:=0;maior:=0;qt:=0;For x:= 1 to 5 doBegin
Write(‘Digite o seu salário’);Readln(pessoa[x].sal);Write(‘Digite a sua idade’);Readln(pessoa[x].idade);Write(‘Digite o número de filhos’);Readln(pessoa[x].filhos);soma:=soma+pessoa[x].sal;if pessoa[x].sal > maior then
maior:=pessoa[x].sal;End;Media:=soma/5;For x:=1 to 5 doBegin
If pessoa[x].sal > media thenqt:=qt+1;
End;Writeln(‘A media é ’, media);Writeln(‘A qt. De pessoas é ’, qt);Writeln(‘O maior salário é ’, maior);
End.
Exercícios propostos do capítulo 4:
1. Faça um algoritmo que solicite 10 valores para o usuário e no final mostre, utilizando vetores:
a. A soma;
b. A média aritmética;
c. Quantidade de números pares, para isso use a função mod.
2. Faça um algoritmo que receba do usuário 5 valores grave em um vetor e faça a ordenação e imprima
na tela.
3. Faça um algoritmo que carregue uma matriz 2x2 com números inteiros, calcule e mostre em uma
matriz resultado que será a matriz informada pelo usuário multiplicada pelo maior elemento da
matriz.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
35
Apostila de Algoritmos e Estrutura de Dados
4. Faça um algoritmo que preencha uma matriz 5x5 ( 5 linhas e 5 colunas ), sabendo-se que: Os valores
da segunda linha são sempre o dobro da primeira, os valores da terceira linha são sempre o dobro da
segunda e assim por diante até a 5ª linha.
5. Faça um algoritmo que receba os dados de cadastro de alunos do curso técnico do Pronatec. Esses
dados são Nome, Idade, Bairro, Nome da Mãe e Número do arquivo onde estão os documentos.
Sabe-se que são 40 alunos. Mostre a listagem dos cadastrados.
6. Faça um algoritmo que carregue uma matriz 10x10 com números inteiros, execute as trocas
especificadas a seguir e mostre a matriz resultante.
a. A linha 2 com a linha 8;
b. A coluna 4 com a coluna 10;
c. A diagonal principal com a diagonal secundária;
d. A linha 5 com a coluna 10.
7. Faça um algoritmo que receba os dados sobre acidentes de 5 estados brasileiros ( Nome do estado,
número de veículos que circulam no estado, número de acidentes de trânsito). Deseja-se saber:
a. Qual o maior e o menor índice de acidentes de trânsito e o nome do estado em que eles
ocorreram;
b. Qual o percentual de veículos em cada estado;
c. Qual a média de acidentes em cada um dos estados.
8. Faça um programa que converta decimais inteiros em binário.
9. Escreva um programa capaz de calcular a sequência fibonacci, sendo que:
a. O primeiro número sempre é zero;
b. O segundo número sempre é 1;
c. Os próximos números são o resultado da soma dos dois predecessores.
Encontre até a sequência 12. O resultado deve ser 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89.
CAPÍTULO 5 – MODULARIZAÇÃO
Modularização é a técnica de dividir o código em partes menores, também chamadas de sub-rotinas.
São blocos de instruções que realizam tarefas específicas. O código de uma sub-rotina é carregado uma vez
e pode ser executado quantas vezes for necessário. Dessa maneira, os programas tendem a ficar menores e
mais organizados, uma vez que o problema pode ser subdivido em tarefas menores.
Os programas seguem uma estrutura sequencial e quando utilizamos as sub-rotinas essa sequência
pode ser desviada quando uma sub-rotina e chamada pelo programa principal.
Existem dois tipos de sub-rotinas
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
36
Apostila de Algoritmos e Estrutura de Dados
Função: É uma sub-rotina que executa seus procedimentos e no final retorna um valor;
Procedimento: É uma sub-rotina que executa seus procedimentos e no final não retorna nenhum valor.
Vamos ver a sintaxe que utilizaremos nos nossos algoritmos.
Nosso algoritmo No Pascal
Sub-Rotina Nome (parâmetros)var
<declaração de variáveis>Inicio <Instruções>;Fim;
Sub-Rotina Nome (parâmetros): <tipo>var
<declaração de variáveis>Inicio <Instruções>;Fim;
procedure Nome(parâmetros)var
<variáveis>begin
<instruções>end;
function Nome [(parâmetros)] : <tipo>;var
<variáveis> ;begin
<instruções>;end;
Obs.: Nos algoritmos iremos utilizar o mesmo nome Sub-Rotina. Porém as funções terão retorno de valor e
na declaração da sub-rotina devemos definir o tipo de dado de retorno, diferente de procedimento que não
retorna valor, o qual não será necessário informar o tipo de retorno.
Os parâmetros não são obrigatórios, somente se houver necessidade.
Vejamos abaixo alguns exemplos do uso de funções e procedimentos com e sem o uso de parâmetros:
Sem o uso de parâmetros:
Sub-Rotina ADICAOvar X, A, B: real;Inicio
Escreva(“Informe um valor para A:”);Leia (A);Escreva(“Informe um valor para B:”);Leia(B);X ← A+B;Escreva(“O resultado é: ”, X);
Fim;
procedure ADICAO;var X, A, B: real;begin
write(‘Informe um valor para A: ’);readln(A);write(‘Informe um valor para B: ’);readln(B);X := A + B;write(‘O resultado e: ’, X);
end;
No exemplo acima temos um procedimento que solicita dois números e exibe o resultado.
Sub-Rotina ADICAO: realvar A, B: real;Inicio
Escreva(“Informe um valor para A:”);Leia (A);Escreva(“Informe um valor para B:”);Leia(B);ADICAO ← A+B;
Fim;
function ADICAO : real;var A, B: real;begin
write(‘Informe um valor para A: ’);readln(A);write(‘Informe um valor para B: ’);readln(B);ADICAO := A + B;
end;
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
37
Apostila de Algoritmos e Estrutura de Dados
Já no exemplo acima temos um função que retorna valor do tipo real. Essa função solicita dois números e
retorna o resultado da soma desses números. Perceba que o retorno é dado fazendo o nome da sub-rotina
receber a soma.
Com o uso de parâmetros:
Sub-Rotina ADICAO (var A, B: real)var X: real;Inicio
X ← A+B;Escreva(“O resultado é: ”, X);
Fim;
procedure ADICAO(var A, B: real);var X: real;begin
X := A + B;write(‘O resultado e: ’, X);
end;
No exemplo acima foi passado para o procedimento, por parâmetro, os valores que serão armazenados nas
variáveis A e B e depois o valor da soma dos dois valores são armazenados em X e em seguida o valor é
exibido ao usuário.
Sub-Rotina ADICAO (var A, B: real): realInicio
ADICAO ← A+B;Fim;
function ADICAO (var A, B: real) : real;begin
ADICAO := A + B;end;
Já no exemplo acima foi passado para a função, por parâmetro, os valores que serão armazenados nas
variáveis A e B e depois o valor e retornado para o programa principal.
Vejamos de forma ilustrativa como fica um algoritmo que faz a chamada em um procedimento ou função.
Veja que ao chamar à função dentro do algoritmo a execução é desviada para a função que só retorna para o
programa principal depois de executar todas as suas instruções.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
38
Apostila de Algoritmos e Estrutura de Dados
5.1 PASSAGEM DE PARÂMETRO
Os parâmetros têm por finalidade servir como um ponto de comunicação entre uma sub-rotina e o
programa principal, ou com outra sub-rotina de nível mais alto. Desta forma, é possível passar valores de
uma rotina a outra rotina, através do uso de parâmetros que poderão ser formais ou reais.
Serão considerados parâmetros formais quando forem declarados através de variáveis juntamente com a
identificação do nome da rotina, os quais serão tratados exatamente da mesma forma que são tratadas as
variáveis globais ou locais, conforme exemplo acima na declaração de sub-rotina com uso de parâmetros.
Serão considerados parâmetros reais quando estes substituírem os parâmetros formais, quando da
utilização da rotina por um programa principal ou por uma rotina chamadora. Vejamos um exemplo abaixo
de um trecho de código que chama um procedimento:
InicioEscreva (“Escreva um valor”);Leia(X);Escreva (“Escreva outro valor”);Leia(Y);ADICAO (X,Y);
Fim.
BeginWrite (‘Escreva um valor’);Readln(X);Write (‘Escreva outro valor’);Readln(Y);ADICAO (X,Y);
End.
No trecho acima, toda vez que a rotina CALC_ADICAO é chamada, faz-se uso de parâmetros reais.
Desta forma, são parâmetros reais as variáveis X, Y, pois são fornecidos seus valores para as rotinas.
Vejamos abaixo um programa completo com uso de sub-rotina (procedimento) para calcular o fatorial de um
número inteiro.
Algoritmo FATORIAL
Sub-Rotina FATOR (var N: integer);var I, FAT: integer;Inicio
FAT ← 1;Para I ← 1 até N faça
FAT ← FAT * I;Escreva(“A fatorial de” , N, “ equivale a: “, FAT);
Fim;var LIMITE : integer;Inicio
Leia(‘Informe um valor inteiro: ’);Leia(LIMITE);FATOR (LIMITE);
Fim.
program FATORIAL;
procedure FATOR(var N : integer);var I, FAT : integer;begin
FAT := 1;for I:=1 to N do
FAT := FAT * I;writeln(‘A fatorial de ’, N, ‘ equivale a: ’, FAT);
end;var LIMITE : integer;begin
write(‘Informe um valor inteiro: ’);readln(LIMITE);FATOR (LIMITE);
end.
A passagem de parâmetro ocorre quando é feita uma substituição dos parâmetros formais pelos reais
no momento da execução da rotina. Estes parâmetros serão passados de duas formas: por valor e por
referência.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
39
Apostila de Algoritmos e Estrutura de Dados
5.1.1 PASSAGEM DE PARÂMETRO POR VALOR
A passagem de parâmetro por valor caracteriza-se pela não alteração do valor do parâmetro real,
quando este é manipulado dentro da sub-rotina. Assim sendo, o valor passado pelo parâmetro real é copiado
para o parâmetro formal, que no caso assume o papel de variável local da rotina. Desta forma, qualquer
alteração que ocorra na variável local da rotina não afetará o valor do parâmetro real correspondente. O
algoritmo FATORIAL acima é um exemplo de passagem de parâmetro por valor.
5.1.2 PASSAGEM DE PARÂMETRO POR REFERÊNCIA
A passagem de parâmetro por referência caracteriza-se pela ocorrência da alteração do valor do
parâmetro real quando o parâmetro formal é manipulado dentro da sub-rotina chamada. Desta forma,
qualquer modificação feita no parâmetro forma, implica em alteração no parâmetro real correspondente. A
alteração efetuada é devolvida para a sub-rotina chamadora. Veja abaixo o algoritmo FATORIAL, agora
usando passagem de parâmetro por referência.
Algoritmo FATORIAL
Sub-Rotina FATOR (var N: integer; var FAT: integer);Var I: integer;Inicio
FAT ← 1;Para I ← 1 até N faça
FAT ← FAT * I;Fim;var LIMITE, RETORNO : integer;Inicio
Leia(‘Informe um valor inteiro: ’);Leia(LIMITE);FATOR (LIMITE, RETORNO);Escreva(‘A fatorial de ’, LIMITE, ‘ equivale a: ’, RETORNO);
Fim.
program FATORIAL;
procedure FATOR(var N : integer; var FAT: integer);var I: integer;begin
FAT := 1;for I:=1 to N do
FAT := FAT * I;end;var LIMITE, RETORNO : integer;begin
write(‘Informe um valor inteiro: ’);readln(LIMITE);FATOR (LIMITE, RETORNO);writeln(‘A fatorial de ’, LIMITE, ‘ equivale a: ’, RETORNO);
end.
5.1.3 RECURSIVIDADE
Algumas funções matemáticas clássicas podem ser estabelecidas de tal forma que as suas definições
utilizem, de modo recorrente, a própria função que se está definindo. Um exemplo trivial seria a função
fatorial vista no exemplo anterior. Sabemos que fatorial de um número inteiro não negativo é o produto de
todos os números naturais de 1 até o referido número. Quando queremos representar o fatorial de um
número, nós colocamos o número e o símbolo exclamação: 12!, lê-se fatorial de 12.
Exemplos:
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
40
Apostila de Algoritmos e Estrutura de Dados
15! = 15.14.13.12.11.10.9.8.7.6.5.4.3.2.1 = 2004310016
5! = 5.4.3.2.1 = 120
Vejamos o fatorial de 4: (4!)
Portanto, podemos dizer que o fatorial de quatro é ele vezes o fatorial de 3. O fatorial de 3 é ele vezes o
fatorial de 2. O fatorial de 2 é ele vezes o fatorial de 1 e finalmente o fatorial de 1 é ele. Veja abaixo como
ficaria a expressão:
4! = 4.3! = 4.(3.2!) = (4.3).(2.1!) = 4. 3. 2. 1 = 24
Então o fatorial de 4 é igual a 24. Percebemos que existe uma recursividade, onde o fatorial de um número é
definido a partir dos fatoriais dos números menores. Isto significa que, para o cálculo do fatorial, há
necessidade de que se recorra aos fatoriais dos naturais anteriores.
Recursividade é aplicada somente as funções, pois necessita que retornem valor a função chamadora.
Vejamos abaixo como ficaria o algoritmo FATORIAL implementado na forma de função recursiva.
Algoritmo FATORIAL
Sub-Rotina FATOR (var N: integer):realInicio
Se (N<=1) entãoFATOR ← 1;
senão FATOR ← FAT * FATOR(N-1);
Fim;var LIMITE: integer;RETORNO : real;Inicio
Leia(‘Informe um valor inteiro: ’);Leia(LIMITE);RETORNO ← FATOR (LIMITE);Escreva(‘A fatorial de ’, LIMITE, ‘ equivale a: ’, RETORNO);
Fim.
program FATORIAL;
Function FATOR(var N : integer) : real ;begin
if(N<=1) thenFATOR:=1;
elseFATOR := N * FATOR(N-1);
end;var LIMITE: integer;RETORNO : real;begin
write('Informe um valor inteiro: ');readln(LIMITE);RETORNO:=FATOR (LIMITE);writeln('A fatorial de ', LIMITE, '
equivale a: ', RETORNO);end.
Veja no exemplo acima que a sub-rotina FATOR foi chamada da própria função, vejamos o rastreio do
algoritmo acima. Vamos imaginar que o usuário informou o valor 4.
CHAMADA FATOR RESULTADO DA FUNÇÃO N LIMITE RETORNO
FATOR(4) FATOR = 4*FATOR(4-1) 4*6 = 24 4 4 24
FATOR = 3*FATOR(3-1) 3*2 = 6 3
FATOR = 2*FATOR(2-1) 2*1 = 2 2
FATOR = 1 1 1
Embora a utilização da recursividade apresente a vantagem de programas mais simples, ela traz o
inconveniente de sacrificar a eficiência do programa. Isto ocorre devido à necessidade de chamadas
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
41
Apostila de Algoritmos e Estrutura de Dados
sucessivas da função e das operações de empilhamento e desempilhamento, o que demanda um tempo maior
de computação e uma maior necessidade de uso de memória .
Exercícios propostos do capítulo 5:
1. Faça uma função que receba um número inteiro e positivo N como parâmetro e retorne a soma dos N
números inteiros existentes entre o número 1 e esse número:
2. Faça uma função que receba três números inteiros como parâmetros, representando horas, minutos e
segundos e os converta em segundos. Exemplo: 2 h, 40 min. e 10 seg. correspondem há 9610
segundos.
3. Faça uma função que receba , por parâmetro, a altura e o sexo de uma pessoa e retorne o seu peso
ideal. Para homens calcular o peso ideal usando a fórmula a seguir: peso ideal = 72.7 * alt – 58 para
homens e 62.1 * alt – 44.7 para mulheres.
4. Faça uma função que receba, por parâmetro, um valor inteiro e positivo N e retorne o valor de S,
onde a 1ª. Parcela da soma tem N=1, a 2ª. Parcela tem N=2, ..., até N ser igual ao valor digitado.
Ex.: S = 1+ 1/2 + 1/3 + 1/4 +1/N.
5. Escreva uma função recursiva que retorne o máximo divisor comum de dois inteiros dados.
6. Escreva uma função recursiva que retorne o mínimo múltiplo comum de dois inteiros dados.
7. Faça uma função que receba um número n e forneça o número formado pelos algarismos de n
escritos na ordem inversa. Por exemplo, se o número dado for 3876, a função deve fornecer 6783.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
42
Apostila de Algoritmos e Estrutura de Dados
REFERÊNCIAS BIBLIOGRÁFICAS
MEDINA, M.,FERTING, C. Algoritmos e programação: teoria e prática. NOVATEC, 2.ed., 2006.
384 p.
CORMEN, THOMAS H. et.al. Algoritmos: teoria e prática. Tradução da segunda edição [americana]
Vandenberg D. de Souza – Rio de Janeiro: Elsevier, 2002, 4ª. Reimpressão. 898 p.
PRONATEC, disponível em <
http://pronatec.mec.gov.br/cnct/et_informacao_comunicacao/t_informatica.php>, Acesso em
25/06/2013.
Algoritmos e Estruturas de Dados, Guimarães, A. M., Lages, N. A. C., Livros Técnicos e Científicos
Editora S.A, 1985.
Lógica de programação: a construção de algoritmos e estruturas de dados, André Luiz Villar
Forbellone, Henri Frederico Eberspacher – 3. Ed. – São Paulo: Pearson Prentice Hall, 2005.
Algoritmos Estruturados, Harry Farrer – 3. Ed. – São Paulo: LTC, 2011
Apostila Pascal, disponível em http://www.cos.ufrj.br/~sergio/ApostilaPascal.pdf, Acesso em 15/06/2013.
Algoritmos e Estrutura de dados, disponível em < http://www.caelum.com.br/apostila-java-estrutura-
dados/>, Acesso em 15/07/2013.
Programando com Pascal. A linguagem do Turbo Pascal e do Delphi, Evaristo Jaime. Editora Book
Express. 2002
Estrutura de Dados, disponível em < http://www4.fct.unesp.br/ronaldo/uploads/Estrutura%20de
%20Dados%20I%20-%20aula%201.pdf>, Acesso em 25/07/2013.
Escola Estadual “Geraldo Gomes Ribeiro”Rua: José Gomes Ribeiro, nº 60, Limoeiro – Ipatinga – MG – CEP: 35.162-451 - Fone: 3824 – 8391
43