Algortimos

ALGORITMOS
Algoritmos
● Livro texto
– Algoritmos e Programação
Teoria e Prática
● Marco Medina e Cristina Fertig
● Segunda Edição
● Editora Novatec
Algoritmos - Introdução
● Definição geral
– Conjunto de instruções para se resolver um
problema
● Definição em informática
– Conjunto de regras e procedimentos lógicos,
perfeitamente definidos, que levam à solução de
um problema em um número finito de etapas.
● Propriedades
– Finitude: um algoritmo deve sempre terminar após um
número finito de etapas
– Definição: cada passo de um algoritmo deve ser
definido com precisão e sem ambiguidades
– Entrada: valores dados antes do seu início
– Saída: valores resultantes
– Eficácia: operações suficientemente básicas, que
podem ser feitas manualmente, com precisão e em um
período de tempo finito
● Programa de computador
– Conjunto de instruções que será executado pelo
processador em uma determinada sequência.
Esse programa leva o computador a executar
alguma tarefa.
– Assim, um programa é um algoritmo cujas
operações são específicas para o computador e
restritas ao conjunto de instruções que o
processador pode executar.
● Linguagem de programação
– É todo o conjunto de regras e operações que
podem ser executadas por um computador.
● Linguagem de máquina
– Linguagem numérica
● Linguagem de montagem (assembly)
– Linguagem mnemônica
● Programa assembler
● Linguagens de baixo nível x alto nível
– Compilação
– Interpretação
● Estruturação de Algoritmos
– Linguagem natural
● Não é ideal para representar algoritmos por não possuir
rigidez sintática e semântica
● Pessoas diferentes podem descrever/resolver o mesmo
problema de formas diferentes
– Linguagem de programação
● Possui rigidez semântica e sintática
● Não utiliza o idioma nativo
– Fluxograma
● Representa o algoritmo de forma gráfica
Início
leia num1, num2
num1 > num2
maior ← num1 maior ← num2
escreva maior
Fim
– Pseudocódigo
● Tem um grau de rigidez sintática intermediária entre as
linguagens natural e de programação
● Pode ser escrito no idioma nativo
● O pseudocódigo mais conhecido é o Portugol
– Pseudocódigo
● Exemplo:
Algoritmo Maior
var num1, num2, maior: inteiro;
início
leia(num1, num2)
se (num1 > num2) então
maior ← num1;
senão
maior ← num2;
escreva(maior);
fim
Algoritmos - Fundamentos
● Objetivos
– Estruturas básicas de dados
– Definição de tipos de dados
– Sequências de ações
– Operação de atribuição de valores
– Comandos de entrada e de saída
● Manipulação de dados
– Internamente o computador só manipula números
– Linguagens de programação permitem a
manipulação de outros tipos de dados
– Tipos de dado
● Conjunto de objetos que têm o mesmo comportamento
diante de um conjunto definido de operações
● Tipos de dados da maioria das linguagens
– Números inteiros
– Números reais
– Letras
– Valores lógicos
– Tipos de dado
● Operadores lógicos
– e, ou e não
– Precedência
● Parênteses
● não
● e, ou
– Tipos de dado
● Operadores numéricos
– pot: potência entre dois números
● 10 pot 2 = 100
● 2 pot 10 = 1.024
– raiz: radiciação entre dois números

●
9 raiz 2 = 3
●
1.024 raiz 10 = 2
– div: resultado inteiro de uma divisão
● 10 div 4 = 2
● 20 div 5 = 4
– resto: resto da divisão inteira de dois números inteiros

●
10 resto 4 = 2
●
20 resto 5 = 0
– Tipos de dado
● Operadores numéricos
– Precedência
● Parênteses
● pot, raiz
● *, / , div, resto
● + , -
– Transformação das expressões matemáticas na
forma algorítmica
– Exemplos:
a+b
● - (a + b) / c
c
● √x+ y - (x + y) raiz 2
b c
● a+ - a pot b + c / d
d
– Constantes e variáveis
● São informações que ficam armazenadas
temporariamente, em memória, durante a execução de
um programa
● São elementos percententes aos tipos de dados
● São repositórios de elementos pertencentes aos tipos
de dados
● Para serem utilizados, devem ser declarados
identificadores informando em qual local da memória
esses elementos se encontram
– Constantes e variáveis
● Constantes: são valores definidos no início do
programa e que não alteram seu valor
● Variáveis: são valores que podem ser alterados durante
a execução de um programa
– Constantes – sintaxe
● constante <identificador1> = <valor1>;
<identificador2> = <valor2>;
…
<identificadorN> = <valorN>;
– Variáveis – sintaxe
● var <identificador1>[,<identificador2>,...] : <tipo1>;
<identificador3>[,<identificador4>,...] : <tipo2>;
– Identificadores
● Devem começar com letras
● Devem conter letras, números e o caracter '_'
● Não podem ser palavras reservadas
● Notações
– Palavras em negrito são palavras reservadas
– Palavras entre <> são elementos do algoritmo a
serem substituídos por nomes/valores a serem
definidos pelo programador
– Elementos entre [ ] são opcionais
– { } utilizados como comentário, para
documentação, não sendo considerados no
processo de execução
– Exemplo
● constante MÁXIMO = 100;
● var quantidade, filhos, netos: inteiro;
aberto: booleano;
altura: real;
resposta: caractere;
● Atribuição
– É o ato de colocar ou atribuir um valor a uma
variável
– É representada pelo símbolo ←
– Sintaxe
● <identificador> ← <valor do mesmo tipo da variável>;
● <identificador> ← <operação cujo resultado é do
mesmo tipo da variável>;
● Atribuição
– Exemplos
● letra ← “a”
● tamanho ← 2.2 {separação de casa decimal
representada com ponto}
● valor ← 5 * 4
● total ← valor + 7
● aberto ← F
● aberto ← aberto e V
● maior ← valor > 30 {V – se valor maior que 30
F – caso contrário}
● Blocos de instruções
– Instruções sempre executadas em sequência
– Os blocos visam identificar, claramente, onde a
sequência de instruções inicia e termina
– Eles apresentam o início e o término do conjunto
de instruções que serão executados em
sequência
– Todo algoritmo tem, pelo menos, um bloco de
intruções, indicando o início e o término do
mesmo.
● Blocos de instruções
– Sintaxe
● <declaração de variáveis>
início
<primeira instrução do bloco>
<segunda instrução do bloco>
…
<última instrução do bloco>
fim
● Exemplo 1
– Sabendo que a relação entre vértices, arestas e
faces de um objeto geométrico é dada pela
fórmula: vértices + faces = arestas + 2, calcule o
número de vértices de um cubo (6 faces e 12
arestas)
● Exemplo 2
– Elaborar um algoritmo para calcular as raízes da
equação: 2x 2 +4x−3
● Entrada e saída
– Dispositivos de entrada
● Teclado, mouse, scanner, ...
– Dispositivos de saída
● Vídeo, impressora, …
– Exemplos anteriores são ditos não adaptativos.
– Para que um programa possa atender às
diferentes necessidades do usuário, esse deve
poder informar quais os valores a processar
– O programa, no final, deve fornecer os resultados
do processamento
● Entrada de dados
– É o meio pelo qual o usuário pode informar dados
ao programa
– Sintaxe
● leia(<variável>);
– Deve ser fornecido um valor compatível com o
tipo de dados definido
● Saída
– É o meio pelo qual o usuário tem acesso aos
resultados do programa
– Sintaxe
● escreva(<valor>);
– O campo valor pode ser:
● Um texto entre aspas
● Um identificador (variável ou constante)
● Uma expressão
● Uma combinação das possibilidades acima
● Saída
– Exemplos
● escreva(letra);
● escreva(5+2);
● escreva(“5+2”);
● escreva(“5 + 2 = “, 5+2);
● Entrada e Saída
– Exemplo 1
● Sabendo que a relação entre vértices, arestas e faces
de um objeto geométrico é dada pela fórmula: vértices
+ faces = arestas + 2, calcule o número de vértices de
um cubo, sendo que o usuário deve fornecer os valores
para faces e arestas. Informe o resultado no final.
– Exemplo 2
● Elaborar um algoritmo para calcular as raízes de uma
equação do segundo grau.
● Teste de mesa
– É um meio pelo qual se pode acompanhar a
execução de um algoritmo, passo a passo, ou
instrução a instrução
– Tem por objetivo verificar e o algoritmo realiza
realmente a tarefa para a qual foi projetado
– Verifica se o mesmo produz o resultado esperado
para qualquer entrada possível
● Teste de mesa
– Exemplo
● Algoritmo
algoritmo obtem_vertices;
var vertices, faces, arestas: inteiro;
início
1> escreva(“Forneça a quantidade de faces: “);
2> leia(faces);
3> escreva(“Forneça a quantidade de arestas: “);
4> leia(arestas);
5> vertices ← arestas + 2 – faces;
6> escreva(“Quantidade de vertices: “, vertices);
fim
● Teste de mesa
– Exemplo
Linha vertices faces arestas Comentário

1 ? ? ? Variáveis com valores indefinidos
2 ? [6] ? faces lida
3 ? 6 ?
4 ? 6 [12] arestas lida
5 8 6 12 Cálculo de vertices
6 {8} 6 12 Saída com o número de vértices
● Exemplo
– Elabore um algoritmo que leia dois números,
troque os seus valores e mostre seus conteúdos
na saída.
Execute o teste de mesa.
● Resolver os exercícios do capítulo 2 (2.5).
Algoritmos - Condição
● Motivação
– Até aqui a execução de comandos se deu de
forma sequencial
– Todos os comandos foram executados e sempre
na mesma ordem
– Porém devemos, muitas vezes, executar alguns
comandos com base em algumas situações ou
condições
● Sintaxe
– se (<valor booleano>) então
<bloco de instruções 1>
[senão
<bloco de instruções 2>]
<continuação do algoritmo>
Teste de mesa (a=5)
● Exemplo 1 Cmd Linha a
1 1 ?
Algoritmo Ex1; 2 2 [5]
var a: inteiro; 3 3 5
início 4 4 5
1 5 5 {5}
escreva(“Entre com um valor: “);
6 6 5
2 leia(a);
3 se (a=5) então
Teste de mesa (a=2)
início
Cmd Linha a
4 escreva(“Condição Verdadeira”); 1 1 ?
5 escreva(“O valor é “, a); 2 2 [2]
fim 3 3 2
4 6 2
6 escreva(“Fim do algoritmo”);
fim
Teste de mesa (a=5)
Cmd Linha a
● Exemplo 1
1 1 ?
Algoritmo Ex1; 2 2 [5]
var a: inteiro;
início 3 3 5
1 escreva(“Entre com um valor: “); 4 4 5
2 leia(a); 5 5 {5}
3 se (a=5) então 6 8 5
início
4 escreva(“Condição Verdadeira”); Teste de mesa (a=2)
5 escreva(“O valor é “, a);
fim Cmd Linha a
senão 1 1 ?
início 2 2 [2]
6 escreva(“Condição Falsa”); 3 3 2
7 escreva(“O valor é “, a);
4 6 2
fim
8 5 7 {2}
escreva(“Fim do algoritmo”);
6 8 2
fim
● Exercícios
– Faça um algoritmo que leia a idade de um pessoa
e diga se é maior de idade ou não. Considerar
idade maior ou igual a 18 anos como maioridade.
DICA: use uma constante para armazenar o valor
da maioridade
– Elabore um algoritmo que leia dois números e
informe o maior entre eles.
Algoritmos – Condição
● Condição composta
– Sintaxe
se (cond1 op.lógico cond2 op.lógico cond3 … condn) então
comando
– Exemplos
se (n1=1 e n2=2) então …
se (n1>5 ou n1<2) então …
se (n1=7 e n2=8) ou (n3=9 e letra='s') então …
– Erros comuns
se (n1 = n2 = n3) então …
se (5 < n1 < 10) então ...
● Condição composta
– Exercício
● Elabore um algoritmo que leia um número e informe se
ele é positivo, maior que 200 e par.
● Condições encadeadas
– Exemplo:
● Uma determinada empresa efetua descontos
progressivos de acordo com o valor total da compra, da
seguinte forma:
– Desconto de 12% para as compras acima de R$1.000,00
– Desconto de 10% para as compras acima de R$ 800,00
– Necessidade do uso
● Evitar execução desnecessária de testes de condição
● Exemplo
se (n = 1) então
comando1;
se (n = 2) então
comando2;
se (n = 3) então
comando3;
…
se (n = n) então
comandon;
– Sintaxe 1
se <valor booleano> então
<bloco de intruções 1>
senão
senão
...
– Sintaxe 2
<bloco de intruções 1>
senão se <valor booleano> então
senão se <valor booleano> então
...
– Exercício 1
● Elabore um algoritmo que leia três números e determine
quantos são iguais entre si. Use condições encadeadas.
– Exercício 2
● Elabore um algoritmo que leia um valor de compra e
informe o valor de desconto e o valor líquido dessa
compra, sabendo que o valor do desconto segue as
seguintes regras:
– Desconto de 12% para as compras acima de R$1.000,00
● Comando caso
– Pode ser visto como um particularidade do
comando se
– Tem por objetivo facilitar um uso particular de
comandos se encadeados
● Comando caso
– Sintaxe
caso <valor inteiro/caractere> seja
<primeiro valor inteiro/caractere>:
<bloco de instruções>
<primeiro valor inteiro/caractere>:
…
default:
<bloco de instruções final>
– Observação
● Os tipos de dados para teste devem ser inteiros ou
caracteres
● Comando caso
– Exemplo
● Elabore um algoritmo que identifique se um número
digitado é igual a 1, 5 ou 10. Caso não seja nenhum
deles, informar “Valor inválido”
● Comando caso
– Exemplo
algoritmo teste;
var n1:inteiro;
início
escreva(“Informe um número a testar: “);
leia(n1);
caso n1 seja
1: escreva(“digitado valor 1”);
default: escreva(“Valor inválido”);
fim
● Resolver os exercícios do capítulo 3 (3.3).
Algoritmos – Repetição
● Comando enquanto
– Exemplo
● Funcionamento de um elevador
– Na subida
● enquanto não chegar ao andar mais alto selecionado faça
início
suba um andar
se chegou ao andar então
início
pare;
abra a porta;
feche a porta;
fim
fim
– Exemplo
● Funcionamento de um elevador
– Na descida
● enquanto não chegar ao andar baixo selecionado faça
início
desca um andar
se chegou ao andar então
início
pare;
abra a porta;
feche a porta;
fim
fim
– Sintaxe
enquanto <valor booleano> faça
● Comando repita
– Sintaxe
repita
até <valor booleano>;
● Comando para
– Sintaxe
para (<instrução de preparação>; <condição de
controle>; <passo para alcance da condição>) faça
– Exemplo 1
● Faça um algoritmo que escreva 100 vezes o texto: “Não
vou mais fazer bagunça.”, utilizando um comando de
repetição.
– Exemplo 2
● Faça um algoritmo que leia 100 números e retorne a
soma e a média desses valores
– Exemplo 3
● Faça um algoritmo que calcule a multiplicação de dois
números inteiros sem utilizar o operador “*”. Um vez
disso, utilize apenas o operador de adição.
– Exemplo 4
● Faça um algoritmo que calcule a soma de todos os
números ímpares dentro de uma faixa de valores
determinada pelo usuário.
Algoritmos - Vetores
● Variáveis Compostas Homogêneas
● Motivação
– Exemplo
● Elabore um algoritmo que leia 50 números e calcule a
média aritmética entre esses números. No final mostre
a média.
Algoritmo exemplo;
var n1, n2, n2, n4, … , n50 : inteiro;
media: real;
início
media ← 0;
escreva(“Informe o primeiro número: “);
leia(n1);
media ← media + n1;
…
escreva(“Informe o quinquagésimo número: “);
leia(n50);
media ← media + n50;
media ← media / 50;
escreva(“Media: “, media);
fim.
● Vetores unidimensionais
– Sintaxe
<identificador>: vetor [<número de elementos>] de <tipo>;
Algoritmo versao_1;
var n: vetor [50] de inteiro;
media: real;
início
media ← 0;
escreva(“Informe o primeiro número: “);
leia(n[1]);
media ← media + n[1];
…
escreva(“Informe o cinquagésimo número: “);
leia(n[50]);
media ← media + n[50];
fim.
Algoritmo versao_2;
var n: vetor [50] de inteiro;
media: real;
i : inteiro;
início
media ← 0;
para (i ← 1; i <= 50; i ← i + 1) faça
início
escreva(“Informe o valor “, i, “: “);
leia(n[i]);
media ← media + n[i];
fim
fim.
● Exemplo 1
– Faça um algoritmo que, dado um vetor numérico de
100 elementos já preenchido, verifique se há
ocorrências de um determinado valor informado pelo
usuário. Se houver, informar a(s) posição(ções) em
que esse valor se encontra dentro do vetor.
● Exemplo 2
– Elabore um algoritmo que leia dois vetores de 50
números e gere um terceiro vetor como a soma dos
outros dois.
● Exemplo 3
– Elabore um algoritmo que leia um vetor de 60
números e inverta os seus valores.
● Vetores bidimensionais
– Sintaxe
<identificador>: vetor [<número de linhas>,
<número de colunas>] de <tipo>;
● Elabore um algoritmo que leia os números de
uma matriz de ordem 3x4
Algoritmo le_matriz;
var matriz: vetor [3,4] de inteiro;
i, j : inteiro;
início
para (i ← 1; i <= 3; i ← i + 1) faça
para (j ← 1; j <= 4; j ← j + 1) faça
início
escreva(“Informe o elemento [“, i, ”,” ,j ,”]:”);
leia(matriz[i,j]);
fim
fim.
Algoritmos - Módulos
● Objetivo
– Divisão de tarefas complexas e longas em
atividades mais simples e curtas
– Abordagem top-down
● Parte-se do todo, dividindo-o em componentes
menores, repetindo-se esse processo até o menor
componente
– Abordagem bottom-up
● É o processo inverso, onde se inicia a resolução de um
problema pela parte menor, menos complexa, e vai
agregando novas partes até chegar so problema maior.
● Vantagens
– Reaproveitamento das atividades em outros
problemas
– Diminuição do tempo de resolução do problema.
● Modularizando algoritmos
– É a forma de didivir as tarefas em subalgoritmos,
onde cada módulo cuida de uma parte do
problema.
– Cada módulo funciona como um programa, com
entrada, processamento e saída bem definidos.
– As entradas e saídas dos módulos são a forma de
interação entre si.
– Para que um módulo seja executado é preciso
que o mesmo seja chamado por outro módulo.
– Todos os algoritmos devem ter pelo menos um
módulo principal.
– É sempre por esse módulo que o algoritmo inicia
sua execução.
– Cada módulo chamado é executado do início até
o fim e o mesmo pode chamar outro módulos.
– Após o fim de cada módulo, o algoritmo continua
do ponto em que o módulo foi chamado. Ponto
esse conhecido como ponto de ativação.
– Na maioria das linguagens de programação os
subprogramas devem ser definidos/escritos antes
de sua utilização.
● Modularizando algoritmos: exemplo
Algoritmo modulo;
var a1, a2, a3: inteiro;
Teste {Módulo Teste}
início
a1 ← a2;
a3 ← a1 + a2;
a2 ← a2 + 6
fim
Principal {Módulo Principal}

início
a2 ← 3;
Teste();
escreva(a1, a2, a3);
fim
– Todo módulo tem um cabeçalho, também chamado
de interface ou protótipo.
– Sintaxe:
● <nome do módulo>([lista de parâmetros]):
<tipo do valor de retorno>
– Exemplo
●
Teste(p1:inteiro; p2:booleano; p3: caractere): inteiro
– A ativação do módulo é feita apenas pelo nome do
mesmo, com seus parâmetros dentro de parênteses
– Exemplo
● Teste(10, V, 'a')
● Retorno de valores
– Um módulo pode ou não retornar valores
– Um módulo que não retorna valores pode ser dito
de módulo com retorno neutro
– O módulo principal sempre é neutro
– Na linguagem Pascal um módulo neutro é
chamado de procedimento e um módulo não
neutro é chamado de função.
– Em C ambos os módulos são chamados de
funções.
– O retorno de valores é a saída do módulo.
● Retorno de valores
– O valor de retorno de um módulo precisa ser
recebido e tratado dentro do módulo ativador.
– Normalmente esse valor é armazenado em uma
variável, mas pode ser usado em comparações,
escritas, dentre outros.
– Comando para retorno de valor
● retorne(<valor>);
– Idependentemente de onde esteja esse comando,
o módulo ativado é encerrado e o controle volta
para o módulo ativador.
● Retorno de valores – Exemplo
– Elaborar um algoritmo que identifique se um
número informado é par, ímpar ou um número
bissexto.
Algoritmo testa;
var n1, opcao: inteiro;
Principal(): neutro
início
Leitura_Dados();
caso opção seja:
1: se (Par()) então
escreva (“Número par.”);
senão
escreva (“Número ímpar.”);
2: se (Bissexto()) então
escreva(“Ano bissexto.”)
senão
escreva(“Ano não é bissexto.”);
Par(): booleano
início
se (n1 resto 2 = 0) então
retorne (V);
senão
retorne (F);
fim
Bissexto(): booleano
início
se (n1 resto 4 = 0 e n1 resto 100 <> 0) ou (n1 resto 400 = 0)) então
retorne (V);
senão
retorne (F);
fim
Leitura_Dados(): neutro
início
escreva(“Entre com o valor a ser testado”);
leia (n1);
repita
escreva(“Entre com o tipo de identificação do valor: ”);
escreva(“Opção 1: par ou ímpar: ”);
escreva(“Opção 2: bissexto: ”);
leia (opcao);
até (opcao = 1) ou (opcao = 2);
fim
● Escopo de variáveis
– Cada módulo pode ser considerado um
subpograma
– E deve ser o mais independente possível
– Assim, cada módulo deve ter suas próprias
variáveis
– A dependência entre os módulos fica restrita à
interface
● Escopo de variáveis – Variáveis globais
– São declaradas antes de todos os módulos
– Podem ser manipuladas em qualquer módulo
– Sintaxe:
<declaração de variáveis globais>
<primeiro módulo>
<segundo módulo>
…
<módulo principal>
● Escopo de variáveis – Variáveis globais
– Vantagem
● Fácil utilização
– Desvantagens
● Dependência entre os módulos
● Uma alteração do valor em um módulo será vista em
todos os módulos. Assim, uma alteração de uma
variável global deve ser analisada em todos os módulos
que a utilizam
● Escopo de variáveis – Variáveis locais
– São declaradas no início de cada módulo que
pertencem
– Essas variáveis só podem ser acessadas dentro
do módulo em que foram declaradas
– Há linguagens que não definem variáveis locais
para os blocos principais (Pascal)
– Há linguagens que implementam variáveis locais
para os blocos principais
● Escopo de variáveis – Variáveis locais
– Variáveis locais e globais podem ter o mesmo
nome
– O escopo da variável local prevalece sobre o
escopo da variável global
– Pode haver variáveis locais de mesmo nome em
módulos diferentes
– A variável local só existirá enquanto o módulo
estiver ativo
● Passagem de parâmetros
– Os parâmetros são os valores que são informados
na chamada do módulo
– Esses valores podem ser chamados de
argumentos
– No módulo ativador os argumentos podem ser
constantes, valores literais (números, letras, etc)
ou variáveis
– Dentro os módulos os parâmetros funcionam
como variáveis locais
● Passagem de parâmetros - por valor
– Aqui uma cópia da variável é feita durante a
ativação do módulo
– Os valores dos argumentos são atribuídos aos
parâmetros de entrada no módulo ativado
– O parâmetro é uma variável local dentro do
módulo ativado, independente dos argumentos de
ativação
– Exemplo
● Cabeçalho
Media(n1, n2, n3, n4: inteiro): real;
● Ativação
m1 ← Media(6, 8, 10, 5);
v1 ← 6;
escreva(Media(v1, 8, 10, 5));
v1 ← 6; v2 ← 8; v3 ← 10; v4 ← 5;
m1 ← Media (v1, v2, v3, v4);
– Os argumentos devem ser passados conforme os
parâmetros foram declarados no cabeçalho do
módulo
Média(n1, n2, n3, n4: inteiro): real;
m1 ← Média (v1, v2, v3, v4);
m1 ← Média (v2, v1, v4, v3);
● Passagem de parâmetros - por referência
– O que é passado para o módulo é o endereço da
variável e não uma cópia do seu valor
– Assim, os parâmetros no módulo ativado ocupam
o mesmo espaço dos argumentos do módulo
ativador
– Os parâmetros e os argumentos ocupam o
mesmo espaço de memória, sendo, efetivamente,
a mesma variável.
– Na chamada dos módulos não podem ser usadas
constantes ou valores explícitos
– Devem ser usadas apenas variáveis
– Os parâmetros podem ser usados tanto como
entrada como saída
– É o artifício usado quando se precisa que o
módulo retorne mais de um valor ao mesmo
tempo
– Sintaxe
● Cabeçalho
<nome do módulo>(ref <identificador>:tipo):<tipo de retorno>
● Ativação
<nome do módulo>(ref <identificador>);
● Exercícios
– Capítulo 5. Página 111.
● 1. Faça um algoritmo que receba o tamanho dos três
lados de um triângulo e faça as seguintes atividades:
retorne se os três lados formam um triângulo e que tipo
de triângulo é este. Cada uma dessas atividades deve
ser um módulo.
● Exercícios
● 3. Faça um algoritmo que calcule a soma dos N
primeiros números primos, sendo N definido pelo
usuário no módulo principal. O algoritmo ainda deverá
ter os módulos Soma_Primos e Primo.
● Exercícios
● 5. Faça um algoritmo que calcule a média aritmética de
todas as turmas de uma escola. Considere como entradas
o número de turmas e o número de alunos de cada turma.
A média aritmética de cada turma deve ser apresentada,
além da média geral, que será o resultado da média das
turmas. O algoritmo deverá ter os módulos Média_Turma
e Média_Escola. O usuário entrará, dentro do módulo
principal, com a quantidade de turmas e, dentro do
módulo Média_Escola, com o número de alunos de cada
turma.
Algoritmos - Recursividade
● Chamada recursiva
– É quando um módulo faz chamada a si mesmo
● Função de recorrência
– É uma função expressa em função de si mesma,
ou seja, a resolução da função implica uma
resolução anterior da mesma função para outro
valor
– Para a conclução da função é necessário ter um
valor base para qual a resolução da função não
seja recorrente
● Princípio da indução matemática
– Método de prova de teoremas que envovle
sequências infinitas, como o conjunto de números
inteiros
– Se método se inicia pela demonstração do
teorema para um valor base
– Depois supõe-se que o teorema é válido para um
valor n qualquer
– Por fim, mostra-se a sua validade para n+1
● Exemplos de funções recorrentes
– R(x) = 10 * R(x-1) + 2 para x>1 e R(x) = 1 para
x=1
– Fibonacci
● fib(n) = fib(n-1) + fin(n-2) para n>1
● Fib(0) = 0 e fib(1) = 1 (base)
– Fatorial
● n! = n * (n-1)! Para n>0
● 0! = 1 (base)
● Funções que podem ser representadas
recursivamante
– Exponenciação (expressa por multiplicações)
n n−1
● x = x∗x para n > 0
● x0 = 1 (base)
– Multiplicação (expressa por adições)
● x∗ y = x+ x∗( y−1) para n > 0
● x∗0 = 0 (base)
● Funções que podem ser representadas
recursivamante
– Somatórios
n n−1
● ∑i = n+ ∑ i para n > 1
i=1 i=1
● ∑i = i para n=1 (base)

i=1
● Recursividade expressa por módulos
– O módulo ativador e o ativado são os mesmos
– Porém, cada módulo chamado tem seu próprio
espaço de memória
– Formato genérico
Recursivo (r1: inteiro): inteiro;
var v1, v2: inteiro;
início
– <operações do módulo>
– V2 ← Recursivo(v1);
– <operações do módulo>
fim
● Recursividade expressa por módulos
– O problema da estrutura anterior é que a mesma
nunca se encerra
– Para que o processo chegue ao final é necessário
haver um ponto de parada
– Esse ponto explicita a saída do módulo e equivale
à base da equação nas funções de recorrência
● Fatorial
Fatorial_recursivo (n: inteiro): inteiro
var fat: inteiro;
inicio
se (n = 0) então {base}
fat ← 1;
senão
fat ← n * Fatorial_recursivo(n – 1); {função recorrente}
retorne(fat)
fim
● Fatorial
Principal ( ): neutro
var fatorial, num : inteiro;
inicio
escreva(“Entre com o valor a ser calculado o fatorial: “)
leia(num);
fatorial ← Fatorial_Recursivo(num);
escreva(“O fatorial é: “, fatorial)
fim
Algoritmos - Registros
● Registros
– São a forma de representar estruturas de dados
compostas heterogêneas
– Quando se deseja trabalhar com um objeto mais
complexo, que necessite de mais de um valor
para identificá-lo
– Agrega informações que são naturalmente
atreladas ao objeto
– Exemplo
● Cadastro de pessoas
● Sintaxe
<identificador>: Registro
início
<campo 1>:<tipo do campo>;
…
<campo n>:<tipo do campo>;
fim
– Cada campo funciona como uma variável primitiva, mas
todos os campos estão agrupados no mesmo registro.
● Exemplo
var
Ficha_Academia: Registro
início
matricula : inteiro;
nome : vetor [50] de caracter;
peso : real;
altura : real;
instrutor : vetor [50] de caracter;
mês_matricula : inteiro;
ano_matricula : inteiro;
fim
● Exemplos de uso
leia(Ficha_Academia.matricula);
escreva(Ficha_Academia.nome);
Ficha_Academia.peso ← 80;
● Formas incorretas
leia(Ficha_Academia);
escreva(Ficha_Academia);
● Definindo tipos de dados
– Exemplo 1
tipo
Ficha_Academia: Registro
início
...
fim
var
Aluno1, Aluno2 : Ficha_Academia;
– Exemplo 2
tipo
data: Registro
início
dia : inteiro;
mes : inteiro;
ano : inteiro;
fim
var
data_nascimento, data_admissao : data;
início
data_nascimento.dia ← 16;
data_nascimento.mes ← 09;
data_nascimento.ano ← 2003;
– Exemplo 3
tipo
data: Registro
início
dia : inteiro;
mes : inteiro;
ano : inteiro;
fim
tipo
Cliente : Registro
início
data_nascimento :data;
fim
var
pessoa : cliente
início
pessoa.nome ← “Antonio Jose”;
pessoa.data_nascimento.dia ← 22; pessoa.data_nascimento.mes ← 10;
pessoa.data_nascimento.ano ← 2000;
● Vetores de registros
– Sintaxe
tipo <tipo de registro>: Registro
inicio
<campo 1> : <tipo de campo>;
…
<campo n> : <tipo de campo>;
fim
tipo <tipo vetor>: vetor [<tamanho>] de <tipo registro>;
● Vetores de registros
– Exemplo
tipo aluno: Registro
inicio
telefone : vetor [10] de caracter;
fim
tipo turma : vetor [50] de aluno;
var turma_algoritmo : turma;
inicio
turma_algoritmo[1].nome ← “adfaf sfsklj”;
turma_algoritmo[2].nome ← “dpfdfjasfja”;
...
● Registro com vetores
– Sintaxe
tipo <tipo de registro>: Registro
inicio
…
<campo n> : vetor [<tam1, tam2>] de <tipo do campo>;
fim
● Registro com vetores
– Exemplo
tipo vendas : Registro
inicio
cod_produto : inteiro;
quantidade : vetor [10, 12] de inteiro;
{venda mensal dos últimos 10 anos}
fim
var
balanco : vendas;
inicio
balanco.cod_produto ← 1;
balanco.quantidade[1,1] ← 20; {qtde vendas ano 1 mes 1}
● Vetores de registros com vetores
– Exemplo
tipo vendas_bimestre : Registro
inicio
cod_produto : inteiro;
quantidade : vetor [6, 2] de inteiro;
{venda mensal de cada bimestre}
fim
var
balanco : vetor [10] de vendas_bimestre;
inicio
balanco[1].cod_produto ← 1;
balanco[1].quantidade[1,1] ← 20; {vendas ano 1, bimestre 1, mes 1}
● Exercícios
– 8.3 Exercícios do capítulo
Algoritmos - Arquivos
● Arquivos
– São estruturas de dados persistentes.
– Armazenam os dados de forma permanente em
dispositivo de armazenamento secundário.
– São usados para armazenar e acessar
dados/informações dentro de um computador
– O sistema operacional tem rotinas para criar,
remover, ler, atualizar, abrir e fechar arquivos.
– Os programas fazem chama a essas rotinas do
sistema operacional.
● Arquivos de registros sequenciais
– Os arquivos são formados apenas de registros do
mesmo tipo
– Sintaxe
<identificador>: Registro
início
…
<campo n>:<tipo do campo>;
fim
<identificador>: Arquivo de <tipo de registro base>
– Exemplo 1
tipo Registro_Aluno_Disciplina: registro
início
disciplina: vetor [50] de caractere;
ano: inteiro;
aluno: vetor [50] de caractere;
média: real;
fim
var
reg_aluno: Registro_Aluno_Disciplina; {1 registro}
arquivo_notas: arquivo de Registro_Aluno_Disciplina;
{1 arquivo de registros}
– Exemplo 2
tipo arquivo_notas_bimestre: arquivo de
Registro_Aluno_Disciplina;
var
notas_bim1, notas_bim2, notas_bim3, notas_bim4 :
arquivo_notas_bimestre;
● Funções de manipulação
– Abra_Arquivo
– Feche_Arquivo
– Grave_Arquivo
– Leia_Arquivo
– Posicione_Arquivo
– FDA (Fim De Arquivo)
– Abra_Arquivo
● Sintaxe
Abra_Arquivo(<Nome do arquivo>, {Nome real}
<Identificador do arquivo>,
<Modo>); {inicial ou final}
● Exemplo
Abra_Arquivo(“Arquivos/Notas/Algoritmo/TurmaB”,
notas_bim1,
inicial);
● Caso não exista o arquivo, será criado um arquivo
vazio.
– Feche_Arquivo
● Sintaxe
Feche_Arquivo(<identificador do arquivo>)
● Exemplo
Feche_Arquivo(notas_bim1);
● Em muitas linguagens o não fechamento do arquivo
implica na perda das alterações realizadas.
– Grave_Arquivo
● Sintaxe
Grave_Arquivo(<identificador do arquivo>,
<Registro>);
● Exemplo
Grave_Arquivo(notas_bim1, reg_aluno);
● O registro será gravado na posição em que o ponteiro
do arquivo se encontrar, sobrepondo a informação
existente.
● Após essa operação o ponteiro será movido para a
próxima posição do arquivo.
– Leia_Arquivo
● Sintaxe
Leia_Arquivo(<identificador do arquivo>,
<Registro>);
● Exemplo
Leia_Arquivo(notas_bim1, reg_aluno);
● O comando recupera os dados de um registro do
arquivo e os atribui a um registtro do programa.
● O registro a ser lido será o apontado pelo ponteiro.
● Após a leitura o ponteiro será movido para a próxima
posição do arquivo.
– Posicione_Arquivo
● Sintaxe
Posicione_Arquivo(<identificador do arquivo>,
<Posição>);
● Exemplo
Posicione_Arquivo(notas_bim1, 10);
– FDA
● Sintaxe
FDA(<identificador do arquivo>);
● Exemplo
FDA(notas_bim1);
● Retorna V caso o ponteiro aponte para o final do
arquivo e F caso contrário.
– Todas as funções retornam um valor booleano.
– Com exceção da função FDA, o retorno V indica
que a operação foi executada com sucesso.
– A função Abra_Arquivo retorna F se o arquivo não
existir
– A função Feche_Arquivo retorna F se o arquivo
não for aberto previamente
– A função Grave_Arquivo retorna F se não houver
permissão de escrita ou se o tipo do registro for
diferente dos registros do arquivo.
– A função Leia_Arquivo retorna F se ponteiro
estiver apontando para o fim de arquivo ou se o
tipo do registro for diferente dos registros do
arquivo.
– A função Posicione_Arquivo retorna F se a
posição indicada for maior que o número de
registros do arquivo.
● Arquivos texto
– São compostos de caracteres e não de registros.
– Sintaxe
<Nome do arquivo>: Arquivo de caractere;
– Exemplo
Arquivo_historia : Arquivo de caractere;
– Os acessos a esses arquivos são sequenciais.
– Não é implementada a função posicione_arquivo.
● Arquivos texto
– Funções de manipulação
● Abra_Arquivo
– Sintaxe
Abra_Arquivo(<Nome do arquivo>,<Identificador do arquivo>,
<modo>);
● Feche_Arquivo
– Sintaxe
Feche_Arquivo(<Identificador do arquivo>);
● Arquivos texto
● Grave_Arquivo
– Sintaxe
Grave_Arquivo(<Identificador do
arquivo>,<Caractere/sequência de caracteres>);
– Exemplos
Grave_Arquivo(nomes,”A”);
Grave_Arquivo(nomes, “Jose da Silva”);
nome1: vetor [50] de caractere;
nome1 ← “Pedro”
Grave_Arquivo(nomes,nome1);
● Arquivos texto
● Leia_Arquivo
– Sintaxe
Leia_Arquivo(<Identificador do arquivo>, <variável caractere
ou vetor de caracteres,<tamanho>);
● Arquivos texto
● FDA (Fim de arquivo)
– Sintaxe
FDA(<Identificador do arquivo>)
● Arquivos de registros indexados/diretos
– Podem ser acessador diretamente por uma chave.
– A chave identifica unicamente um registro.
– São usadas estruturas chamadas de índices para
facilitar o acesso pela chave.
– Sintaxe
tipo <Tipo registro base>: Registro
início
<campo 1>: <tipo de campo>;
<campo 2>: <tipo de campo>;
…
<campo n>: <tipo de campo>;
fim
<Identificador> : Arquivo Indexado de <Tipo registro
base>, Chave <campo-chave>
– Exemplo
tipo registro_aluno_disciplina : Registro
início
matricula: inteiro;
disciplina: vetor [50] de caractere;
media: real;
fim
var
reg_aluno: registro_aluno_disciplina;
arquivo_notas_bimetre1: Arquivo indexado de
registro_aluno_disciplina, Chave matricula
● Abra_Arquivo
– Sintaxe
Abra_Arquivo(<Nome do arquivo>,<Identificador do arquivo>)
● Feche_Arquivo
– Sintaxe
Feche_Arquivo(<Identificador do arquivo>)
● Grave_Arquivo
– Sintaxe
Grave_Arquivo(<Identificador do arquivo>,<Registro>,<chave>);
● Leia_Arquivo
– Sintaxe
Leia_Arquivo(<Identificador do arquivo>,<Registro>,<chave>);
● Não são implementadas as funções Posicione_Arquivo e
FDA.

Algortimos

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algortimos

Enviado por

Direitos autorais:

Formatos disponíveis

ALGORITMOS

leia num1, num2

num1 > num2

maior ← num1 maior ← num2

– raiz: radiciação entre dois números

– resto: resto da divisão inteira de dois números inteiros

Linha vertices faces arestas Comentário

Principal {Módulo Principal}

● ∑i = i para n=1 (base)

Você também pode gostar