apostila algoritmos e estrutura de dados_2

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


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


2


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.


3


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)


4


“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.


5


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


6


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.


7


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.


8


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.


9


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:


10


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.


11


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.


12


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”.


13


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 “:”.


14


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.


15


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


16


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


17


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;


18


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


19


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


20


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;


21


Á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.


22


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


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


endelsebegin



23


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


24


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


Fim;

For x:= Expressão1 to Expressão2 do Begin


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


25


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


Fim;

While <condição> faça Begin


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);


26


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.


27


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)).


28


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.


29


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


30


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.


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]


31


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


32


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


33


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.


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.


34


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.


35


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


36


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.


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;


37


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.


38


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.


39


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:


40


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


41


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.


42


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.


43

http://www4.fct.unesp.br/ronaldo/uploads/Estrutura%20de%20Dados%20I%20-%20aula%201.pdf

http://www4.fct.unesp.br/ronaldo/uploads/Estrutura%20de%20Dados%20I%20-%20aula%201.pdf

http://www.caelum.com.br/apostila-java-estrutura-dados/

http://www.caelum.com.br/apostila-java-estrutura-dados/

http://www.cos.ufrj.br/~sergio/ApostilaPascal.pdf

http://pronatec.mec.gov.br/cnct/et_informacao_comunicacao/t_informatica.php

apostila algoritmos e estrutura de dados_2

Documents