CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE
SERGIPE
COORDENADORIA DE INFORMÁTICA
PROGRAMAÇÃO I
LÓGICA DE PROGRAMAÇÃO
Prof. André Luiz Sozzi
Curso de Informática
Módulo 6 - Lógica de Programação
Pag.
2
Curso de Informática
Pag.
ÍNDICE
Capítulo 1
Capítulo 2
Capítulo 3
Capítulo 4
Introdução
1.1 Ciclo de Vida do Sw .........................................................................
1.2 Processamento de Dados ..................................................................
Algoritmos Estruturados
2.1 Conceitos ........................................................................................
2.2 Programação Estruturada ................................................................
2.3 Constantes .......................................................................................
2.4 Variáveis .........................................................................................
2.5 Expressões Aritméticas ....................................................................
2.6 Expressões Lógicas .........................................................................
2.7 Expressões Literais ..........................................................................
2.8 Comando de Atribuição ...................................................................
2.9 Comandos de Entrada e Saída ..........................................................
2.10 Estruturas de Controle
2.10.1 Seqüência ...........................................................................
2.10.2 Condição (Decisão) ............................................................
2.10.3 Repetição ...........................................................................
2.11 Lista de Exercícios ..........................................................................
2.12 Algoritmos de Quebras de Controle ................................................
Modularização
3.1 Introdução ......................................................................................
3.2 Conceito .........................................................................................
Exemplo ..........................................................................................
3.2.1 Visões de um módulo ...........................................................
3.3 Ferramentas para Modularização ....................................................
3.4 Regras de Escopo ............................................................................
3.5 Comunicação entre módulos ...........................................................
Exemplos de Comunicação ..............................................................
3.6 Recursividade ..................................................................................
3.7 Lista de Exercícios ..........................................................................
Variáveis Compostas
4.1 Homogêneas
4.1.1 Definição .............................................................................
4.1.2 Vetor ..................................................................................
4.1.3 Lista de Exercícios...............................................................
4.1.4 Matriz..................................................................................
4.1.5 Lista de Exercícios...............................................................
4.2 Heterogêneas
4.2.1 Registro...............................................................................
4.2.2 Lista de Exercícios...............................................................
Módulo 6 - Lógica de Programação
04
05
08
10
11
11
14
15
18
18
19
20
21
24
26
34
42
42
43
46
47
48
51
53
56
58
59
59
61
63
64
67
73
3
Curso de Informática
Capítulo 5
Pag.
Algoritmos Especiais
5.1 Pesquisa em Vetor
5.1.1 Pesquisa Seqüencial Única / Múltipla...................................
5.1.2 Pesquisa Binaria Única / Múltipla.......................................
5.2 Ordenação de Vetor
5.2.1 Método da Seleção ..............................................................
5.2.2 Método da Bolha .................................................................
5.2.3 Método da Inserção .............................................................
81
83
85
Bibliografia ...........................................................................................
Cronograma de Atividades ...................................................................
86
87
Módulo 6 - Lógica de Programação
74
77
4
Curso de Informática
Capítulo 1 - Introdução
1.1 Ciclo de Vida do Software (Sw)
Módulo 6 - Lógica de Programação
Pag.
5
Curso de Informática
Pag.
1.2 Processamento de Dados
Entrada(s)
Processamento
Saída(s)
Entrada(s)
Processamento
Processador
Saída(s)
Exemplo de Processamentos
a.
Roupa Suja
Processo:
Detergente
Roupa Limpa
Lavagem
Água
b.
Sapato Sujo
Escova / Pano
Graxa
Processo Manual
Engraxar Sapatos
Sapatos Limpos
Engraxate
c.
Maca
Leite
Açúcar
Módulo 6 - Lógica de Programação
Processo Automático
Fazer Vitamina
Liquidificador
Vitamina
6
Curso de Informática
Pag.
d.
Dados
Processamento de Dados
Dados Processados
Programa
Computador
e.
Cozinheiro
Ingredientes
Processador
Rotina:
Passo 1
Passo 2
Passo 3
...
Passo n
Receita
Módulo 6 - Lógica de Programação
Bolo
7
Curso de Informática
Pag.
8
Exercícios:
1. Indique algumas possíveis entradas e saídas dos processamentos abaixo:
Cortar Grama
Procurar o número do telefone
de um colega no catálogo
2. Para cada exemplo abaixo identifique o processamento realizado ou informações fornecidas ao
processador:
a
b
a. Relação de Alunos de uma Turma
b. Indicação dos Alunos Presentes e Ausentes
a
c
b
a. Relação dos Candidatos ao Vestibular
b. Média Final de cada Candidato
c. Relação dos Candidatos Classificados para ingressar na Universidade
3. Para cada um dos exercícios acima, indique o agente processador.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
9
Capítulo 2 - Algoritmos Estruturados
2.1 Conceitos
Um programador de computador é, antes de mais nada, um solucionador de problemas. Assim sendo,
ele deve lidar com os mesmos de forma rigorosa e sistemática. A dificuldade de se programar o
computador provém da complexidade inerente a esta atividade combinada com muitos processos
mentais.
Podemos afirmar que a arte de programar está dividida entre duas atividades: uma eminentemente
inteligente, criativa; e outra mais sistemática, mecânica.
É na fase criativa do processo que produzimos um algoritmo (conjunto de instruções, “receita”) que
solucione o problema em questão. Existem, na literatura, vários métodos para descrever algoritmos. Na
fase subsequente, codificamos o algoritmo usando algumas das linguagens de programação existentes
no mercado.
Portanto, algoritmo é uma descrição detalhada e não ambígua, de ações que devem ser realizadas para
a solução de um problema.
É a descrição de um conjunto de comandos que, obedecidos, resultam numa sucessão finita de ações
que resultarão na resolução do problema proposto.
Grande parte dos algoritmos possuem métodos complicados de organizar o dados envolvidos na
computação. Objetos criados para esses fins são chamados “Estrutura de Dados”, que não serão
abordados por fugir ao escopo desta disciplina.
Frequentemente existe mais que um algoritmo para resolver o mesmo problema. A escolha do
melhor algoritmo para um particular problema pode ser um processo muito complicado, geralmente
envolvendo uma análise mais sofisticada. A área da Ciência da Computação na qual estas questões são
estudadas é chamada “Análise de Algoritmos”.
Vamos considerar alguns aspectos de algoritmos e suas relações com o computador:
a) Para todo o problema que se queira resolver usando o computador e que tenha uma solução, existirá
um algoritmo.
b) Todas as tarefas que sabemos que são realizadas num espaço finito de tempo podem ser descritas
por algoritmos que existem executarão estas tarefas no computador em um tempo finito.
c) O tamanho da descrição de um algoritmo não deve ser proporcional ao número de ações executadas
no algoritmo senão, a enorme disparidade entre nossa taxa de criação de algoritmos e a taxa de
execução do algoritmo no computador nos levaria a crer que os computadores não teriam grande
trabalho a fazer. Deveremos escrever algoritmos cujo tamanho de sua descrição seja independente
do número de ações a ser executadas. Existem partes do algoritmo que são executadas muitas vezes
pelo computador.
d) A execução de um algoritmo no computador deve sempre apresentar o mesmo resultado.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
10
Os algoritmos a que nos referimos são aqueles que manipulam símbolos, representados por números,
já que estes são algoritmos que tem execução imediata em computadores digitais.
Dentre as propriedades dos algoritmos, podemos citar:
a) Um algoritmo deve ter um único ponto de “início” e sua execução se faz de passo a passo, até
atingir o ponto de “parada” (fim).
b) Cada passo do algoritmo deve ser simples e objetivo, para que ele possa ser corretamente executado
por uma máquina (o computador) que naquele momento só tem conhecimento sobre os específico
passo.
c) Para garantir que um algoritmo termina, cada passo dever ser executado em um espaço de tempo
finito.
d) Já que partes da descrição do algoritmo vão ser “lidas” e executadas mais de uma vez, um algoritmo
contém no mínimo um ciclo, isto é, certas sequências de passos recorrendo durante a execução do
algoritmo. Como a execução do algoritmo deve terminar em um tempo finito, deve haver uma
maneira para encerrar cada ciclo. Em outras palavras, deve existir, em cada ciclo, um passo que
decida entre continuar o ciclo ou sair dele.
e) Todo o algoritmo deve conter no mínimo uma variável com um domínio de valores. Se um
algoritmo não tem variáveis, ou seja, só tem constantes, só será necessário executá-lo uma única
vez.
Algoritmo para a solução de um problema genérico
Passo 1: Entender completamente a descrição do problema.
Passo 2: Fazer um esboço geral do algoritmo para a solução do problema dado, sem se preocupar com
detalhes específicos. Assegurar que a estratégia esteja correta, rastreando o algoritmo esboçado com
amostra de dados. Se não estiver correta revisá-la.
Passo 3: Identificar e declarar qualquer variável que seja necessária. Por identificação entenda-se o
nome da variável, seu tipo e uma descrição de seu propósito. Esta lista de variáveis pode ser
aumentada ou diminuída segundo a necessidade.
Passo 4: Refinar os passos individuais do algoritmo esboçado. O nível de detalhamento deve ser
aquele onde as instruções descritas nos passos do algoritmo tenham mapeamento quase imediato para a
linguagem de programação.
Passo 5: Sentindo que o algoritmo está detalhado adequadamente, proceda seu rastreamento a fim de
comprovar sua obediência à especificação.
Passo 6: Implementação do algoritmo numa linguagem de programação particular.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
11
2.2 Programação Estruturada
Dentre os diversos leques de atuação da Informática, algumas delas estão voltados para a construção
de sistemas de aplicação. Então, a utilização do computador para estes fins exige que se construa
algoritmos de todos os programas que irão compor determinado sistema. O algoritmo deve, portanto,
prever antecipadamente todas as situações que possam ocorrer quando posto em execução.
Devido a evolução das máquinas, os sistemas desenvolvidos podem ser maiores e de maior
complexidade. Porém, os algoritmos são ainda desenvolvidos pelo ser humano, mas podem ultrapassar
os limites de sua compreensão. Por esta razão, nos últimos anos surgiram técnicas que permitem
sistematizar e ajudar o desenvolvimento de algoritmos para a resolução de grandes e complexos
problemas nos computadores. O conjunto destas técnicas denominamos de desenvolvimento
estruturado ou programação estruturada que é uma ferramenta utilizada para se obter programas
confiáveis, manuteníveis e eficientes e objetiva:
•
•
•
•
•
facilitar a escrita dos programas;
facilitar a leitura dos programas;
permitir a verificação a priori dos programas;
facilitar a manutenção e modificação dos programas e
permitir que o seu desenvolvimento possa ser empreendido simultaneamente por uma equipe de
pessoas.
Logo, estas técnicas preconizam que para se resolver um problema devemos dividi-lo, para podermos
compreende-lo, que podemos faze-lo utilizando:
• desenvolvimento do programa em diferentes fases por refinamento sucessivo;
• decomposição do programa total em módulos funcionais, organizados num sistema hierárquico;
• dentro de cada módulo só um número muito limitado de estruturas básicas de fluxo de controle.
Exercício:
Confeccione um algoritmo para substituir uma lâmpada queimada.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
12
2.3 Constantes
A constante se caracteriza por não se modificar ao longo da execução de um programa.
Pode ser classificada em numérica, literal e lógica.
2.3.1 Constante Numérica
É definida a partir do sistema decimal, podendo ser um número inteiro ou fracionário.
As constantes numéricas podem participar de operações aritméticas.
Exemplos: 25, 3.14, 8.5 x 103, - 2.6, 105
2.3.2 Constante Literal
É definida a partir de uma seqüência qualquer de caracteres (letras, dígitos ou símbolos especiais) com
algum significado para o problema em estudo.
Sempre será colocada entre aspas para não seja confundida com outro item.
Não podem participar de operações aritméticas.
Exemplos: “José da Silva”, “12348”, “MENSAGEM ...:”, “A%B23X-5”
2.3.3 Constante Lógica
É um valor lógico que só pode ser verdadeiro ou falso e são representadas pelas palavras: verdadeiro e
falso.
2.4 Variáveis
A grande parte dos computadores disponíveis comercialmente adota o modelo da Máquina de Von
Neumann, matemático que introduziu o conceito de “programa armazenado”, onde variáveis são
usadas para representar células de memória e atribuições são usadas para simular armazenamento.
Num programa de computador, uma variável é uma entidade que possui um valor, sendo conhecida no
programa por um identificador. As variáveis são valoradas com dados do mesmo tipo.
Uma variável corresponde uma posição de memória (RAM). Seu conteúdo pode variar ao longo do
tempo durante a execução de um programa, ou seja, pode assumir valores diferentes em instantes
diferentes.
A variável é identificada por um nome ou identificador.
Exemplo: Para se realizar o cálculo das raízes de uma equação do 2o grau (ax2 + bx + c = 0), os
identificadores A, B e C podem representar as posições de memória que armazenam os coeficientes da
equação.
RAM
A
B
Módulo 6 - Lógica de Programação
C
Curso de Informática
Pag.
13
2.4.1 Regras para a formação dos nomes ou identificadores
• Pode ser formado por um ou mais caracteres,
• Obrigatoriamente, o primeiro caractere tem que ser um letra,
• É permitido o uso de letras e dígitos e não o de símbolos especiais
Nomes Válidos
AAA
X
NOTAALUNO
NOMEPECA
Nomes Não Válidos
6NOME
RUA-ALUNO
CEP ALUNO
SEXO%EMPREG
Observando os exemplos acima, temos AAA e X como nomes válidos. Entretanto, estes nomes não
são significativos, ou seja, eles não refletem a natureza dos valores que neles serão armazenados. A
utilização de nomes significativos pelo programador torna o algoritmo mais legível.
2.4.2 Declaração de Variáveis
Uma variável só pode armazenar valores de um mesmo tipo. Logo, as variáveis são classificadas em
numéricas, literais ou lógicas.
A declaração é utilizada para indicar o tipo da variável. Alem disso, no momento da declaração é
associado um nome a variável (posição de memória).
Qualquer referência que se faça a variável implica na referência ao seu conteúdo do local da memória
que a representa.
Sintaxe:
declare lista-de-variáveis tipo, onde:
declare
lista-de-variáveis
tipo
Exemplos:
declare NOTA, CÓDIGO, X5 numérico
declare TESTE, SIM
lógico
declare NOME, ENDERECO literal
Módulo 6 - Lógica de Programação
palavra chave do algoritmo
nomes escolhidos para as variáveis, usar vírgulas
palavra chave que indica o tipo das variáveis
Curso de Informática
Pag.
14
2.4.3 Comentários
A clareza é uma das principais características de um algoritmo e o comentário é um dos instrumentos
para cumprir esta finalidade. O comentário pode ser um texto ou uma frase, deve vir delimitado por
chaves e podem ser colocados em qualquer parte do algoritmo.
Exemplo:
declare MAT, {Número da Matrícula do Aluno}
NOTA, {Nota do Aluno em determinado Bimestre}
COD, {Código do Curso do Aluno}
numérico
Exercícios:
a. Identificar o tipo de cada constante abaixo:
Constante
21
“BOLA”
falso
“verdadeiro”
0.21 x 103
“500”
Tipo
b. Assinalar com um “X” os identificadores válidos:
(
(
(
(
(
) VALOR
) X2
) 3x4
) XYZ
) “NOTA”
(
(
(
(
(
)
)
)
)
)
SAL-LIQ
NOTA*ALUNO
MARIA
NOMEDAEMPRESA
AH/
(
(
(
(
(
)
)
)
)
)
B248
A1B2C3
KM/H
SALA215
M(A)
c. Supondo-se que as variáveis NOM, PROF, ID e SAL serão utilizadas para armazenar o nome, a
profissão, a idade e o salário de uma pessoa, escrever o conjunto de declarações necessário para criar
essas variáveis e associá-las aos respectivos tipos básicos.
d. Realizar as declarações necessárias para um algoritmo que calcula as raízes de uma equação do 2o
grau.
e. Realizar as declarações necessárias para os exercícios propostos no tópico Estrutura Sequencial.
Observação:
• A quantidade de variáveis declaradas em um programa, definida pelo programador, depende do
problema a ser resolvido,
• Para facilitar esta definição, o programador deverá ler por varias vezes o enunciado do problema e
a partir dele, tentar identificar quais as variáveis serão de entrada, quais serão de saída e quais serão
intermediárias (aquelas que não são de entrada, nem de saída, mas que são necessárias ao
processamento).
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
15
2.5 Expressão Aritmética
É aquela cujos operadores são aritméticos e os operandos são constantes e/ou variáveis do tipo
numérico.
2.5.1 Operações Básicas
( + ) Adição
( - ) Subtração
( / ) Divisão
( x ) Multiplicação
( √ ) Radiciação
( a ) Exponenciação
Exemplos:
X + Y
2 x NOTA
X - Y
TOTAL / N
√P
SOMA2
AxB+C
√ F1 + G - H
5 + TOT / M
Observações:
• Não omitir o operador de multiplicação,
• A precedência das operações é igual a da Matemática (1. Potenciação/Radiciação, 2. Multiplicação/
Divisão, 3. Adição/Subtração),
• Para alterar a precedência utilizar parênteses e não colchetes e chaves.
2.5.2 Funções
Conforme veremos mais adiante, a maioria das linguagens suporta 2 tipos de funções: a da própria
linguagem e as definidas pelo usuário (programador).
A função numérica atua sobre o(s) argumento(s) que é(são) passado(s) e obrigatoriamente retorna
com um valor numérico. Logo, as funções podem ser utilizadas em expressões aritméticas. As funções
devem ser escritas em letras maiúsculas.
Segue-se relação de algumas funções matemáticas que as linguagens suportam:
FUNÇÃO
LOG (A)
LN (A)
EXP (A)
ABS (A)
TRUNCA (A)
ARREDONDA (A)
SINAL (A)
QUOCIENTE (A, B)
RESTO (A, B)
Módulo 6 - Lógica de Programação
RESULTADO FORNECIDO
Logaritmo na base 10 de A
Logaritmo neperiano de A
O número e elevado a A
Valor Absoluto de A
A parte inteira de A
A parte inteira de A arredondada
-1, +1 ou 0 para A respectivamente negativo, positivo ou nulo
Quociente inteiro de A / B
Resto de A / B
Curso de Informática
Pag.
16
Exemplos:
QUOCIENTE (10, 3) = 3
RESTO (10, 3)
=1
Exercícios:
a. Sendo A, B, X e Y variáveis do tipo numérico, quais os resultados fornecidos por cada uma das
seguintes funções sendo A = 10, B = 3, X = 2.5 e Y = 1.2 ?
a1. SINAL ( X + Y - A)
a2. ARREDONDA (A - X)
a3. TRUNCA (B2 + X)
a4. ABS (A - B3)
a5. EXP (√ A + 2 x B
-B
a6. QUOCIENTE (B + Y, X + 1)
a7. RESTO (B + Y, X + 1)
2.6 Expressões Lógicas
São utilizadas no condicionamento de ações, logo uma condição do algoritmo é representada através
de uma expressão lógica.
Denomina-se expressão lógica aquela cujos operadores são lógicos e cujos operandos são relações e/ou
variáveis do tipo lógico.
2.6.1 Relação
É uma comparação realizada entre dois valores do mesmo tipo básico.
Os operadores relacionais são aqueles que indicam a comparação a ser realizada entre os dois valores e
são:
= (igual a)
# (diferente de)
> (maior que)
O resultado obtido de uma relação é sempre um valor lógico.
Exemplos: A # B
NOME = “ JOAO”
B-4 x A x C < 0
X >= 1
Módulo 6 - Lógica de Programação
< (menor que)
>= (maior igual a)
<= (menor igual a)
Curso de Informática
Pag.
17
2.6.2 Operadores Lógicos
Utilizados para a formação de novas proposições a partir de outras já conhecidas, através dos
conectivos E - para a conjunção, OU - para a disjunção e não - para negação.
Tabela de Conjunção - E
Relação-1
Relação-2
Resultado
V
V
V
F
F
V
F
F
Tabela de Disjunção - OU
Relação-1
Relação-2
Resultado
V
V
V
F
F
V
F
F
Exemplos:
A + B = 0 e C # 1
TESTE ou A x C > B
não TESTE e COR = “AZUL”
Exercícios:
Dadas as variáveis numéricas X, Y, Z e as variáveis literais NOME e COR, definir os resultados
obtidos para as relações a partir dos valores fornecidos aos operandos:
X Y
1 2
4 3
1 1
1 2
Z
5
1
2
1
VARIÁVEIS
COR
“AZUL”
“ROSA”
“BEGE”
“AZUL”
NOME
“PAULO”
“JOSE”
“PEDRO”
“JOSE”
2
X + Y >Z
RELAÇÕES
COR = “AZUL”
NOME # “JOSE”
2.6.3 Prioridade
A prioridade entre todos os operadores conhecidos, visto que podem estar presentes na mesma
expressão lógica:
PRIORIDADE
1
2
3
4
5
Módulo 6 - Lógica de Programação
OPERADOR
ARITMÉTICO
RELACIONAL
NÃO
E
OU
Curso de Informática
Pag.
18
Exercícios:
1. Dadas as variáveis numéricas X, Y e Z contendo os valores 2, 5 e 9 respectivamente; a variável
literal NOME contendo “MARIA” e a variável lógica SIM, contendo o valor falso, informar os
resultados obtidos das expressões abaixo:
a. X + Y > Z e NOME = “MARIA”
b. SIM ou Y >= X
c. não SIM e QUOCIENTE (Z, Y) + 1 = X
d. NOME = “JORGE” e SIM ou X2 < Z + 10
2. Confeccione uma expressão lógica para que cada condição abaixo seja satisfeita:
a. Que a variável numérica X seja positiva.
b. Que a variável numérica NUM seja par.
c. Que a variável numérica Y esteja no intervalo compreendido de 10 a 20 inclusive.
d. Que a variável numérica NUM seja impar.
3. Dados 3 valores X, Y e Z, verificar:
a. se eles podem ser comprimentos dos lados de um triângulo.
Propriedade: O comprimento de cada lado de um triângulo é menor do que a soma dos
comprimentos dos outros dois lados.
b. se é um triângulo equilátero.
c. se é um triângulo escaleno.
d. se é um triângulo isósceles.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
19
Tabela de Verificação:
COMPRIMENTOS
X
Y
Z
1.5
1
1
1,5
2
2
1
1,5
1
2
3
1.5
1
1
2
EQUILÁTERO
ESCALENO
ISÓSCELES
2.7 Expressões Literais
Formada por operadores literais e operandos que são constantes e/ou variáveis literais.
Importantes no estudo de programação, mas variam bastante de linguagem para linguagem.
Exemplo: Concatenação
Suponhamos que a variável A possua o conteúdo “PAPA” e a variável B o conteúdo “GAIO”, logo:
A : B = “PAPAGAIO”
2.8 Comando de Atribuição
Permite que se forneça um valor a uma certa variável, onde o tipo do valor tem que ser compatível
com o tipo da variável.
2.8.1 Formato:
identificador ← expressão, onde:
identificador: É o nome da variável a qual esta sendo atribuído o valor da expressão,
←:
É o símbolo de atribuição,
expressão:
Pode ser aritmética, lógica ou literal de cuja avaliação é obtido o valor a ser atribuído a
variável.
Exemplos:
K ← 1
COR ← “VERDE”
TESTE ← falso
A ← B
MEDIA ← SOMA / N
COD ← N + 1 >= 5
SIM ← X < 0 e Y = 5
TOTAL ← G + Y + T
Módulo 6 - Lógica de Programação
TOT ← TOT + 1
Curso de Informática
Pag.
20
2.9 Comandos de Entrada e Saída
As unidades de entrada e saída são dispositivos que possibilitam a comunicação entre o usuário e o
computador. Por exemplo, através do teclado, o usuário consegue dar entrada ao programa e aos dados
na memória do computador, por sua vez, o computador pode emitir os resultados e outras mensagens
para o usuário através das unidade de saída (monitor de vídeo, impressora, etc).
2.9.1 Formatos:
a. leia lista-de-variáveis, onde:
leia: É uma palavra chave
lista: São os nomes das variáveis, separados por virgulas, nas quais são armazenados os valores
provenientes do dispositivo de entrada.
Exemplo:
leia NOME, NOTA
b. escreva lista-de-variáveis e/ou constantes
escreva: É uma palavra chave
lista : São os nomes das variáveis, cujos conteúdos serão mostrados ao usuário através do meio de
saída ou gravados em disco. Além dos conteúdos das variáveis, o valor de uma constante
pode ser emitido diretamente.
Exemplo:
escreva A, X, 35
escreva “Media da Turma:”, MEDIA
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
21
2.10 Estruturas de Controle
Os computadores digitais são projetados segundo o modelo formulado pelo matemático alemão Von
Neumann. As partes principais da Máquina de Von Neumann são (a) Unidade de Processamento, (b)
Memória e (c) Registradores que estabelecem a comunicação entre (a) e (b).
A memória pode ser vista como um vetor onde cada célula (componente do vetor) é designada por um
endereço (índice). A memória armazena dados e programa.
Normalmente, após executar um comando colocado em um endereço i da memória o comando
seguinte a executar deve ser o de endereço i + 1. Isto corresponde à Estrutura Sequencial de controle
(i.e., os passos são executados sequencialmente, do passo 1 até o último passo do algoritmo).
No entanto, comandos de desvio condicional ou incondicional podem indicar endereço diverso onde
encontrar o comando seguinte.
O caso de desvio condicional é o mais importante pois pode ser usado para implementar outras duas
estruturas: Decisão (a habilidade para selecionar uma ação dentre um conjunto de alternativas
especificadas) e Repetição (a habilidade para repetir uma série de ações).
Foi demonstrado que as três estruturas de controle, ou seja, Sequência, Decisão e Repetição são
suficientes para elaborar algoritmos e, consequentemente programas.
2.10.1 Estrutura Sequencial
Num algoritmo aparecem em primeiro lugar as declarações seguidas por comandos que, se não houver
indicação ao contrário, deverão ser executados numa seqüência linear, seguindo-se o texto em que
estão escritos, de cima para baixo.
Algoritmo
d1
d2
d3
.
.
.
c1
c2
c3
.
.
.
cn
FimAlgoritmo
Texto do Algoritmo
Módulo 6 - Lógica de Programação
C1
C2
C3
Cn
Diagrama de Chapin
Curso de Informática
Pag.
22
Exercícios:
a. Escreva um algoritmo que leia dois números e emita o produto dos mesmos.
b. Escreva um algoritmo que leia três números e emita estes números e a média aritmética dos
mesmos.
c. Confeccione um algoritmo que leia o valor do raio, calcule e imprima a área do círculo, o
comprimento da circunferência e o volume da esfera.
d. Confeccione um algoritmo que leia dois valores como sendo catetos de um triângulo retângulo,
calcule e emita o valor da hipotenusa.
2.10.2 Estrutura Condicional
A estrutura condicional permite a escolha do grupo de ações e estruturas a ser executado quando
determinadas condições, representadas por expressões lógicas, são ou não satisfeitas.
A estrutura é delimitada pelo comando Se e pela expressão FimSe.
A estrutura pode ser representada de três maneiras:
2.10.2.1 Condicional Simples
Se condição
então Seqüência de Comandos
FimSe
Condição
V
Seqüência
Comandos
F
-
Neste caso, não ocorrerá a execução de nenhuma ação se a condição for falsa.
Exercícios:
a. Confeccione um algoritmo para ler A, B, C e emita a soma de A, B e C se o produto de A por B for
maior que C.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
23
2.10.2.2 Condicional Composta
Se condição
então Seqüência A de Comandos
senão Seqüência B de Comandos
FimSe
Condição
V
F
Seqüência A Seqüência B
Comandos
Comandos
Neste caso, a seqüência A de comandos só será executada se a condição (expressão lógica) for
verdadeira e a seqüência B de comandos só será executada se a condição for falsa.
Exercícios:
a. Confeccionar um algoritmo para ler um número e emitir se o mesmo é positivo, negativo ou nulo.
b. Confeccionar um algoritmo para ler um número e emitir se o mesmo é par ou impar.
c. Confeccionar um algoritmo para ler um número e emitir se o mesmo está compreendido no intervalo
de 10 a 20 inclusive.
d. Confeccionar um algoritmo para ler três valores e emitir se os mesmos podem ou não ser os
comprimentos dos lados de um triângulo.
e. Confeccione um algoritmo que leia 3 valores e verifique se eles podem ser os comprimentos dos
lados de um triângulo, se forem, imprimir a classificação do triângulo.
f. Escrever um algoritmo para ler dois valores e imprimir a diferença entre o maior e menor valor.
g. Fazer um algoritmo que leia 3 valores, determine e imprima o maior deles.
h. Confeccionar um algoritmo para ler um número e emitir se o mesmo é par ou ímpar.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
24
2.10.2.3 Condicional Múltipla
Muitas vezes um algoritmo pode conter vários comandos mutuamente exclusivos, isto é, se um ou
mais comandos forem executados os demais não o serão.
Quando este for o caso, uma condicional múltipla é a mais indicada, cuja execução será aquele grupo
de comandos precedido por um valor que seja igual ao valor corrente da variável.
Completada a execução do grupo de comandos selecionado, o controle passa para o final da
condicional múltipla.
Senão houver o “casamento” do valor corrente da variável com nenhum valor explicitado, o grupo de
comandos do senão será executado, se especificado.
Caso Variável de
Valor-1 : Grupo-Comandos-1
Valor-2 : Grupo-Comandos-2
...
Valor-n-1 : Grupo-Comandos-n-1
senão
Grupo-Comandos-n
FimCaso
Exercícios:
1. Confeccione um algoritmo que leia o Código do Estado Civil e escreva a descrição correspondente
ao mesmo conforme tabela abaixo.
Código Estado Civil
“C”
“S”
“D”
“V”
“M”
Descrição
“Casado”
“Solteiro”
“Divorciado”
“Viúvo”
“Marital”
2. Confeccione um algoritmo que simule o funcionamento de uma calculadora, ou seja, emita o
resultado da operação entre dois operandos a partir da leitura dos mesmos e do operador. Considere
que os possíveis operadores são: (+) para adição, (-) para subtração, (x) para multiplicação e (/) para
divisão.
3. Confeccione um algoritmo que leia o mês (numérico) e o ano e emita a quantidade de dias deste
mês/ ano. Considerar anos bissextos.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
25
2.10.3 Estrutura de Repetição
A estrutura de repetição permite a execução de um conjunto de ações repetidamente enquanto uma
determinada condição permanece válida. (Expressão cujo resultado é o valor lógico verdadeiro).
Enquanto condição
Condição
Seqüência de
Comandos
Seqüência
de
Comandos
FimEnquanto
O controle da repetição (do laço) pode ser feita através de um contador ou de flags (marcas).
2.10.3.1 Tipos de Estruturas de Controle de Repetição utilizando Contador
Para
Enquanto
Algoritmo
declare Contador numérico
...
Contador ← valor inicial
...
Enquanto Contador < valor
...
...
Contador ← Contador ± inc
FimEnquanto
...
...
FimAlgoritmo
Algoritmo
Repita
Algoritmo
declare Contador numérico
declare Cont numérico
...
...
...
Cont ← valor inicial
Para Contador = valor inicial ...
até valor final
Repita
passo incremento
...
...
...
...
Cont ← Cont ± inc
...
FimPara
Ate Cont > valor
...
...
...
...
FimAlgoritmo
FimAlgoritmo
Exercícios:
a. Confeccionar um algoritmo para ler cinco números e emitir para cada um deles se o mesmo é
positivo, negativo ou nulo.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
26
2.10.3.2 Controle de Repetição utilizando Flag
Nesta abordagem utiliza-se uma marca com uma característica especial que torna o fim do conjunto de
dados facilmente identificável, ou seja, o valor do flag deverá ser fornecido.
No entanto, será preciso alterar as posições dos comando de leitura, por (1) assegurar-se de que o flag
não seja processado pelos comandos do laço e (2) prever a possibilidade que o flag seja o primeiro a
ser lido, para o caso em que não existam dados no conjunto.
Algoritmo
declare Variável_Flag
declare Variáveis_Conjunto_Dados
...
Leia Variável_Flag
...
Enquanto Variável_Flag diferente Valor_Flag
Leia Variáveis_Conjunto_Dados
...
...
Leia Variável_Flag
FimEnquanto
...
...
FimAlgoritmo
2.10.3.3 Repetição Embutida
São repetições dentro de outras repetições. A amplitude de uma repetição é encaixada na amplitude da
outra repetição. A repetição interna é executada completamente para cada passagem da repetição
externa.
É da responsabilidade do programador garantir que o laço (repetição) termine. Laços que falham em
terminar são extremamente caros e embaraçosos. A frequência desta situação é maior em laços
condicionais (enquanto, repita), pois o mecanismo para os laços automáticos (para) é realizado pela
linguagem.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
27
2.11 Lista de Exercícios
1. Quais valores serão emitidos pelo algoritmo abaixo?
Algoritmo
declare N, QUADRADO numérico
N ← 10
Enquanto N > 1
QUADRADO ← N2
escreva QUADRADO
N←N-1
FimEnquanto
FimAlgoritmo
2. Confeccione um algoritmo que leia 100 números, calcule e imprima a média desses números.
3. Confeccione um algoritmo para determinar e imprimir o maior valor de um conjunto de 10 valores.
4. Confeccione um algoritmo que emita a soma dos números pares de 2 a 100 inclusive.
5. Confeccione um algoritmo que emita os números ímpares de 50 a 80.
7. A conversão de graus Farenheit para centígrados é obtida por C = 5/9 ( F - 32 ). Fazer um
algoritmo que calcule e escreva uma tabela de graus centígrados em função de graus Farenheit, que
variam de 50 a 100 de 1 em 1.
8. Fazer um algoritmo que dado o valor de N, calcule o valor de H = 1 + 1 + 1 + 1 + ... + 1
2 3 4
N
9. Confeccionar um algoritmo para ler um número e informar se o mesmo é primo ou não.
10. Fazer um algoritmo que calcule o N! ( fatorial de N ), sendo que o valor inteiro de N será
informado pelo teclado. Considerar 0! = 1.
11. Confeccione um algoritmo para imprimir a sequëncia de Fibonacci (0, 1, 1, 2, 3, 5, 8, 13, ...) até o
enésimo termo informado. Considerar n >= 2.
12. Fazer um algoritmo para ler n números quaisquer, onde número = -1 indica fim, e imprima a soma
dos números ímpares, a média dos números pares e o produto desses números.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
28
13. Fazer um algoritmo que:
• Leia um conj. de dados contendo cada um a idade e o nome de um indivíduo. O último conjunto
não entrará nos cálculos, contém o valor da idade igual a 0 (zero).
• Calcule e escreva a idade média deste grupo de indivíduos.
14. Tem-se um conjunto de dados contendo a altura e o sexo ( masculino, feminino ) de 50 pessoas.
Fazer um algoritmo que calcule e escreva:
• a maior e menor altura do grupo;
• a média de altura das mulheres;
• o número de homens.
15. Num frigorífico existem 90 bois. Cada boi traz em seu pescoço um cartão contendo seu número de
identificação e seu peso. Fazer um algoritmo que leia estes dados e escreva a identificação e peso
do boi mais gordo e do boi mais magro.
16. Fazer um algoritmo para ler o nome, o sexo e a idade de pessoas, onde o nome = “FIM” indica o
fim, imprimir o nome do homem mais velho e da mulher mais nova.
17. O sistema de avaliação de uma determinada disciplina obedece aos seguintes critérios:
•
•
•
durante o ano letivo são dadas 4 notas;
a nota final é obtida pela média aritmética das notas dadas durante o curso;
é considerado aprovado o aluno que obtiver a nota final superior ou = 60 e que tiver
comparecido a um mínimo de 40 aulas.
Fazer um algoritmo que:
a) Leia um conjunto de dados contendo o nome do aluno, as notas e a freqüência ( nº de aulas
freqüentadas ) de 5 alunos.
b) Calcule: a nota final de cada aluno;
o total de alunos reprovados;
o total de alunos aprovados.
c) Escreva:
• para cada aluno, o nome, a freqüência, a nota final e a mensagem (Aprovado / Reprovado).
• no final do processamento o total de alunos reprovados e aprovados.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
29
18. Existem 3 candidatos a uma vaga no senado. Confeccione um algoritmo que leia um conjunto de
dados contendo o voto de cada eleitor, calcule e imprima:
•
•
•
•
o número do candidato vencedor
o número de votos em branco
o número de votos nulos
o número de eleitores que votaram
O voto de cada eleitor foi codificado da seguinte forma:
1
2
3
voto para os candidatos
0}
4}
voto branco
voto nulo
O último voto não entrará nos cálculos, voto = -1.
19. Foi feita uma pesquisa para determinar o índice de mortalidade infantil em um certo período.
Fazer um algoritmo que:
a) Leia o número de crianças nascidas no período;
b) Leia em seguida, um conjunto de dados, contendo cada um, o sexo de uma criança morta e o
número de meses de vida da criança. A última criança não entrará nos cálculos, (sexo =
branco)
c) Determine e imprima;
c.1. - a porcentagem de crianças mortas no período;
c.2. - a porcentagem de crianças do sexo masculino mortas no período;
c.3. - a porcentagem de crianças que viveram menos de 24 meses.
20. Uma companhia de teatro planeja dar uma série de espetáculos. A direção planeja que a, R$
100,00 o ingresso, serão vendidos 120 ingressos, e as despesas montarão em R$ 500,00.
A uma diminuição de R$ 5,00 no preço do ingresso espera-se que haja um aumento de 20
ingressos vendidos.
Fazer um algoritmo que escreva uma tabela de valores conforme lay-out abaixo, fazendo-se variar
este preço de R$ 100,00 a R$ 10,00 de R$ 5,00 em R$ 5,00.
PREÇO - R$
NÚMERO INGRESSOS
100,00
95,00
90,00
...
10,00
Módulo 6 - Lógica de Programação
120
140
160
...
999
DESPESA - R$
500,00
500,00
500,00
...
500,00
LUCRO - R$
9999999
9999999
9999999
...
9999999
Curso de Informática
Pag.
30
21. Para se determinar o número de lâmpadas necessárias para cada cômodo de uma residência,
existem normas que dão o mínimo de potência de iluminação exigida por metro quadrado ( m2 ),
conforme a utilização deste cômodo. Seja a seguinte tabela tomada como exemplo:
UTILIZAÇÃO
quarto
sala de TV
salas
cozinha
varandas
escritório
banheiro
CLASSE
1
1
2
2
2
3
3
POTÊNCIA/m2
15
15
18
18
18
20
20
Supondo que só serão usadas lâmpadas de 60 W, fazer um algoritmo que:
a) Leia um conjunto de dados contendo cada um:
• cômodo de uma residência;
• classe de iluminação deste cômodo;
• as duas dimensões do cômodo.
b) Calcule e escreva:
b.1) para cada cômodo:
• o cômodo;
• a área do cômodo;
• a potência de iluminação;
• número de lâmpadas necessárias;
b.2) para toda a residência:
• total de lâmpadas;
• total de potência.
c) Considere:
1) Se o número de lâmpadas for fracionário, considerar o menor inteiro que contenha este
número. Ex.: 8,3 → 9; 8,7 → 9.
2) O último conjunto de dados , que não entrará nos cálculos, conterá no lugar do cômodo a
palavra VAZIO.
22. Supondo que a população de um país A seja da ordem de 90 mil habitantes com uma taxa anual de
crescimento de 3% e que a população de um país B seja, aproximadamente, de 200 mil habitantes
com uma taxa de crescimento de 1,5%; fazer um algoritmo que calcule e escreva o número de anos
necessários para que a população do país A ultrapasse ou se iguale à população do país B, mantidas
estas taxas de crescimento.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
31
23. Uma empresa decidiu fazer um levantamento em relação aos candidatos que se apresentaram para
o preenchimento de vagas no seu quadro de funcionários, utilizando processamento eletrônico.
Supondo que você seja o programador encarregado deste levantamento, fazer um algoritmo que:
a) Leia um conjunto de dados contendo, para cada candidato, os seguintes dados:
• número de inscrição ( Flag = 0 )
• nome
• idade (em anos)
• sexo (Masculino / Feminino)
• experiência no serviço (Sim / Não)
b) Calcule:
b.1) o número de candidatos do sexo masculino;
b.2) o número de candidatos do sexo feminino;
b.3) idade média dos homens que já tem experiência no serviço;
b.4) o número de mulheres que tem idade inferior a 35 anos e com experiência no serviço.
c) Escreva:
c.1) o número de inscrição e o nome das mulheres pertencentes ao grupo descrito no item b.4;
c.2) o que foi calculado em cada item acima especificado ( do b.1 ao b.4).
24. Foi feita uma pesquisa de audiência de canal de TV em várias casas de uma certa cidade, num
determinado dia. Para cada casa visitada, foi registrado um conj. de dados contendo o número do
canal ( 4, 5, 7, 12 ) e o número de pessoas que o estavam assistindo naquela casa. Se a televisão
estivesse desligada, nada era perfurado, ou seja, esta casa não entrava na pesquisa.
Fazer um algoritmo que:
• leia estes conjuntos de dados, considerando que o último contém o número do canal igual a 0
(zero);
• calcule a porcentagem de audiência para cada emissora (Total de Assistentes do Canal / Total de
Assistentes x 100);
• escreva o número do canal e sua respectiva porcentagem.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
32
25. Uma universidade deseja fazer um levantamento a respeito de seu concurso vestibular. Para cada
curso, o conjunto de dados:
• o código do curso;
• número de vagas;
• número de candidatos do sexo masculino;
• número de candidatos do sexo feminino.
O último conjunto, para indicar fim de dados, contém o código do curso igual a 0 (zero)
Fazer um algoritmo que:
• calcule e escreva, para cada curso, o número de candidatos por vaga e a porcentagem de
candidatos do sexo feminino ( escreva também o código correspondente do curso );
• determine o maior número de candidatos por vaga e escreva esse número juntamente com o
código do curso correspondente ( supor que não haja empate );
• calcule e escreva o total de candidatos.
26. Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma
determinada cidade. Para isso, foram registrados o seguinte conjunto de dados:
• número do consumidor;’
• quantidade de kWh consumidos durante o mês;
• código do tipo de consumidor ( Residencial, Comercial, Industrial ).
O último conjunto, que não entrará nos cálculos, contém o número do consumidor igual a 0 (zero).
Fazer um algoritmo que:
• leia o preço do kWh
• leia os dados descritos acima;
• calcule:
a) para cada consumidor o total a pagar;
b) o maior consumo verificado;
c) o menor consumo verificado;
d) o total de consumo para cada um dos três tipos de consumidores;
e) a média geral de consumo;
• escreva:
a) para cada consumidor, o seu número e o total a pagar;
b) o que foi calculado nos itens b, c, d ,e acima especificados.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
33
27. A comissão organizadora de um rallye automobilístico decidiu apurar os resultados da competição
através de um processamento eletrônico.
Um dos algoritmos necessários para a classificação das equipes concorrentes, é o que emite uma
listagem geral do desempenho das equipes, atribuindo pontos segundo determinadas normas. O
algoritmo deverá:
a) Ler:
a.1) um conjunto de dados contendo os tempos-padrão para as três fases de competição;
a.2) um conjunto de dados contendo cada um o número de inscrição da equipe e os tempos que
as mesmas despenderam ao cumprir as três diferentes etapas. O último conjunto (flag), que
não entrará nos cálculos, contém o número de inscrição 99999.
b) Calcular:
b.1) os pontos de cada equipe em cada uma das etapas, seguindo o seguinte critério: Seja ∇ o
valor absoluto da diferença entre o tempo padrão (lido no primeiro conjunto) e o tempo
despendido pela equipe em cada etapa:
∇ (Delta)
<3
de 3 a 5
>5
Pontos da Etapa
100
80
70
b.2) o total de pontos de cada equipe nas três etapas;
b.3) a equipe vencedora.
c) Escrever:
c.1) Para cada equipe, o número de inscrição, os pontos obtidos em cada etapa e o total de
pontos obtidos.
c.2) A inscrição da equipe vencedora.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
34
28) Numa certa loja de eletrodomésticos, o comerciário encarregado da seção de televisores recebe,
mensalmente, um salário fixo mais comissão. Essa comissão é calculada em relação ao tipo e ao
número de televisores vendidos por mês, obedecendo à tabela abaixo:
TIPO
A cores
preto e branco
Nº TELEVISORES
VENDIDOS
>= a 10
< que 10
>= a 20
< que 20
COMISSÕES
R$ 10,00 por televisor
R$ 5,00 por televisor
R$ 4,00 por televisor
R$ 2,00 por televisor
Sabe-se, ainda, que ele tem um desconto de 8% sobre seu salário fixo para o INSS. Se o seu salário
total (fixo + comissões - INSS) for maior ou igual a R$ 800,00, ele ainda terá um desconto de 5%,
sobre esse salário total, relativo ao imposto de renda retido na fonte. Sabendo-se que existem 20
empregados nesta seção, leia o número de inscrição, o nome, o valor do salário fixo, o número de
televisores a cores e o número de televisores preto e branco vendidos; calcule e escreva o número
de inscrição de cada empregado, seu salário total e seu salário líquido.
29) Um determinado material radiativo perde metade de sua massa a cada 50 segundos. Confeccione
um algoritmo para ler uma massa inicial, em gramas e determine o tempo necessário para que essa
massa se torne menor que 0,5. Escreva a massa final, e o tempo calculado em horas, minutos e
segundos.
30) Escrever um algoritmo para calcular o saldo final da conta de 50 clientes de um banco, a partir do
saldo inicial a ser informado e dos N movimentos do cliente, contendo o tipo do movimento
(crédito ou débito) e o valor do movimento. Critique o tipo do movimento.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
35
2.12 Algoritmos de Quebras de Controle
Se observamos os tipos de extração de dados (consultas, relatórios) podemos classificá-las em:
a. Relatórios de Detalhes ou de Transações
b. Relatórios de Exceções
c. Relatórios de Resumo
Os relatórios ou consultas de detalhes ou de transações consistem na leitura de um arquivo de
dados onde praticamente são criadas saídas para cada registro de entrada lido, ou seja, as saídas são
individualizadas. Por exemplo, relatório que emitem contracheques, faturas, posição de estoque, dados
básicos de alunos, empregados, etc..
Os relatórios de exceções consistem praticamente quando o usuário necessita não de todos os dados
do arquivo, mas sim de parte dele. Como exemplo podemos citar a relação dos clientes que estão
atrasados com os pagamentos, a relação de alunos de um determinada turma, relação de pecas cuja
quantidade em estoque é inferior a um valor mínimo. Logo, o relatório de exceções é uma listagem de
registros específicos que satisfazem certos critérios.
Relatórios de Resumo, como o nome sugere, resume, não detalha. Geralmente, os resumos, ou totais
podem fornecer ao usuário uma visão mais abrangente do que um relatório de detalhes ou exceções.
Considere o exemplo abaixo:
Um arquivo em disco contem registros de vendas, cada um com três campos de entrada: o número do
departamento do vendedor, o nome do vendedor e o valor das vendas realizadas pelo vendedor,
acumulado na semana. Os registros do arquivo de entrada estão em seqüência, por número de
departamento.
Pode haver vários registros de vendedores para o DEPT 01, DEPT 02, etc. Isto é, pode haver vários
registros com o mesmo numero de departamento, dependendo do número de vendedores dentro de
cada departamento. As saídas podem ser 1) um relatório que contem não só o valor das vendas de cada
vendedor, mas também o valor total das vendas de cada departamento ou 2) um relatório contendo
somente o valor total das vendas de cada departamento. O usuário, no caso, é a melhor pessoa para
definir qual das saídas pretende que seja realizada.
Departamento
01
01
01
02
02
Módulo 6 - Lógica de Programação
Nome do Vendedor
Ze da Silva
Ana da Silva
Rui
Rita
Aida
Valor Vendas Realizadas
500,00
300,00
700,00
400,00
450,00
Curso de Informática
Pag.
Saída 1
RELATÓRIO MENSAL DE SITUAÇÃO
DEPARTAMENTO
9999
9999
VENDEDOR
VALOR
TOTAL
X-------------------------X
X-------------------------X
X-------------------------X
999999999
999999999
999999999
9999999
X-------------------------X
X-------------------------X
X-------------------------X
999999999
999999999
999999999
9999999
TOTAL DE VENDAS REALIZADAS NO MÊS............................................................ 99999999
SOLUÇÃO PARA SAÍDA 1
Módulo 6 - Lógica de Programação
36
Curso de Informática
Pag.
Saída 2
RELATÓRIO MENSAL DE SITUAÇÃO
DEPARTAMENTO
9999
9999
9999
9999
VALOR
999999999
999999999
999999999
999999999
TOTAL DE VENDAS REALIZADAS NO MÊS......................... 9999999999
SOLUÇÃO PARA SAÍDA 2
Módulo 6 - Lógica de Programação
37
Curso de Informática
Pag.
2.12.1 Esquema para solução de Rotinas de Quebras de Controle
Algoritmo
declare
PG
Enquanto não EOF
PQ
Enquanto não EOF e mesmo item de quebra
PR
FimEenquanto
TQ
FimEnquanto
TG
FimAlgoritmo
PG - Preparação para o Geral
PQ - Preparação para Quebra
PR - Processamento do Registro de Dados
Módulo 6 - Lógica de Programação
TQ - Tratamento da Quebra
TG - Tratamento Geral
38
Curso de Informática
Pag.
Exercícios:
1. Confeccionar um algoritmo que:
a. Leia um conjunto de dados (arquivo) ordenado por Número do Armazém, contendo:
Número do Armazém
Número do Item
Quantidade em Estoque
Preço Unitário
b. Emita relatório conforme lay-out abaixo:
RELATÓRIO POSIÇÃO DE ESTOQUE
ARMAZÉM
ITEM
QTD ESTOQUE
PAG. 999
PREÇO UNIT.
VALOR TOTAL
9999
X----X
99999
99999,99
9999999,99
X----X
99999
99999,99
9999999,99
TOTAL DO ARMAZÉM ....................................................999999999,99
9999
X----X
99999
99999,99
9999999,99
X----X
99999
99999,99
9999999,99
TOTAL DO ARMAZÉM .....................................................999999999,99
TOTAL GERAL EM ESTOQUE .........................................................................999999999,99
TOTAL DE ARMAZÉNS....................................................................................................9999
2. Confeccione um algoritmo que:
a. Leia um conjunto de dados ordenado por DEPARTAMENTO, contendo:
Departamento
Nome do Empregado
Salário
Total de Descontos
b. Leia uma taxa de aumento que será utilizada no cálculo de novos salários dos empregados.
c. Emita a FOPAG conforme lay-out abaixo:
Módulo 6 - Lógica de Programação
39
Curso de Informática
Pag.
BEER Cia - FOPAG
DEPTO
NOME
SALÁRIO
NOVO SALÁRIO
DESCONTOS
SALÁRIO LIQUIDO
XXX
X------X
9-------9
9------------9
9-------------9
X------X
9-------9
9------------9
9-------------9
X------X
9-------9
9------------9
9-------------9
TOTAL A PAGAR .....................................................................:
MAIOR SALÁRIO LIQUIDO ........................................................:
9---------------9
9---------------9
9---------------9
9----------------9
9----------------9
XXX
X------X
9-------9
9------------9
9-------------9
X------X
9-------9
9------------9
9-------------9
X------X
9-------9
9------------9
9-------------9
TOTAL A PAGAR .....................................................................:
MAIOR SALÁRIO LIQUIDO ........................................................:
9---------------9
9---------------9
9---------------9
9----------------9
9----------------9
TOTAL GERAL A PAGAR .........................................................................: 9---------------9
TOTAL GERAL DE EMPREGADOS ...........................................................:
9999
3. Confeccionar um algoritmo que:
a. Leia um conjunto de dados ordenado por MÊS, contendo
Mês
Nome do Produto
Quantidade Pedida do produto no mês
Preço Unitário do produto
b. Emita relatório, conforme lay-out abaixo:
PEDIDOS REALIZADOS NO EXERCÍCIO
MÊS
PRODUTO
QTD PEDIDA PR UNITÁRIO
VALOR PEDIDO
XXX
X--------------------------X
9-------9
9------------9
X--------------------------X
9-------9
9------------9
X--------------------------X
9-------9
9------------9
VALOR TOTAL DE PRODUTOS PEDIDOS ................................:
9-------------9
9-------------9
9-------------9
9----------------9
XXX
X--------------------------X
9-------9
9------------9
X--------------------------X
9-------9
9------------9
X--------------------------X
9-------9
9------------9
VALOR TOTAL DE PRODUTOS PEDIDOS ................................:
9-------------9
9-------------9
9-------------9
9----------------9
TOTAL GERAL DE VALORES PEDIDOS .......................................................: 9-----------------9
MÊS COM MAIOR VALOR DE PEDIDO ........................................................: XXX
Módulo 6 - Lógica de Programação
40
Curso de Informática
Pag.
41
4. A Biblioteca da Escola realizou um levantamento do seu acervo referente a livros. Assim sendo,
confeccione um algoritmo que:
a. Leia um conjunto de dados ordenado por TIPO DO LIVRO, contendo:
Tipo do Livro
Título do Livro
Quantidade do Acervo
Quantidade Ideal do Acervo
b. Emita relatório conforme lay-out abaixo:
ETFSE - SETOR: BIBLIOTECA
LEVANTAMENTO DO ACERVO DE LIVROS
TIPO DO LIVRO
TÍTULO DO LIVRO
QTD ACERVO
X--------------X
X-------------------------------------X
9------9
9------9
X-------------------------------------X
9------9
9------9
X-------------------------------------X
9------9
9------9
TOTAL DE TÍTULOS ...................................................:
9------9
LIVRO MAIS PRIORITÁRIO PARA AQUISIÇÃO ......: X------------X
X--------------X
X-------------------------------------X
9------9
9------9
X-------------------------------------X
9------9
9------9
X-------------------------------------X
9------9
9------9
TOTAL DE TÍTULOS ...................................................:
9------9
LIVRO MAIS PRIORITÁRIO PARA AQUISIÇÃO ......: X------------X
TOTAL DE TIPOS DE LIVROS .........................................................................:
QTD IDEAL
9-------9
c. Considere: A não necessidade de aquisição para um determinado tipo de livro, onde a Quantidade do
Acervo for maior ou igual a Quantidade Ideal.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
5. Confeccionar um algoritmo que:
a. Leia um conjunto de dados ordenado por REGIÃO e PARTIDO contendo:
Região
Partido
Nome do Candidato
Total de Votos
b. Emita relatório conforme lay-out abaixo:
ELEIÇÕES 1997
REGIÃO
PARTIDO
CANDIDATO
TOTAL DE VOTOS
X--------------X
X----------------------X
X---------------------X
9------9
X---------------------X
9------9
X---------------------X
9------9
TOTAL DE VOTOS................: 9------9
X----------------------X
X---------------------X
9------9
X---------------------X
9------9
X---------------------X
9------9
TOTAL DE VOTOS...............: 9------9
TOTAL DE VOTOS DA REGIÃO ....................................: 9-------9
X--------------X
X----------------------X
X---------------------X
9------9
X---------------------X
9------9
X---------------------X
9------9
TOTAL DE VOTOS................: 9------9
X----------------------X
X---------------------X
9------9
X---------------------X
9------9
X---------------------X
9------9
TOTAL DE VOTOS...............: 9------9
TOTAL DE VOTOS DA REGIÃO ....................................: 9-------9
TOTAL GERAL DE VOTOS ...................................................................................:
Módulo 6 - Lógica de Programação
9-------9
42
Curso de Informática
Pag.
43
Capítulo 3 - Modularização
3.1 Introdução
Nos fins da década de 60, a frequência de um conjunto de problemas no desenvolvimento de sistemas
de programação levou os países desenvolvidos à chamada “crise do software”.
Os custos da atividade de programação mostravam a cada ano uma clara tendência a se elevar muito
em relação aos custos dos equipamentos. Essa tendência é devida, em grande parte, ao rápido avanço
tecnológico na fabricação dos equipamentos de computação em contrapartida com o lento
desenvolvimento tecnológico que o software tem tido.
A não utilização de uma metodologia para a construção de programas conduz à produção de
programas geralmente cheios de erro e com alto custo de desenvolvimento, que consequentemente
exigem grandes custos para sua correção e manutenção futuras.
A programação estruturada é hoje o resultado de uma série de estudos e propostas de disciplinas e
metodologias para o desenvolvimento de software. Conceitos associados como técnicas de
refinamentos sucessivos e modularização dos programas integram o ferramental para elaboração de
programas visando principalmente, os aspectos de confiabilidade, manutenibilidade e flexibilidade.
Dijkstra, sem dúvida um dos principais introdutores da programação estruturada, afirma que “a arte de
programar consiste na arte de organizar e dominar a complexidade dos sistemas”. Esta complexidade
definida pelo número de componentes de um sistema e grau de interação entre eles. Pode-se reunir as
idéias da programação estruturada em três grupos:
• desenvolvimento de algoritmos por fases ou refinamentos sucessivos;
• uso de um número muito limitado de estruturas de controle;
• decomposição do algoritmo total em módulos.
O desenvolvimento de algoritmos por refinamentos sucessivos e o uso de número limitado de
estruturas de controle são técnicas usadas largamente para obter algoritmos de boa qualidade.
Abordaremos os aspectos de decomposição de algoritmos em módulos como recurso para dominar a
complexidade e organizar o processo de programação.
3.2 Conceito de Modularização
A técnica dos refinamentos sucessivos possibilita ao programador nas etapas iniciais do
desenvolvimento, certas abstrações sobre os processos a serem descritos no algoritmo. Estas abstrações
são definidas apenas pelo seu efeito e constituem uma definição funcional do processo. Nas etapas
posteriores, cada descrição funcional é substituída por trechos mais detalhados e que especificam as
etapas do processo.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
44
Quando no processo de desenvolvimento do algoritmo por refinamento, que se constitui na fase de
projeto do programa, faz-se a opção pela divisão do algoritmo; este procedimento conduz à
modularização da solução do problema.
Um módulo é então um grupo de comandos, constituindo um trecho de algoritmo, com uma função
bem definida. Dijkstra, analisando as limitações humanas na tarefa de elaboração de algoritmos mais
complexos, propõe a modularização como uma regra áurea da programação: dividir para reinar.
Esta divisão da atividade de programação permite que a cada instante toda a atenção do programador
esteja concentrada na solução de cada problema específico e bem definido. Da mesma forma, pode-se
verificar a correção do algoritmo por etapas analisando-se a correção de cada módulo.
Resumindo, a programação modular é uma técnica de programação que tem por objetivo simplificar o
desenvolvimento de programas através de sua divisão em “partes”.
Cada uma dessas “partes” pode ser mais facilmente entendida, programada, testada e modificada, pois
o problema que está sendo resolvido é menor.
A decisão pela divisão do algoritmo em módulos traz benefícios como:
• reutilização de código;
• a elaboração do módulo pode ser feita independentemente e em época diferente do restante do
algoritmo;
• testes e correção dos módulos podem ser feitos em separado.
Até agora temos desenvolvido programas que englobam a lógica completa do algoritmo para a solução
de um determinado problema.
Exemplo
Existem 3 candidatos a uma vaga no senado. Confeccione um algoritmo que leia um conjunto de
dados contendo o voto de cada eleitor, calcule e imprima:
•
•
•
•
o número do candidato vencedor
o número de votos em branco
o número de votos nulos
o número de eleitores que votaram
O voto de cada eleitor foi codificado da seguinte forma:
1
2
3
voto para os candidatos
0}
4}
voto branco
voto nulo
O último voto não entrará nos cálculos, voto = -1.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
45
Etapa-1 - Decomposição
Algoritmo
Declare Variáveis
Inicialize Variáveis Trabalho
Apure Votos
Determine Candidato Vencedor
Emita Resultados
FimAlgoritmo
Ao se elaborar tal refinamento (decomposição), não houve preocupação de como o processo de
apuração de votos seria efetuado e sim o que deve ser feito para realizar tal processo.
Essas ações constituem funções bem definidas no algoritmo e que serão executadas por módulos
específicos.
O ponto básico para programação modular é a abordagem de resolução de problemas através de sua
decomposição. Esta abordagem possibilita a obtenção de bons resultados através de algumas
premissas:
•
Política de “Dividir para conquistar”.
•
Com a divisão do problema original em vários subprogramas menores, a solução do problema é
conseguida através da combinação das soluções dos subprogramas.
•
Como cada subprograma é menor que o problema original, a solução destes problemas menores
também é mais simples.
•
A cada unidade resultante da decomposição de um algoritmo chama-se Refinamento ou Módulo.
•
Um problema deve ser subdividido até o ponto em que, se fizermos uma nova subdivisão, cada
módulo tenha que ser descrito através de comandos elementares, e não mais por chamadas a outros
módulos.
A versão final modularizada do algoritmo ficaria então constituída do algoritmo
abaixo mais os módulos refinados:
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
Etapa-2 – Especificação dos módulos
Ref. Declare Variáveis
Declare VOTO, VENC, BRANCO, NULO,ELEIT numérico
Declare VCAND1, VCAND2, VCAND3
numérico
End-Ref.
Ref. Inicialize Variáveis
BRANCO ← 0
NULO
← 0
ELEIT
← 0
VCAND1 ← 0
VCAND2 ← 0
VCAND3 ← 0
End-Ref.
Ref. Apure Votos
Leia VOTO
Enquanto VOTO # -1
Caso VOTO de
0 : BRANCO
1 : VCAND1
2 : VCAND2
3 : VCAND3
4 : NULO
EndCaso
ELEIT ← ELEIT
Leia VOTO
FimEnquanto
End-Ref.
←
←
←
←
←
BRANCO + 1
VCAND1 + 1
VCAND2 + 1
VCAND3 + 1
NULO + 1
+ 1
Ref. Determine Candidato Vencedor
Se VCAND1 > VCAND2 e VCAND1 > VCAND3
então VENC ← 1
senão Se VCAND2 > VCAND3
então VENC ← 2
senão VENC ← 3
FimSe
FimSe
End-Ref.
Ref. Emita Resultados
Escreva VENC, BRANCO, NULO, ELEI
End-Ref.
Módulo 6 - Lógica de Programação
46
Curso de Informática
Pag.
47
Podemos observar acima que um módulo é uma “parte” de um algoritmo com uma única função
perfeitamente definida à qual pode ser atribuído um nome que a descreva.
Uma notação para a descrição estrutural da modularização de problemas é o diagrama hierárquico.
Apresenta-se a seguir o diagrama do problema:
Módulo
Principal
Inicialize Variáveis Trabalho
Apure
Votos
Determine
Cand. Vencedor
Emita
Resultados
3.2.1 Visões de um Módulo
Visão
Externa
Interna
Atributo
Nome
Entrada
Saída
Função
Lógica
Dados Internos
Descrição
Identificação pela qual o módulo pode ser referenciado.
Parâmetros que são passados do chamador para o módulo.
Parâmetros que são passados do módulo para o chamador.
O que faz com a Entrada para se produzir a Saída.
A codificação de comandos para realizar sua função
Seu espaço de trabalho, dados pelos quais somente o
módulo faz referências. (objetos locais)
A maneira mais intuitiva de proceder a modularização de problemas é feita definindo-se um módulo
principal de controle e módulos específicos para as funções do algoritmo. No diagrama anterior, o
módulo principal tem a função de controlar a ativação (chamada) aos outros módulos.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
48
3.3 Ferramentas para Modularização
Em termos funcionais, existem dois tipos de módulos:
3.3.1 Procedimento ou Rotina
Módulo que, a partir de dados de entrada, executa uma tarefa e gera informações de saída. A chamada
a um procedimento é feita através da indicação do seu nome. No exemplo acima, todos os módulos são
do tipo procedimento.
3.3.2 Função
Módulo que, a partir de dados de entrada, executa uma tarefa e gera apenas uma informação de saída.
A informação de saída é atribuída ao nome da função e devolvida pela função na própria posição em
que foi chamada. Toda função possui um tipo associado, que é o tipo de informação que a função
retorna. Logo, a chamada a uma função deve estar em uma expressão (lógica, numérica ou literal).
Exemplo de Função
Algoritmo
{ Calcula Y = X / N! }
Declare X, Y, N numérico
Leia Y, N
Y ← X / FATORIAL (N)
Escreva Y
FimAlgoritmo
Função FATORIAL (NUMERO) : numérico
declare FAT, CONT numérico
FAT ← 1
Para CONT = 2 até NUMERO passo 1
FAT ← FAT x CONT
FimPara
FATORIAL ← FAT
FimFunção
Módulo 6 - Lógica de Programação
Ativação da Função
Tipo do valor a ser retornado pela função
Retorno do valor através do nome da função
Curso de Informática
Pag.
49
3.4 Regras de Escopo e os Aspectos de Conflito de Identificadores
Um outro aspecto importante que envolve a modularização, em particular a modularização de dados, é
a possibilidade de cada módulo poder definir as suas estruturas de dados próprias, suficientes e
necessárias apenas para atingir o objetivo final do módulo. Este aspecto disciplina e impõe restrições à
utilização das estruturas de dados do algoritmo. Toda a comunicação entre módulos deverá ser bem
definida através de vínculos entre os mesmos.
As linguagens de programação hoje existentes dispõem de recursos que facilitam a construção e
manipulação de módulos. Estes recursos permitem não só a modularização dos comandos do programa
como também a modularização dos dados utilizados.
O algoritmo apresentado a seguir mostra o aspecto do escopo ou validade das variáveis considerando o
bloco existente.
Exemplo:
Algoritmo
declare I,J numérico
leia I, J
bloco
declare I,X numérico
I ← 2xJ+1
X ← J+I
escreva X
fimbloco
I ← JxI
escreva I
FimAlgoritmo
Com referência ao algoritmo acima, pode-se observar que:
⇒ Existem duas variáveis I no algoritmo. A primeira, declarada no início do algoritmo, em sua
validade antes e após o bloco. Isto se deve ao fato da existência de uma segunda variável declarada
no bloco que tem a sua validade apenas dentro do bloco, como indicado por I. Qualquer referência a
I dentro do bloco será feita à variável nele declarada que é criada quando do seu início e se destroe
no seu fim. As demais referências são feitas a variável I declarada no início do algoritmo.
⇒ A variável J tem validade em todo o algoritmo, inclusive dentro do bloco, por ser externa a ele.
⇒ A variável X só tem validade dentro do bloco.
O uso de blocos e objetos locais se constitui em uma ferramenta muito útil para a modularização de
algoritmos. O bloco é, pois, um módulo do algoritmo que possui comandos próprios e objetos
próprios. Sendo assim, qualquer objeto utilizado apenas no escopo de um bloco não precisa ser
conhecido em todo algoritmo, como foi mostrado em exemplo anterior, onde a variável AUXILIAR só
é declarada no bloco de valores.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
50
A utilização de objetos locais, sempre que possível, e, consequentemente, a redução da utilização de
objetos globais é uma técnica muito útil quando se trabalha com algoritmos de maior porte e onde o
controle do uso de objetos como, por exemplo, variáveis, torna-se efetivamente complexo.
Abordando o aspecto dinâmico do algoritmo, a modularização em blocos pode, dependendo do
equipamento utilizado, facilitar a segmentação dos programas quando em execução.
Deve-se ter cuidado, no entanto, com o acréscimo de trabalho computacional quando, por exemplo, se
utilizar blocos dentro de estruturas de repetição.
O conflito de identificadores pode ocorrer em algoritmos quando objetos são definidos em níveis
diferentes (por exemplo, no algoritmo propriamente dito e em um bloco) utilizando o mesmo
identificador. Estes casos são resolvidos utilizando-se a regra básica de que a referência é
primeiramente feita às declarações do mesmo nível. Sendo assim, o objeto efetivamente utilizado na
referência será o que estiver no nível mais interno em relação a referência.
Um método bastante simples para se analisar o escopo de identificadores é traçar um modelo gráfico
do algoritmo e dos blocos nele contido.
r3
I
J
r2
r4
leia I
I←IxI
leia J
bloco
I← J x I
escreva I
r1
I
X
I ← 2 x J +1
X←J+1
A
B
No esquema acima, o contorno mais interno corresponde ao bloco e o mais externo, ao algoritmo
propriamente dito. Os quadros no canto superior esquerdo contem a legenda descritiva dos
identificadores declarados no respectivo contorno. Pode-se voltar agora às observações feitas
anteriormente com relação a este algoritmo. Veja-se:
1. Nota-se claramente a dupla existência do identificador I, no entanto, como pode-se ver, são
memórias diferentes e existentes em domínios diferentes, apenas possuem uma identificação única. As
referências a I de dentro do bloco A (r1) são feitas na legenda de A e as referências (r2) no contorno B
são feitas na legenda B.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
51
2. Todas as referências (r3) e (r4) ao identificador J, mesmo dentro do bloco A, são feitas à legenda de
B, pois não existe J na legenda do bloco.
3. A variável X só pode ser usada dentro do bloco A onde existe. Qualquer referência a X fora do
mesmo é ilegal, pois a mesma não existe na legenda mais externa.
3.4.1 A Utilização de Objetos Locais e Globais em Procedimentos/Funções
As regras de espaços e para tratamento de conflito de identificadores apresentadas anteriormente são
válidas tanto para os blocos como para os mesmos aspectos nos procedimentos. Cada procedimento,
para efeito da análise de escopo e conflito de identificadores, é como se fosse um bloco localizado no
nível em que está declarado.
Sendo assim, uma função ou um procedimento utiliza objetos locais declarados no seu corpo ou pode
também utilizar objetos globais declarados em níveis mais externos. As variáveis globais se utilizadas
dentro dos procedimentos é uma das formas de transmissão de informações de fora para dentro e de
dentro para fora dos procedimentos. O uso de variáveis declaradas globalmente provoca a inserção de
dados ao procedimento. Da mesma forma, as modificações feitas em variáveis globais dentro do
procedimento é a forma de transmitir ao nível mais externo, em geral o módulo principal algum valor
determinado dentro da mesma. É de se notar que as variáveis locais apenas existem quando da
execução do procedimento, ou seja, são criadas no início da sua execução e são destruídas ao final.
Apesar da possibilidade de uso de objetos globais, os procedimentos devem ser construídos de forma a
reduzir ao máximo esta utilização. Poder-se-ia dizer, em outras palavras, que a modularização dos
programas deve minimizar a referência feita às variáveis globais em um algoritmo. Este procedimento
torna os algoritmos mais estruturados e organizados do ponto de vista de objetos utilizados, o que
facilita, sem dúvida, a sua compreensão.
O algoritmo abaixo exemplifica o uso de objetos locais e globais em procedimento. Neste algoritmo, X
é uma variável local ao procedimento e não tem sentido fora do mesmo. No entanto, as variáveis A,B e
C são globais ao mesmo procedimento e existem durante toda a execução do algoritmo principal (são
locais ao algoritmo principal). O procedimento EXEMPLO utiliza todas as variáveis X,A,C, a primeira
local a ele e as demais locais ao algoritmo e globais ao mesmo procedimento.
Algoritmo
declare A,B,C numérico
leiaA,B,C
EXEMPLO
escreva A,B,C
FimAlgoritmo
Procedimento EXEMPLO
declare X numérico
X← A
se B = 0
então B← X
senão B← A + C
fim-se
Fimprocedimento
Deve ser observado que a referência feita a objetos globais dentro de um procedimento constitui a
maneira mais intuitiva de transferência de informações para dentro de um procedimento e da mesma
forma para transferência de resultados para os níveis mais externos. No exemplo, a utilização de A e C
dentro do procedimento importa valores do bloco mais externo e a atribuição de valores a B provoca a
transferência de valores calculados para fora do procedimento.
Módulo 6 - Lógica de Programação
Curso de Informática
Módulo 6 - Lógica de Programação
Pag.
52
Curso de Informática
Pag.
53
3.5 Comunicação entre módulos
A transferência de informações de e para módulos utilizando-se de variáveis globais não constitui
uma boa disciplina de programação. Estas transferências precisam ser mais formalizadas e
documentadas, a bem da legibilidade, documentação e organização do algoritmo elaborado.
A utilização de parâmetros de transferência se constitui em um método mais adequado e que atende a
critérios anteriormente expostos. Além disso, permite que um mesmo procedimento possa ser utilizado
com operandos diferentes, dependendo da função que se deseja do mesmo.
Parâmetros são dados de entrada para os procedimentos e funções ou dados de saída para os
procedimentos. Existem dois tipos de parâmetros:
3.5.1 Atual ou Real
É aquele que, na chamada ao módulo, está na lista de parâmetros. Geralmente, este parâmetro é uma
variável que envia e/ou recebe dados do módulo
Ele também pode ser uma constante ou uma expressão.
a. procedimento NOME (lista de parâmetros atuais)
b. função NOME (lista de parâmetros atuais)
3.5.2 Formal
É aquele que na especificação do módulo, está na lista de parâmetros. Ele tem a função de receber e/ou
enviar valor ao parâmetro atual correspondente.
A declaração de módulos que utilizam parâmetros é feita como se segue:
a. Ref. NOME (lista de parâmetros formais)
....
....
FimRef.
b. Ref NOME (lista de parâmetros formais) tipo
FimRef.
É obrigatório que exista uma “correspondência posicional” entre a lista de parâmetros formais e a lista
de parâmetros atuais, ou seja, o primeiro parâmetro formal é associado ao primeiro parâmetro atual, e
assim por diante.
onde:
procedimento/função são palavras chaves;
tipo
é o tipo do resultado da função
lista de parâmetros
é a lista de objetos globais que serão utilizados dentro do procedimento e que
têm seus valores passados do algoritmo ou procedimento chamador para este
procedimento.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
54
NOME (Atual_1, Atual_2, Atual_3)
Ref. NOME (Formal_1, Formal_2, Formal_3)
....
....
FimRef.
Existem basicamente duas formas de passagem de parâmetros:
3.5.3
Por Valor
O conteúdo do parâmetro atual é passado para o seu correspondente formal, mas só permitindo a
leitura do mesmo, ou seja, o valor do parâmetro pode ser utilizado dentro do módulo, mas o módulo
não conseguirá alterar seu valor. Também chamado de parâmetro de entrada.
3.5.4
Por Referência
O endereço do parâmetro atual é passado para o módulo. Permite tanto a leitura quanto a alteração do
seu conteúdo através do parâmetro formal correspondente. Também chamado de parâmetro de entrada
e saída.
Módulo 6 - Lógica de Programação
Curso de Informática
Exemplos:
1. Procedimentos :
Algorítmo
Declare MENS literal
MENS <= “TESTE”
Emita_Linha
Escreva MENS
Emita_Linha
FimAlgorítmo
Ref. Emita_Linha
Declare COLUNA numérico
COLUNA <= 1
Enquanto COLUNA =< 80
Escreva “ - ”
COLUNA <= COLUNA + 1
FimEnquanto
FimRef.
Módulo 6 - Lógica de Programação
Pag.
55
Curso de Informática
2. Procedimentos com passagem de parâmetros
Algorítmo
Declare X , Y numérico
Soma_Num ( 4 , 5 )
X <= 10
Y <= 20
Soma_Num (X , Y)
FimAlgorítmo
Ref. Soma_Num ( NUM1 , NUM2 )
Declare SOMA numérico
SOMA <= NUM1 + NUM2
Escreva SOMA
FimRef.
3. Procedimentos com passagem de parâmetros de volta
Algorítmo
Declare X numérico
Soma_Num ( 4, 5, X)
Escreva X
FimAlgorítmo
Ref. Soma_Num ( NUM1, NUM2, RESUL )
RESUL <= NUM1 + NUM2
FimRef.
Módulo 6 - Lógica de Programação
Pag.
56
Curso de Informática
Pag.
4. Funções
Algorítmo
Declare X, Y numérico
X <= Soma_Num (10, 20)
Y <= Soma_Num (40 , 50)
Escreva X , Y
Escreva Soma_Num (X , Y)
FimAlgorítmo
Ref. Soma_Num ( NUM1, NUM2 ) numérico
Soma_Num <= NUM1 + NUM2
FimRef.
Módulo 6 - Lógica de Programação
produz ____ e ____
57
Curso de Informática
Pag.
58
3.6 Recursividade
Recursividade é um conceito fundamental em matemática e em computação. São comuns em
matemática, as definições recursivas de funções (ditas equações de recorrência). Em computação, um
procedimento recursivo é aquele que possui uma chamada a si próprio como subprograma.
Como veremos a seguir, aspectos não prático de recursão são ressaltados na implementação de
algumas funções matemáticas, definidas por equações de recorrência através de programas
recursivos simples. Entretanto, a utilização de recursão se revela como uma ferramenta muito prática
em projeto de algoritmos.
Como dissemos, um procedimento recursivo é aquele que possui uma chamada a si próprio. Contudo,
estas chamadas recursivas não podem ser feitas infinitamente, pois neste caso a execução de tal
procedimento nunca irá terminar, caracterizando uma circularidade na definição da função
implementada. Portanto, tanto a existência de um ponto (ou condição de parada), quando a
possibilidade deste ponto ser alcançado (ou da condição ser satisfeita) são características essenciais
numa definição recursiva de uma função e, consequentemente, no procedimento que a implementa.
As considerações feitas acima são facilmente exemplificadas pela função fatorial:
n! = 1
se n = 0
n! = n * (n-1) * (n-2) *....* 1 se n >0
Observe que,
3! = 3*2*1
4! = 4*3*2*1 = 4 * 3!
Logo, temos a seguinte equação de recorrência para a função fatorial:
n! = 1
se n = 0
n! = n * (n-1) se n > 0
É importante notar que 0 é um ponto de parada da definição recursiva e ele pode ser alcançado, visto
que a aplicação (chamada) recursiva da função é sempre feita a um elemento menor que o inicial.
A seguir apresentaremos implementações de uma função recursiva e uma iterativa para o cálculo do
fatorial.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
59
Exemplo 1:
Function Fatorial_R (n : integer) : real;
begin
if n = 0
then fatorial_R := 1
else fatorial_R := n * fatorial_R (n-1);
end;
{recursivo}
Function Fatorial_I (n : integer) : real ;
var i : integer ;
f : real;
begin
f := 1;
for i := 2 to n do
f := f * i;
fatorial_I := f;
end;
{iterativo}
Ao simular a execução da função recursiva para uma entrada n=5, por exemplo, observa-se que o
término do processo, que determina o valor de 5!, depende do término do processo que determina 4!,
e assim por diante. Logo, cada processo fica “congelado” até que a execução da sua chamada
recursiva seja concluída. Esta seqüência de chamadas recursivas incompletas formam uma pilha.
5!=5*4!
4!=4*3!
5!=5*4!
3!=3*2!
4!=4*3!
5!=5*4!
2!=2*1!
3!=3*2!
4!=4*3!
5!=4*4!
1!=1*0!
2!=2*1!
3!=3*2!
4!=4*3!
5!=5*4!
0!
1!=1*0!
2!=2*1!
3!=3*2!
4!=4*3!
5!=5*4!
de tal modo que a medida que uma chamada é concluída o seu contexto é retirado da pilha.
O! = 1
1!=1*0!
2!=2*1!
3!=3*2!
4!=4*3!
5!=5*4!
1!=1
2!=2*1!
3!=3*2!
4!=4*3!
5!=5*4!
Módulo 6 - Lógica de Programação
2!=2
3!=3*2!
4!=4*3!
5!=4*4!
3!= 6
4!=4*3!
5!=5*4!
4! = 24
5! = 5*4!
5! = 120
Curso de Informática
Pag.
3.7 Exercícios
Utilizando as técnicas de refinamentos sucessivos confeccione o algoritmo para os exercícios:
1. Número 2 da Lista de Exercícios. Realize o refinamento usando procedimento e depois função.
2. Número 4.
3. Número 14
4. Número 17
5. Número 26
6. Número 27
Módulo 6 - Lógica de Programação
60
Curso de Informática
Pag.
61
Capítulo 4 - Variáveis Compostas
4.1 Homogêneas
Nem sempre os tipos básicos de dados (literal, numérico e lógico) são suficientes para exprimir
estruturas de dados em algoritmos. Por exemplo, considere o seguinte enunciado:
Confeccione um algoritmo que leia as notas de 5 alunos e imprima a nota e a média das notas dos
alunos.
Para resolvermos o problema deveríamos utilizar 5 variáveis numéricas para armazenar as notas da
turma e a partir destas calcular a média. Imagine que o número de alunos da turma seja 80. Só a
declaração destas variáveis tornaria impraticável a redação do algoritmo. Daí a necessidade de novos
tipos de dados serem criados, que seriam as variáveis denominadas compostas.
4.1.1 Definição
São estruturas de dados homogêneas, que se caracterizam por possuírem elementos do mesmo tipo,
também denominadas de arrays.
Os arrays são classificados em unidimensionais e multidimensionais, dependendo da quantidade de
índices que são necessários para a referência a um determinado elemento..
Os arrays unidimensionais são denominados de vetores e os bidimensionais de matrizes.
4.1.2 Vetor
4.12.1 Definição
Constitui um agrupamento de dados homogêneo armazenados sequencialmente com tamanho
definido em tempo.
Ex-1: Vetor de inteiros de 8 posições (elementos)
0
9
-1
2
5
87
4
3
Ex-2: Vetor de string de 4 posições (elementos)
‘casa’
‘carro’
‘fax’
‘iate’
Ex-3: Vetor de real de 6 posições (elementos)
0.51
9.67
Módulo 6 - Lógica de Programação
0.0
3.0
39.7
53.5
Curso de Informática
Pag.
62
4.1.2.2 Acesso
Os elementos de um vetor são acessados (referenciados) através de um índice ou subscrito, que
indica a posição que o elemento ocupa no vetor.
Cada elemento de um vetor é tratado como se fosse uma variável simples
Ex: Seja o vetor VET:
0
1
9
-1
2
5
87
2
3
4
5
6
4
3
7
8
4
3
7
8
⇐ índice ou subscrito
logo,
VET [4] = 2
VET [7] = 4
Ex: Seja o vetor LUGAR:
0
1
9
-1
2
5
87
2
3
4
5
6
⇐ índice ou subscrito
logo,
LUGAR [ 1] = 0
LUGAR [ 3] = -1
4.1.2.3 Declaração Algoritmica
Declare nome-vetor VETOR [ li .. ls] : tipo-básico
onde:
li = limite inferior
ls = limite superior
Observação:
1. li e ls devem ser inteiros
2. O tamanho do vetor (quantidade de elementos) é calculado por ls - li + 1 .
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
63
4.1.3 Exercícios
1. Confeccione um algoritmo que leia 10 números e colocá-los num vetor para depois imprimí-los.
2. Confeccione um algoritmo para ler um conjunto de 10 números e colocá-os num vetor para depois
imprimir o menor deles.
3. Confeccionar um algoritmo para gerar 10 números aleatórios compreendidos entre 0 e 100 e
informar quantos estão acima de 50.
4. Confeccionar um algoritmo que leia uma sequência de 10 números, calcule a média aritmética deste
conjunto e imprima a quantidade de elementos que ficam abaixo da média e a quantidade acima.
5. Confeccionar um algoritmo para gerar um vetor de 20 números aleatórios e emitir quantos
elementos possuem o seu valor menor que seu índice.
6. Confeccionar um algoritmo para gerar 2 vetores (de 10 posições cada) de números aleatórios
variando de 0 a 100, e a partir destes vetores construir um terceiro vetor formado pelos maiores
elementos de cada posição correspondente e emita estes vetores.
7. Confeccione um algoritmo para gerar 10 números aleatórios compreendidos entre 0 e 50 e, a seguir,
imprima esses números, depois de feita a troca do primeiro elemento com o segundo, do terceiro
com o quarto e, assim, sucessivamente.
8. Confeccione um algoritmo para gerar um vetor com 5 elementos de números aleatórios
compreendidos de 0 a 10. E, utilizando função, calcule e imprima o fatorial do valor de cada
elemento.
9. Confeccione um algoritmo para gerar um vetor com 5 elementos de números aleatórios
compreendidos de 0 a 100. E, utilizando função, determine e calcule quantos desses números são
primos.
10.Confeccione um algoritmo para gerar 10 números aleatórios compreendidos entre 0 e 50 e, a seguir,
imprima esses números, depois de feita a troca do primeiro elemento com o último, do segundo com
o penúltimo e, assim, sucessivamente.
11.Confeccione um algoritmo para gerar 10 números aleatórios compreendidos entre 0 e 50 e, a seguir,
imprima esses números e depois gerar dois vetores, um, contendo os valores pares e o outro, os
valores ímpares.
12.Confeccione um algoritmo para gerar 2 vetores com 10 números aleatórios compreendidos entre 0 e
50 cada. A seguir, imprima esses vetores e a soma dos produtos de seus elementos de mesmo
índice.
13.Confeccione um algoritmo para ler dois vetores A e B, cujos elementos estão em ordem crescente.
A seguir, formar o vetor C, intercalando os elementos de A e B, de modo que os elementos de C
fiquem, também, em ordem crescente, sem repetição. Exemplo:
Módulo 6 - Lógica de Programação
Curso de Informática
VETOR
A
B
C
Pag.
2
1
1
3
3
2
4
5
3
ELEMENTOS
6
7
6
8
4
5
6
7
64
8
14. Um professor de certa disciplina aplica, durante um semestre, quatro provas numa turma de 5
alunos. Escrever um programa que leia para cada aluno (no formato de tabela) seu número de
matrícula, nome e as quatro notas. E, a seguir, imprima o relatório conforme lay-out abaixo,
considerando como aprovado o aluno que obtiver média maior ou igual a 6,0:
APLICAÇÃO FINAL DA DISCIPLINA X----------------------------------------X
MATRIC
NOME
NOTA-1
NOTA-2
NOTA-3
NOTA-4
MEDIA
9999
9999
9999
9999
9999
X-----------X
X-----------X
X-----------X
X-----------X
X-----------X
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
99.9
RESUMO DA DISCIPLINA
NÚMERO DE ALUNOS APROVADOS
NÚMERO DE ALUNOS REPROVADOS
MÉDIA GLOBAL DA TURMA
QTD DE ALUNOS COM MÉDIA ACIMA DA GLOBAL
99
99
99.9
99
15.Confeccione um algoritmo para gerar 6 vetores de 5 elementos cada com números compreendidos
entre 0 a 100. A seguir, determinar (através de procedimento) e escrever o menor valor de cada
vetor e o menor valor dos números gerados. Imprimir, também, cada vetor gerado na forma de
tabela através de procedimento.
16.Confeccione um algoritmo para ler dois vetores, ambos em ordem crescente de seus valores, o
primeiro, com N elementos e o segundo com M elementos. A seguir, determinar e imprimir o vetor
união e o vetor interseção.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
65
4.1.4 Matrizes
4.1.4.1 Definição / Acesso
Como os vetores, as matrizes são agrupamentos de dados homogêneos mas que para serem acessadas
(referenciadas) necessitam de 2 (dois) índices, o primeiro designando a linha, e o segundo a coluna,
que indicam a posição que o elemento ocupa na mesma.
Exemplo: Seja a matriz MAT do tipo char:
linhas
⇓
1
2
3
4
1
A
H
J
S
2
X
D
L
G
3
B
P
M
T
4
E
O
Z
Y
5
Q
K
C
U
6
W
R
V
F
7
R
T
Q
B
⇐ colunas
logo,
MAT [4, 3] = “T”
MAT [2, 5] = “K”
4.1.4.2 Declaração Algorítmica
Declare nome-matriz = Matriz [lil..lsl, lic, lsc] : tipo-básico
onde
lil = limite inferior da linha
lsl = limite superior da linha
lic = limite inferior da coluna
lsc = limite superior da coluna
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
66
4.1.5 Exercícios
1. Confeccione um algoritmo para gerar a matriz quadrática M de 5 linhas e, a seguir imprima essa
matriz na sua estrutura convencional.
2. Confeccione um algoritmo para gerar a matriz quadrática M de 5 linhas e, a seguir imprima a soma
de seus elementos.
3. Confeccione um algoritmo para gerar a matriz quadrada M de dimensão 5 x 5 e, a seguir imprima a
matriz e a soma dos elementos da diagonal principal.
4. Confeccione um algoritmo para gerar a matriz quadrada M de dimensão 5 x 5 e, a seguir imprima a
soma dos elementos situados abaixo da diagonal principal.
5. Confeccione um algoritmo para gerar a matriz quadrada M de dimensão 5 x 5 e, a seguir determine,
através de procedimento, o maior elemento da diagonal principal e o imprima.
6. Confeccione um algoritmo para gerar a matriz quadrática M de 5 linhas e, a seguir imprima os
elementos da diagonal secundária e os acima dela.
7. Confeccione um algoritmo para ler duas matrizes de dimensão M x N e, a seguir, obtenha e
imprima a matriz soma e as matrizes lidas.
8. Confeccione um algoritmo para ler 3 (três) vetores com M elementos e a partir desses, utilizando
procedimento, gerar uma matriz de ordem 3 x M. Imprima os vetores lidos e a matriz gerada.
9. Confeccione um algoritmo para ler uma matriz de dimensão M x N e, a seguir, troque os elementos
da primeira linha pelos elementos da linha onde se encontra o maior elemento da primeira coluna.
Imprima a matriz antes e depois da troca.
10.Confeccione um algoritmo para ler uma matriz quadrada de dimensão 5 x 5 e, a seguir, divida cada
linha da matriz pelo respectivo elemento da diagonal principal. Imprima a matriz antes e depois da
divisão.
11.Confeccione um algoritmo para ler uma matriz quadrada de dimensão M x N e, a seguir, determine
e imprima o menor valor de cada linha e o maior valor de cada coluna.
12.Confeccione um algoritmo para ler uma matriz quadrada de dimensão M x N e, a seguir, eliminar
dessa matriz a primeira linha e a segunda coluna. Imprima a matriz antes e após a eliminação.
13.Confeccione um algoritmo para ler uma matriz quadrada de dimensão 5 x 5 e, a seguir, eliminar
dessa matriz os elementos da diagonal secundária. Imprima a matriz antes e após a eliminação dos
elementos.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
67
14.Confeccione um algoritmo para gerar uma matriz de dimensão M x N e, a seguir, calcular os totais
de cada linha e de cada coluna através de procedimentos e imprima o resultado conforme lay-out
abaixo:
99
99
99
9999
Totais
Matriz Lida
99
99
99
9999
Totais
9999
9999
9999
99
99
99
9999
15.Dado um tabuleiro de xadrez onde, para faciliatr a indicação das peças, foi convencionado:
0 - Ausência de Peças
4 - Bispos
1 - Peões
5 - Reis
2 - Cavalos
6 - Rainhas
3 - Torres
Confeccione um algoritmo para contar a quantidade de cada tipo de peça no tabuleiro. Por exemplo, no
tabuleiro:
1
2
3
4
5
6
7
8
1
6
0
0
0
1
0
1
1
2
0
1
1
0
0
0
0
5
3
0
0
1
2
1
1
0
0
4
5
2
1
0
1
3
0
6
5
0
0
0
3
0
0
2
0
6
0
3
1
4
1
4
2
1
7
1
0
0
4
0
0
2
1
8
0
2
0
3
0
1
1
0
Temos: Peões com 17 peças
Cavalos com 6 peças
Torres com 4 peças, etc..
16. Confeccione um algoritmo para corrigir testes de múltipla escolha de N alunos. O teste tem 10
questões, cada uma valendo 1 (um) ponto. As opções para cada questão são designadas pelas letras
A, B, C, D e E. O algoritmo deverá:
• Ler o número de alunos, o nome e o gabarito da prova;
• Ler para cada aluno seu número de matrícula, seu nome e as opções escolhidas como resposta da
prova numa mesma linha;
• Calcular a nota de cada aluno, a média das notas e, para cada questão, quantos alunos
responderam as opções A, B, C, D e E;
• Imprimir relatório conforme lay-out abaixo:
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
RESULTADO DA CORREÇÃO DA PROVA DE: X----------------------------------------X
GABARITO: X X X X X X X X X X
MATRIC
999
999
999
999
999
NOME
X---------------------X
X---------------------X
X---------------------X
X---------------------X
X---------------------X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
RESPOSTAS
X X X X
X X X X
X X X X
X X X X
X X X X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
NOTA
99
99
99
99
99
MÉDIA DAS NOTAS - 99.9
A
B
C
D
E
1
99
99
99
99
99
2
99
99
99
99
99
3
99
99
99
99
99
Módulo 6 - Lógica de Programação
TOTAIS POR OPÇÃO
QUESTÕES
4
5
6
99
99
99
99
99
99
99
99
99
99
99
99
99
99
99
7
99
99
99
99
99
8
99
99
99
99
99
9
99
99
99
99
99
10
99
99
99
99
99
68
Curso de Informática
Pag.
69
4.2 Heterogêneas
Para muitas aplicações que manipulam informações, o tratamento dessas informações como uma
coleção de dados individuais fica muito restritivo. Veremos como organizar os dados em grupos e,
depois, agregá-los em entidades mais abrangentes.
4.2.1 Registros
4.2.1.1 Definição
Os registros (records) são estruturas de dados heterogêneas, que se caracterizam por possuírem
elementos de tipos diferentes e estarem logicamente relacionados. O uso de registros permitirá ampliar
a gama de aplicações da linguagem.
Por exemplo: A ficha de um empregado de uma empresa.
Os dados estão logicamente relacionados entre si, pois constituem informações cadastrais do mesmo
indivíduo.
Inscrição
Nome
Rua
Registro do Empregado
Número
CEP
CPF
Sexo
Dt Nasc.
O conceito de registro visa facilitar o agrupamento de variáveis que não são do mesmo tipo, mas que
guardam estreita relação lógica.
Registros correspondem a conjuntos de posição de memória conhecidos por um mesmo nome e
individualizados por identificadores associados a cada conjunto de posições
O registro é o caso mais geral de variável composta na qual os elementos do conjunto não precisam
ser, necessariamente, homogêneos ou do mesmo tipo. O registro é constituído por campos.
4.2.1.2 Declaração
Declare lista-de-identificadores registro (campos)
onde:
Declare
lista-de-identificadores
campos
registro
Módulo 6 - Lógica de Programação
É uma palavra chave
São os nomes que estão sendo associados aos registros que se
deseja declarar
São declarações e/ou identificadores de variáveis compostas,
separados por vírgula
É uma palavra chave
Curso de Informática
Pag.
70
O registro acima seria então declarado:
Declare EMPREG registro INSC numérico
NOME, RUA literal
NUM, CEP, CPF numérico
SEXO numérico
DTNASC numérico
4.2.1.3 Acesso ao dados do Registro
Conforme mencionado, cada elemento do registro é denominado de campo do registro, ou
simplesmente campo. O acesso a um campo do registro é feito usando-se um “.” entre o nome do
registro e o nome do campo.
Logo, para acessarmos o campo SEXO do registro do empregado usaríamos: EMPREG.SEXO
Exemplo
Leia EMPREG.SEXO
Se EMPREG.SEXO = “M”
então TOTMASC ← TOTMASC + 1
senão TOTFEM ← TOTFEM + 1
FimSe
Um registro também pode receber ou ser atribuído diretamente a um outro registro, contanto que
ambos sejam do mesmo tipo.
Exemplo:
Declare EMPREG, MAISVELHO registro INSC, NUMERO, CEP, CPF, DTNASC numérico
NOME, RUA, SEXO literal
...
MAISVELHO ← EMPREG
A execução da atribuição acima faz com que o valor de cada campo da variável EMPREG seja
armazenada no campo correspondente da variável MAISVELHO. Essa atribuição é possível, somente
porque EMPREG e MAISVELHO têm exatamente o mesmo tipo (variáveis declaradas na mesma
lista)
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
71
4.2.1.4 Conjunto de Registros (Arrays de Registros)
Os registros podem ser agrupados formando arrays de registros, sendo, cada um, individualizados
através de um índice.
O uso de arrays de registros é recomendado quando queremos definir tabelas na memória,
principalmente para consulta.
Exemplo:
1
Contas
2
Rua
3
Cliente
Nome
Numero
Saldo
CPF
4
5
4.2.1.4.1 Declaração
1
Declare CLIENTE registro NOME, RUA literal
NUMERO, CPF, SALDO numérico
Declare CONTAS Vetor [ 1..5 ] : CLIENTE
2
Declare CONTAS [ 1:5 ] registro NOME, RUA literal
NUMERO, CPF, SALDO numérico
Com a declaração passa existir a variável CONTAS (vetor), onde cada elemento é um registro, com os
campos NOME, RUA, NUMERO, CPF, SALDO.
4.2.1.4.2 Acesso aos Campos
O acesso aos campos de array de registros depende de como a declaração do mesmo foi realizada.
Forma Genérica
identificador-variável [ I ].identificador-registro.identificador-campo
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
72
A especificação do nome do registro depende da declaração feita, podendo portanto, ser omitido.
Exemplo:
Referenciar o campo NOME do 3º elemento do conjunto, ou seja, o nome do cliente número 3.
1
I←3
Leia CONTAS [I].CLIENTE.NOME
Leia CONTAS [3].CLIENTE.NOME
I←3
Leia CONTAS [I].NOME
Leia CONTAS [3].NOME
2
4.2.1.5 Variação das Estruturas
a.1 Estrutura
Inscrição
Nome
Rua
Registro Empregado
Endereço
Num
CEP
CPF
Sexo
Dt Nasc.
a.2 Declaração
Declare ENDERECO registro RUA literal
NUMERO, CEP numérico
Declare EMPREG
registro INSC numérico
NOME literal
ENDERECO
CPF numérico
SEXO literal
DTNASC numérico
a.3 Acesso
Na estrutura acima foi especificada a técnica de refinamento à declaração dos registros. Nestes casos,
quando na declaração do regsitro se encontra um outro registro, o acesso aos campos é feito
hierarquicamente. Primeiro, fez-se menção aos registros mais externos, depois aos mais internos e,
finalmente, aos identificadores dos campos.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
Exemplo: Para acessarmos ao componente CEP usaríamos: EMPREG.ENDERECO.CEP
b.1 Estrutura
1
Registro de Pagamento
CPF
IDENTIDADE
HORAS TRABALHADAS
2
3
4
5
(1, 1)
SALARIO
FGTS
(1, 2)
(2, 1)
(2, 3)
6
b.2 Declaração
Declare HORAS vetor [1:6] numérico
Declare FGTS
matriz [1:2, 1:2] numérico
Declare PAGEMP registro NOME literal
CPF, IDI numérico
HORAS
SALARIO numérico
FGTS
b.3 Acesso aos Campos
Ex-1: Referenciar à quantidade de horas trabalhadas pelo empregado em abril
Escreva PAGEMP.HORAS[4]
Ex-2: Referenciar ao Fgts recolhido no 3º trimestre
Escreva PAGEMP.FGTS [2, 1]
Módulo 6 - Lógica de Programação
73
Curso de Informática
Pag.
c. Conjunto de Pagamentos para 50 Empregados
c.1 Estrutura
1
Estrutura b.1
2
3
4
c.2 Declaração
Declare PAGAMENTOS Vetor [1.. 50] : PAGEMP
c.3 Acesso
Ex-1: Referenciar à quantidade de horas trabalhadas em abril pelo empregado nº 3
Escreva PAGAMENTOS[3].PAGEMP.HORAS[4]
Ex-2: Referenciar ao Fgts recolhido no 3º trimestre pelo empregado nº 3
Escreva PAGAMENTOS[3].PAGEMP.FGTS [2, 1]
Módulo 6 - Lógica de Programação
74
Curso de Informática
4.2.2
Pag.
75
Exercícios
1. Confeccionar um algoritmo para ler o nome de grupo de pessoas e, a seguir, encontrar e imprimir o
telefone de cada uma delas. A tabela contendo o nome e o telefone das pessoas deverá ser
previamente lida.
2. Confeccionar um algoritmo que leia o nome do empregado, o sexo e o salário de 10 empregados e
depois emita para cada empregado os dados acima bem como o percentual da diferença entre o
salário e média dos salários e no final o nome do empregado com maior salário e a média dos
salários.
3. Em certo município, vários proprietários de imóveis estão em atraso com o pagamento do imposto
predial. Desenvolver um algoritmo que calcule e escreva o valor da multa a ser paga por estes
proprietários considerando que:
• os dados de cada imóvel: identificação, valor do imposto e número de meses em atraso deverão ser
lidos;
• as multas devem calculadas a partir do valor do imposto e de acordo com a seguinte tabela que
também deverá ser informada previamente.
Valor do Imposto (R$)
até 500,00
de 500,01 até 1.000,00
de 1.000,01 até 2.000,00
de 2.000,01 até 5.000,00
acima de 5.000,00
% por mês em atraso
1
2
4
7
10
• último registro lido, que não deve ser considerado, contém a identificação do imóvel igual a 0.
• na saída deverão ser impressos: a identificação do imóvel, valor do imposto, meses em atraso e a
multa a ser paga.
• as estruturas de dados a serem adotadas para a solução do problema são:
a. a tabela acima em forma de matriz
b. o registro de imóveis contendo os campos: identificação, valor do imposto e meses em atraso.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
76
Capítulo 5 - Algoritmos Especiais
5.1 Pesquisa em Vetor
A capacidade de armazenar informações foi um passo decisivo na evolução da ciência da computação
e para o nível generalizado de utilização do computador. Com isto, a capacidade de recuperar
informações, para posterior processamento, assume papel de suma importância na utilização cotidiana
do computador, existindo para isso inúmeros exemplos. Dentre eles podemos citar o problema de
recuperação de dados de transações bancárias de um cliente através de um número de conta, no
cadastro de clientes/operações de um banco. Portanto, algoritmos de pesquisa devem ser projetados de
forma a garantir a confiabilidade e eficiência exigidas pela importância das aplicações existentes.
A pesquisa de dados pode ser efetuada tanto em unidades de memória secundária (disco rígido,
disquetes, fita), quanto na memória principal do computador. A estes casos, chamamos,
respectivamente, de problemas de pesquisa externa e interna. Neste texto trataremos somente de
problemas de pesquisa interna. Os métodos aqui apresentados podem ser utilizados em problemas de
pesquisa externa, considerando-se as adaptações necessárias.
Apresentaremos nas seções seguintes os métodos de pesquisa sequencial e binária.
5.1.1 Pesquisa Sequencial
O método mais simples de determinar a presença, ou não, de um elemento numa sequência, é percorrêla a partir do seu início, efetuando comparações, até que o elemento seja encontrado ou o fim seja
alcançado. Este método é chamado de pesquisa sequencial.
Apesar da aparente simplicidade do método proposto, podem ser consideradas inúmeras variações
sobre a sequência de elementos considerada, cada qual exigindo uma forma de aplicação específica do
método. Para a análise de tais casos, consideremos a seguinte especificação de entradas e saídas para o
problema de pesquisa, de modo geral.
Dados:
Ö vetor de n elementos (n conhecido);
Ö elemento a ser pesquisado no vetor (E).
Resultado:
Ö Se o elemento existe mostra-se a sua posição ou o total de ocorrências deste elemento no vetor
(sucesso);
Ö Se o elemento não existe, mostra-se uma mensagem de falha.
As considerações que podem ser feitas sobre os dados de entrada (vetor), são do tipo: o vetor está ou
não ordenado; o elemento ocorre uma única vez (pesquisa única) ou repetidas no vetor (pesquisa
múltipla).
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
5.1.1.1 Pesquisa Única
Caso 1: Vetor Desordenado
35
10
1
30
2
35
3
30
4
5
5
80
6
7
Para E = 30 Ö sucesso (3 testes)
Para E = 12 Ö falha (7 testes)
Caso 2: Vetor Ordenado
5
10
30
30
35
35
80
2
3
4
5
6
7
1
Para E = 30 Ö sucesso (3 testes)
Para E = 12 Ö falha (3 testes)
5.1.1.2 Pesquisa Múltipla
Caso 1: Vetor Desordenado
35
1
10
2
30
35
3
30
4
5
5
80
6
7
Para E = 30 ⇒ 2 sucessos (7 testes)
Para E = 12 ⇒ falha
(7 testes)
Caso 2: Vetor Ordenado
5
10
1
30
2
Para E = 30 ⇒ 2 sucessos (5 testes)
Para E = 12 ⇒ falha
(3 testes)
Módulo 6 - Lógica de Programação
30
3
35
35
4
5
80
6
7
77
Curso de Informática
Exercícios Propostos:
1- Desenvolver cada um dos algoritmos de pesquisa.
Program Usa_Pesquisa_Sequencial;
Uses crt;
{implementa o algoritmo de pesquisa sequencial unica e multipla}
Type
vetor = array [1..100] of integer;
{--------------------------- subprogramas ----------------------------------}
Procedure Ler_Sequencia (var vet : vetor; var n : integer);
var i : integer;
begin
writeln('Digite o valor de n');
readln(n);
writeln('Digite o valor da sequencia');
for i := 1 to n do
begin
write('elemento [',i,'] : ');
readln( vet[i] );
end;
writeln;
end;
{------------------------ programa principal -------------------------------}
Var
vet
: vetor;
{espaço para pesq. }
n
: integer;
{tamanho do espaço }
dado
: integer;
{ dado procurado }
achou
: boolean;
{resultado da pesq.}
posicao
: integer;
{posição encontrada}
frequencia : integer;
{ frequência. Encontrada }
tipo_pesq : integer;
Begin
clrscr;
writeln('***** pesquisa sequencial *****':50);
Ler_Sequencia (vet, n);
repeat
writeln('Escolha o tipo de pesqisa.');
writeln('1 -> pesquisa sequencial £nica desordenada');
writeln('2 -> pesquisa sequencial £nica ordenada');
writeln('3 -> pesquisa sequencial m£ltipla desordenada');
writeln('4 -> pesquisa sequencial m£ltipla ordenada');
writeln;
Módulo 6 - Lógica de Programação
Pag.
78
Curso de Informática
Pag.
79
readln(tipo_pesq);
writeln('Digite o dado (0 - termina)');
readln(dado);
case tipo_pesq of
1 : Pesq_Seq_unica_1 (vet, n, achou, posicao);
2 : Pesq_seq_unica_2 (vet, n, dado, achou, posicao);
3 : Pesq_Seq_multipla_1 (vet, n, dado, achou, frequencia);
4 : Pesq_Seq_multipla_2 (vet, n, dado, achou, frequencia);
end;
case tipo_pesq of
1,2 : if achou
then writeln('Existe na posi‡Æo = ',posicao)
else writeln('NÆo existe');
3,4 : if achou
then writeln('Total de ocorrˆncias = ',frequencia)
else writeln('NÆo existe');
end;
until dado = 0;
End.
5.1.2 Pesquisa Binária
O método de pesquisa sequencial é fácil de escrever e é razoavelmente eficiente para sequências com
poucos elementos. Entretanto, para sequências de tamanho considerável, que ocorre na maioria das
aplicações existentes, a utilização do método torná-se inviável. Uma estratégia interessante e eficiente
é utilizada no método de pesquisa binária.
→ Definir intervalo inicial (i,f) de busca
→ Definir a posição média do intervalo (m= (i + f) / 2 )
Comparar o elemento da posição média (v[m]) com o elemento E:
caso sejam iguais então terminou a pesquisa
caso contrário definir o novo intervalo de busca
→ Aplicar sucessivamente o passo anterior até encontrar E ou não existir mais intervalo de
busca.
Módulo 6 - Lógica de Programação
Curso de Informática
São aspectos fundamentais do método:
→ O vetor de entrada tem que estar ordenado;
→ O intervalo de busca inicial é (i,f) = (l,n);
→ O intervalo de busca, considerado a cada iteração, é definido do seguinte modo:
• (i, m-l), se (E < v[m])
• (m+1,f), se (E > v[m])
tendo a metade do tamanho do intervalo original;
→ Não existirá intervalo de busca quando (i > f);
Dados:
→ vetor de n elementos (n conhecido);
→ elemento a ser pesquisado no vetor (E);
Resultado:
→ se o elemento existe, mostra-se a sua posição no vetor. (sucesso)
→ se o elemento não existe, mostra-se uma mensagem de falha.
Módulo 6 - Lógica de Programação
Pag.
80
Curso de Informática
Pag.
Exemplo-1: Para E = 10
10
15
20
25
30
35
40
1
2
3
4
5
6
7
10
15
20
25
30
35
40
1
↑I
2
4
↑M
5
6
7
↑F
10
15
20
25
30
35
40
1
↑I
2
↑M
3
↑F
4
5
10
15
20
25
30
1
I↑F
M
2
3
4
5
3
6
35
6
7
40
7
Sucesso com 3 testes
Exemplo-2: Para E = 37
10
15
20
25
1
↑I
2
3
4
↑M
10
15
20
25
1
2
3
4
10
15
20
25
1
2
3
4
30
5
35
40
6
7
↑F
40
30
35
5
↑I
6
↑M
30
35
5
6
7
↑F
40
7
I↑ F
M
10
15
20
25
1
2
3
4
Falha com 3 testes
Módulo 6 - Lógica de Programação
30
5
35
6
↑F
40
7
↑I
81
Curso de Informática
Pag.
Exercício:
1- Desenvolver um algoritmo de pesquisa (trecho de programa em PASCAL abaixo):
program Usa_Pesquisa_Binaria;
Uses crt;
{Implementa o algoritmo de pesquisa binária}
Type
vetor = array [1..100] of integer;
Var
vet
: vetor;
n
: integer;
dado : integer;
achou : boolean;
posicao : integer;
{espaço para pesquisa. }
{tamanho do espaço }
{ dado procurado }
{resultado da pesq.}
{posição entrada }
{----------------------------- subprogramas --------------------------------}
{------------------------- programa principal ------------------------------}
Begin
clrscr;
writeln('**** pesquisa binária ****':50);;
Ler_Sequencia (vet, n );
{A mesma definida em pesqseq.pas}
repeat
writeln;
writeln('Digite o dado (0 - termina)');
readln(dado);
{---- executar a pesquisa binária ----}
Pesquisa_Binaria (vet, n, dado, achou, posicao);
if achou
then writeln('Existe na posição ¯ ',posicao)
else writeln('Não existe');
until dado = 0;
End;
Módulo 6 - Lógica de Programação
82
Curso de Informática
Pag.
83
5.2 Algoritmos de Ordenação
Os problemas de ordenação são comuns tanto em aplicações comerciais quanto em científicas.
Entretanto, raro são os problemas que se resumem a pura ordenação de sequências de elementos.
Normalmente, os problemas de ordenação são inseridos em problemas de pesquisa, intercalação e
atualização. Isto torna ainda mais importante o projeto e a construção de algoritmos eficientes e
confiáveis para tratar o problema.
De modo análogo ao problema de pesquisa, uma dada aplicação pode exigir que seja feita uma
ordenação em mémoria secundária, chamada ordenação externa, A ordenação interna normalmente é
efetuada no próprio vetor em que os elementos são armazenados, sem a utilização de um vetor
adicional.
Agora analizaremos três métodos de ordenação1 interna: SelectionSort, BubbleSort e InsertionSort.
5.2.1 SelectionSort
Este método é um dos mais simples e intuitivos dentre os métodos existentes. Sua estratégia básica é
selecionar o menor elemento da sequência considerada e colocá-lo no início da sequência. Assim,
dada uma sequência de tamanho n, várias iterações são efetuadas, sendo que a cada vez que esta
estratégia é aplicada, uma nova sequência é gerada pela eliminação do menor elemento da sequência
original.
Exemplo-1: Algoritmo SelectionSort
Procedure SelectionSort ( var vet : vetor; n : integer);
{ordenação crescente}
var
i, j, pmin : integer;
begin
for i := 1 to (n-1) do
begin
pmin := 1;
for j := (i + 1) to n do
if vet[j] < vet[pmin]
then pmin := j;
trocar (vet[i], vet[pmin]);
end;
end;
1
{inicializa}
{procura o menor}
{troca com o menor}
A forma de ordenação pode ser crescente ou decrescente. Neste texto optou-se pela ordenação crescente.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
Consideramos a execução do procedimento acima para o vetor
40
30
20
10
30
20
↑
pmin
2
↑
j
40
10
30
20
30
20
1
10
2
3
4
Para i = 1, são feitas as seguintes comparações
40
1
1
2
↑
pmin
40
1
10
2
3
4
3
↑
j
4
3
↑
pmin
10
4
↑
j
40
30
20
troca realizada
Para i = 2, são feitas as seguintes comparações:
10
1
10
1
40
30
↑
pmin
↑
j
40
30
2
2
3
↑
pmin
10
Módulo 6 - Lógica de Programação
20
30
3
20
4
20
4
↑
j
40
84
Curso de Informática
Pag.
85
Para i = 3, são feitas as seguintes comparações:
10
1
20
2
30
3
↑
pmin
10
20
30
vetor ordenado
40
4
↑
j
40
5.2.2 BubbleSort
Este método é levemente mais complexo que o SELECTIONSORT, mas apesar de possuir a mesma
ordem de complexidade do método anterior , ele efetua em média um número menor de comparações
como veremos a seguir.
A estratégia utilizada pelo BUBBLESORT consiste em comparações e trocas entre elementos
consecutivos da sequência, a fim de “empurrar” o maior elemento para a última posição. Assim, várias
iterações são efetuadas e, para cada sequência considerada, a aplicação da estratégia gera uma nova
sequência pela eliminação do maior elemento da sequência original.
Além disto, uma variável de controle (lógica) é utilizada para registrar a ocorrência ou não de troca
entre elementos da sequência. Quando nenhuma troca é efetuada, tem-se que a sequência considerada
já estava ordenada. Esta particularidade determina, em alguns casos, um número menor de
comparações que o método SelectionSort.
Procedure BubbleSort (var vet : vetor; n : integer); {ordenação crescente }
var
i, limite : integer;
trocou : boolean;
begin
limite := n;
repeat
trocou := false;
for i := 1 to (limite - 1) do
begin
if vet [i] > vet [i + 1] then
begin
trocar (vet [i], vet[i + 1]);
trocou := true;
limite := i
end
end;
until not trocou;
end;
Módulo 6 - Lógica de Programação
{ordenação crescente}
{otimização}
Curso de Informática
Pag.
Consideremos a execução do procedimento acima para o vetor
40
1
10
30
20
2
3
4
Para i de l a 3, são feitas as seguintes comparações:
40
10
30
20
1
↑
2
↑
3
4
10
40
30
20
1
2
↑
3
4
↑
10
30
40
20
1
2
3
↑
4
↑
10
30
20
40
ocorreram 3 trocas.
Para i de 1 a 2, são feitas as seguintes comparações:
10
30
1
↑
2
↑
10
30
1
2
↑
10
20
20
40
3
20
3
4
40
4
↑
30
ocorreu 1 troca.
Módulo 6 - Lógica de Programação
40
86
Curso de Informática
Pag.
Para i = 1, é feita a seguinte comparação:
10
30
20
40
1
↑
2
↑
3
4
10
20
30
40
não ocorreram trocas
5.2.3 InsertionSort
Este método baseia-se no seguinte processo de inserção controlada:
• Com o primeiro elemento de sequência original (desordenada) forma-se uma sequência
ordenada de tamanho 1.
• Cada elemento restante da sequência original é inserido na nova sequência, de modo que esta
permaneça ordenada. Isto é feito através de uma pesquisa na sequência ordenada que determina
a posição que ele deverá ocupar.
• Quando um elemento é inserido a frente de outros, estes deverão ser deslocados de uma
posição.
Exemplo: Para a entrada (40, 10, 30, 20). O método determina as seguintes inserções:
40
1
10
40
1
2
10
30
40
1
2
3
10
20
30
40
3
4
1
2
Módulo 6 - Lógica de Programação
87
Curso de Informática
Pag.
88
Bibliografia
1. Harry Farrer, Algoritmos Estruturados, Rio de Janeiro, 1985.
2. Guimarães / Lages, Algoritmos e Estruturas de Dados, Rio de Janeiro, Livros Técnicos e
Científicos, 1985.
3. Sérgio E.R. de Carvalho, Introdução a Programação com Pascal, Rio de Janeiro, Campus, 1985.
4. Kathleen Jensen e Niklaus Wirth, Pascal ISO, Rio de Janeiro, Campus, 1988.
5. Eber A. Schmitz e Antônio A. S. Teles, Pascal e Técnicas de Programação, Rio de Janeiro, Livros
Técnicos e Científicos, 1985.
6. Steve Wood, Turbo Pascal - Guia do Usuário, São Paulo, McGraw-Hill, 1987.
Módulo 6 - Lógica de Programação
Curso de Informática
Pag.
Cronograma de Atividades
Atividade
Mês
Data
1
2
3
4
5
6
7
8
Módulo 6 - Lógica de Programação
Conteúdo
89