IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
1
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
Sumário
1 Algoritmos................................................................................................................. 3
2 A Linguagem Pascal.................................................................................................. 4
2.1 Construção do programa em Pascal.................................................................... 4
2.1.1 Cabeçalho do Programa............................................................................... 5
2.1.2 Área de Declarações.................................................................................... 5
2.1.3 Corpo do Programa...................................................................................... 5
2.2 Variáveis............................................................................................................. 6
2.2.1 Tipos de Variáveis....................................................................................... 6
2.2.2 Atribuição de Valores.................................................................................. 7
2.3 Entrada e Saída de dados.................................................................................... 7
2.3.1 Entrada de dados.......................................................................................... 8
2.3.2 Saída de dados............................................................................................. 8
2.4 Operadores.......................................................................................................... 8
2.5 Posicionamento na tela....................................................................................... 9
2.6 Cores do texto e fundo (textbackground e textcolor)..........................................9
2.7 Estruturas de Repetição e Condição................................................................. 10
2.7.1 Comando for n=:1 to 10............................................................................. 10
2.7.2 Comando If ... then ... else......................................................................... 10
2.7.3 Comando While......................................................................................... 10
2.7.4 Comando Break......................................................................................... 11
2.8 Comando Case of:............................................................................................. 12
3 Variáveis Compostas Homogêneas - Vetores ......................................................... 14
3.1 Uso do comando for com vetores..................................................................... 14
3.2 O que se pode e o que não se pode fazer com vetores, na linguagem Pascal:.. 15
3.2.1 Não é possível:.......................................................................................... 15
3.2.2 O que é permitido:..................................................................................... 15
4 Variáveis Compostas Homogêneas – Matrizes........................................................16
5 Procedimentos (procedures).....................................................................................17
6 Variáveis Compostas Heterogêneas – Registros......................................................19
7 Menu Hierárquico.................................................................................................... 20
8 Variáveis Compostas Heterogêneas – Registros em arquivos (c:\cadastro.txt)....... 22
2
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
3
ALGORITMOS II
1 Algoritmos
Um algoritmo pode ser definido como um conjunto de regras (instruções), bem definidas,
para solução de um determinado problema. Segundo o dicionário Michaelis, o conceito de
algoritmo é a "utilização de regras para definir ou executar uma tarefa específica ou para resolver
um problema específico."
A partir desses conceitos de algoritmos, pode-se perceber que a palavra algoritmo não é um
termo computacional, ou seja, não se refere apenas à área de informática. É uma definição ampla
que agora que você já sabe o que significa, talvez a utilize no seu cotidiano normalmente.
Na informática, o algoritmo é o "projeto do programa", ou seja, antes de se fazer um
programa (software) na Linguagem de Programação desejada (Pascal, C, Delphi, etc.) deve-se fazer
o algoritmo do programa. Já um programa, é um algoritmo escrito numa forma compreensível pelo
computador (através de uma Linguagem de Programação), onde todas as ações a serem executadas
devem ser especificadas nos mínimos detalhes e de acordo com as regras de sintaxe1 da linguagem
escolhida.
Uma das formas mais eficazes de aprender algoritmos é através de muitos exercícios.
Tabela 1: Dicas de como aprender e como não aprender algoritmos
Algoritmos não se aprende
Algoritmos se aprende
Copiando algoritmos
Construindo algoritmos
Estudando algoritmos prontos
Testando algoritmos
Os algoritmos podem ser representados de várias formas, como por exemplo:
a) Através de uma língua (português, inglês, etc.): forma utilizada nos manuais de
instruções, nas receitas culinárias, bulas de medicamentos, etc.
b) Através de uma linguagem de programação (Pascal, C, Delphi, etc.): esta forma é
utilizada por alguns programadores experientes, que "pulam" a etapa do projeto do programa
(algoritmo) e passam direto para a programação em si.
c) Através de representações gráficas: são bastante recomendáveis, já que um "desenho"
(diagrama, fluxograma, etc.) muitas vezes substitui, com vantagem, várias palavras.
Diagrama NassiFluxograma
Português
Shneiderman
Estruturado
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
4
2 A Linguagem Pascal
Pascal é uma linguagem de programação estruturada, que recebeu este nome em
homenagem ao matemático Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth, tendo em
mente encorajar o uso de código estruturado.
O próprio Niklaus Wirth diz que Pascal foi criada simultaneamente para ensinar
programação estruturada e para ser utilizada em sua fábrica de software. Simultaneamente, a
linguagem reflete a liberação pessoal de Wirth das restrições impostas após seu envolvimento com a
especificação de ALGOL 68, e sua sugestão para essa especificação, o ALGOL W.
Pascal originou uma enorme gama de dialetos, podendo também ser considerada uma
família de linguagens de programação. Grande parte de seu sucesso se deve a criação, na década de
1980, da linguagem Turbo Pascal, inicialmente disponível para computadores baseados na na
arquitetura 8086 (com versões para 8080 no seu início).
Pascal é normalmente uma das linguagens de escolha para ensinar programação, junto com
Scheme, C e Fortran. Comercialmente, a linguagem foi sucedida pela criação da linguagem Object
Pascal, atualmente utilizada nos IDEs Embarcadero Delphi (Object Pascal), Kylix e Lazarus.
2.1 Construção do programa em Pascal
O programa se constitui num texto, que pode ser editado em qualquer editor de texto ou
diretamente no compilador, sendo necessário ser salvo com a terminação .pas de pascal, em seguida
compilado (traduzido para linguagem de máquina), para depois ser executado. Nos compiladores de
hoje já é possível executar direto pulando todas estas etapas.
Um programa em Pascal é composto, basicamente, de três partes. São elas:
Cabeçalho do Programa;
Área de Declarações;
Corpo do Programa.
Vejamos, na figura a seguir como essas partes são distribuídas em um programa:
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
5
2.1.1 Cabeçalho do Programa
Esta área é utilizada para se fazer a identificação do programa com um nome. O cabeçalho
de um programa é constituído pela instrução PROGRAM seguida de um nome. Ao final do nome
deve-se colocar o símbolo ponto-e-vírgula ( ; ).
2.1.2 Área de Declarações
Esta área é utilizada para validar o uso de qualquer tipo de identificador que não seja
predefinido, estando divida em sete sub-áreas: uses, label, const, type, var, procedure e function.
No II Curso Pré-engenharia, vamos estudar apenas a sub-área var. Esta é utilizada na
declaração das variáveis que serão utilizadas durante a execução de um programa, assim como o seu
tipo.
2.1.3 Corpo do Programa
Nessa área escreveremos nossos algoritmos utilizando as funções da linguagem Pascal e as
declarações feitas na área anterior. Aqui está o programa propriamente dito, isto é, a
seqüência de instruções que daremos à máquina para que ela crie um programa que execute as ações
que desejamos.
Iniciamos o corpo do programa com a instrução BEGIN e finalizamos com a instrução END
seguida de um ponto ( . ). O uso dessas instruções caracteriza o que chamamos de bloco.
O programa em Pascal se constitui basicamente de:
{comentários entre chaves não são lidos pelo
compilador}
program Nome_do_programa; {identificação do
programa}
var
{declaramos as variáveis}
a,b,c:real; {variáveis:tipo}
begin
{início do corpo do programa}
read(a); {comandos dentro do corpo}
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
c:=a;
vírgula}
end.
{comandos
terminam
com
ponto
6
e
{fim do corpo do programa com ponto}
2.2 Variáveis
Em programação, variáveis são regiões da memória do computador previamente
identificadas, que têm por finalidade armazenar informações (dados) de um programa
temporariamente. Podem ser vistas como um papel, inicialmente em branco, onde se podem
escrever valores (sejam numéricos, de texto ou lógicos) no decorrer da execução do programa.
Uma variável pode armazenar apenas um valor por vez. Sendo considerado como valor o
conteúdo de uma variável, este valor está associado ao tipo de dado da variável.
Para declarar variáveis na linguagem Pascal, devemos
Nesse
exemplo
estamos
obedecer à seguinte sintaxe:
declarando as variáveis de nome Soma,
Total e Salário como sendo do
tipo REAL; Idade e Contador como
sendo do tipo INTEGER; e Nome como
sendo do tipo STRING.
2.2.1 Tipos de Variáveis
Veremos aqui os principais tipos de variáveis que são utilizados na linguagem Pascal.
Descrição
Tamanho
Tipo
Boolean
Char
Byte
Variáveis
desse
tipo
podem armazenar
apenas
dois
valores
distintos: True ou False
(Verdadeiro ou Falso).
Variáveis desse tipo
podem armazenar apenas um
caractere.
Armazena valores inteiros
positivos entre 0 e
8 bits (1 byte)
8 bits (1 byte)
8bits (1 byte)
255, inclusive.
Integer
Armazena valores inteiros
positivos ou
16 bits (2 bytes)
negativos entre -32768
e 32767.
Longint
Armazena valores inteiros
positivos ou
32 bits (4 bytes)
negativos
entre
-2147483648 e 2147483647.
Shortint
Armazena valores inteiros
positivos ou
negativos entre -128 e
8 bits (1 byte)
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
7
127.
Word
Armazena valores inteiros
positivos entre 0 e
16 bits (2 bytes)
65535.
Double
Armazena valores reais.
Possui precisão de
8 bytes
15 dígitos.
Real
Armazena valores reais.
Possui precisão de
6 bytes
11 dígitos.
String
Armazena cadeias
caracteres (palavras ou
frases).
de
variável
Depende do valor da
2.2.2 Atribuição de Valores
Para atribuir valores a uma variável,
utilizamos a seguinte construção:
Nome-da-Variável := Valor;
Vejamos este exemplo:
Esse programa declara algumas variáveis e
atribui valores a elas. Observe que quando
trabalhamos com caracteres ou string, o
valor atribuído deve estar entre aspas simples (‘ ’).
Caso
contrário o resultado não sairá como o
esperado.
Observe também que esse programa não
exibe nenhuma mensagem na tela do computador.
Ele
apenas atribui valores às variáveis e finaliza
sem qualquer mensagem. No capítulo seguinte
aprenderemos
como fazer isso.
2.3 Entrada e Saída de dados
Aqui começaremos a apresentar os primeiros comandos da linguagem Pascal. É muito
importante prestar atenção na sintaxe dos comandos, pois pequenos erros farão com que o
compilador exiba uma mensagem de erro e o programa não será criado.
Entrada e saída de dados são fundamentais em todos os programas criados, pois estabelecem
uma comunicação entre a máquina e o usuário.
2.3.1 Entrada de dados
Em Pascal, a entrada de dados é feita utilizando o comando readln(). A sintaxe desse
comando é a seguinte:
readln(Variável1, Variável2, ...);
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
8
Nesse caso, o programa vai
parar sua execução até que o usuário
digite algum valor. Ao digitar o
valor e pressionar a tecla
ENTER, o valor digitado será
armazenado na Variável1 e o programa
esperará
novamente por um valor, mas o
armazenará na Variável2. Isso se repete
até que todas as variáveis
listadas estejam preenchidas
com algum valor.
Vejamos um programa que
utiliza entrada de dados pelo usuário:
2.3.2 Saída de dados
Em Pascal, a saída de dados é feita
utilizando o comando writeln(). Esse
comando imprime alguma
mensagem na tela do computador.
Vejamos sua sintaxe:
Writeln(‘Mensagem 1’, variável 1,
...);
Vejamos ao lado um programa que
apenas exibe uma mensagem na tela:
2.4 Operadores
Os operadores, como o nome sugere, nos permitem realizar operações entre variáveis
numéricas.
Essas operações podem ser algébricas, lógicas ou de comparação. Dessa forma, existem
operadores diferentes para cada tipo. Veremos a seguir.
Operadores Aritméticos
Resumiremos os operadores aritméticos na seguinte tabela:
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
Operador
Função
+
*
/
div
Soma
Subtração
Multiplicação
Divisão simples
Divisão inteira
mod
Resto da divisão inteira
9
Um exemplo da utilização desses operadores pode ser observado no programa abaixo.
Nosso primeiro exemplo de programa em Pascal:
program nome;
var
nome:string;
begin
clrscr;
write('Escreva um nome ');
read(nome);
writeln('O nome que voce escreveu foi: ',nome);
readkey;
end.
Segundo desafio:
Criar um programa que leia dois valores e calcule as operações básicas com os mesmos:
Adição, subtração, multiplicação, divisão e média.
2.5 Posicionamento na tela
O comando gotoxy define a posição do cursor do teclado na tela.
Sintaxe
gotoxy (coluna: integer ; linha: integer ) ;
Exemplo.Programa que move o cursor do teclado para a linha 10, coluna 15, e imprime
"Olá, mundo!" na tela.
Program PascalZIM;
Begin
gotoxy(15,10);
textcolor( lightcyan );
textbackground( red );
write('Olá, mundo!');
End.
2.6 Cores do texto e fundo (textbackground e textcolor)
O comandos definem a cor de fundo usada na impressão de textos.
Sintaxe
textbackground ( listaDeCores ) ; textcolor ( listaDeCores ) ;
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
10
onde listaDeCores pode ser uma constante inteira ou qualquer uma dentre as cores seguintes:
BLUE
GREEN
CYAN
RED
MAGENTA
BROWN
LIGHTGRAY
DARKGRAY
LIGHTBLUE
LIGHTCYAN
LIGHRED
LIGHMAGENTA
LIGHTGREEN
YELLOW
WHITE
BLACK
2.7 Estruturas de Repetição e Condição
Por vezes, precisamos que o programa realize determinada ação repetidamente, seja por um
número determinado de vezes, ou enquanto uma condição está sendo satisfeita, ou mesmo
até que uma condição seja verificada. Para isto utilizam-se as Estruturas de Repetição, para evitar
que, por exemplo, tenhamos que escrever 30 vezes o comando readln() quando quisermos ler do
teclado as notas dos 30 alunos de uma turma de informática.
2.7.1 Comando for n=:1 to 10
Repete a execução de um bloco de
comandos por um número de vezes que depende
dos
objetivos do programa. Sua sintaxe é a
seguinte:
Desafio: criar um programa que mostre na tela os números de 1 a 100, sendo que dez
números em cada linha.
2.7.2 Comando If ... then ... else
Na maioria dos casos, quando verificamos
uma condição, queremos que uma ação seja
tomada
no caso da condição ser satisfeita, mas
também queremos que outra ação seja tomada no
caso da
condição não ser verificada. Para isso
existe a estrutura supracitada, cuja sintaxe é a que
segue (atenção à
ausência de ponto-e-vírgula antes do
comando else):
Desafio: criar um programa que mostre na tela os números de 1 a 100, sendo que dez
números em cada linha, porém, os números pares tem que ser amarelos e os ímpares brancos.
Desafio: criar um algoritmo para ler o nome do aluno, notas das tres provas, e calcular se
o mesmo foi aprovado ou reprovado conforme a média(mínimo 6).
2.7.3 Comando While
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
11
Difere do comando for quanto à sintaxe.
A maioria dos programas em que se usa o while
podem ser feitos usando-se o for, e vice-versa.
Porém, em alguns casos a escolha de um deles
simplifica significativamente a lógica a ser
utilizada. Vejamos a sintaxe do comando while:
Dasefio: criar um algoritmo para ler um número infinito de palavras e mostrar na tela
após a leitura. Para encerrar a leitura, deverá ser digitada a palavra “SAIR”.
2.7.4 Comando Break
Algumas vezes é interessante parar o programa antes que um laço seja realizado por
completo.
Nestes casos, utiliza-se o comando break, cuja sintaxe será mostrada no exemplo a seguir:
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
12
Desafio: montar um algoritmo que crie X números aleatórios . O usuário tem que digitar
o número até acertar. Quando isto ocorrer, o algoritmo tem que emitir uma mensagem e avisar
sobre o acerto do número. O usuário terá um número Y de tentativas.
Desafio da loteria. Os números da loteria são de 01 até 60. Montar um algoritmos que
sorteie 6 dezenas. Não pode haver duplicidade de números.
Escreva um programa que leia a razão de uma PA, o seu primeiro termo e a quantidade
de termos e com isso calcule a soma dessa PA.
2.8 Comando Case of:
Possibilita a escolha de um conjunto de comandos que serão executados, dentre várias
alternativas de escolha.
Sintaxe
case < selector > of
< lista de constantes > : < comandos > ;
< lista de constantes > : < comandos > ;
...
< lista de constantes > : < comandos > ;
else < comandos > ;
end ;
Onde:
- < seletor > é uma expressão do tipo integer ou char ;
- < lista de constantes > é uma sequência de constantes do tipo integer ou char, separadas
por vírgula (ao invés de uma constante é possível usar um intervalo de constantes, que consiste em
duas constantes separadas por um par de pontos)
A cláusula else não é obrigatória, e os comandos associados a essa cláusula serão
executados somente se nenhuma outra opção do case foi selecionada ;
Exemplo
Program PascalZIM ;
Var
opcao : integer ;
Begin
write ( 'Entre com uma opcao: ' );
readln ( opcao );
case opcao of
1 : writeln( 'Você escolheu a opção 1...' );
2 : writeln( 'Você escolheu a opção 2...' );
3 : writeln( 'Você escolheu a opção 3...' );
else writeln( 'Você escolheu uma opção diferente de 1, 2, 3...' );
end ;
End.
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
13
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
14
3 Variáveis Compostas Homogêneas - Vetores
Um vetor (array em inglês) é um agregado de variáveis do mesmo tipo (homogêneas). O
exemplo abaixo mostra a representação gráfica de um vetor de 6 inteiros chamado v:
Cada “casa” , ou “elemento”, do vetor é uma variável independente. No exemplo acima,
cada elemento pode conter um valor inteiro, e as posições foram ordenadas de 1 até 6. Os
elementos de um vetor são identificados pelo nome do vetor associado ao número de ordem da sua
posição relativa no vetor: v[1], v[2], v[3], v[4], v[5] e v[6].
Assim, no caso acima, a variável v[2] tem o valor 67.
Podemos alterar esse valor exatamente como fazemos com qualquer variável:
v[2] := 100;
readln(v[2]);
Para declarar esse vetor em um programa Pascal, é usada a forma abaixo:
var
v: array[1..6] of integer;
A forma geral é:
var <identificador do vetor>: array [<intervalo das posições>] of <tipo dos valores do vetor>
Cada variável do conjunto é representada por:
<identificador do vetor>[<expressão cujo valor é a posição da variável> ]
onde a expressão deve ser do tipo declarado.
Por exemplo, a variável na posição 3 do vetor pode ser representada por:
v[3]
v[10-7]
v[5*5-2*11] v[x-4], supondo que x tenha o valor 7, etc.
3.1 Uso do comando for com vetores
A manipulação de vetores é grandemente facilitada pelo uso dos comandos de repetição,
especialmente o for. Por exemplo, para zerar (colocar o valor 0) todas as posições do vetor v
definido acima, seria necessário escrever 6 comandos:
v[1]:= 0;
v[2]:= 0;
v[3]:= 0;
v[4]:= 0;
v[5]:= 0;
v[6]:= 0;
A mesma operação pode ser feita com apenas um comando de repetição for, usando uma
variável de controle para representar as posições do vetor:
for i:= 1 to 6 do v[i]:=0;
É fácil imaginar o que isso representa de simplificação para a manipulação de vetores
grandes.
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
15
Da mesma forma, para ler do teclado todos os valores do vetor v, seriam também
necessários 6 comandos:
read (v[1]);
read (v[2]);
read (v[3]);
read (v[4]);
read (v[5]);
read (v[6]);
Todos esses comandos podem ser substituídos por um único comando for:
for i:= 1 to 6 do read(v[i]);
3.2 O que se pode e o que não se pode fazer com vetores, na
linguagem Pascal:
3.2.1 Não é possível:
a) Não se pode ler todo um vetor diretamente com um comando read. Não se pode escrever:
read(v);
É necessário ler casa a casa, diretamente, ou com um laço de repetição como for no exemplo
acima.
b) Não se pode escrever todos os elementos de um vetor com um único comando write. Não é
permitido escrever: write(v). Também nesse caso cada elemento deve ser tratado como uma
variável independente, por exemplo:
for i:= 1 to 6 do write(v[i]);
c) Não é possível copiar os valores dos elementos de um vetor para outro com um único comando
de atribuição. Ou seja, dados dois vetores v e w, ambos do mesmo tamanho e do mesmo tipo,
não é permitido fazer: w:= v; . Também aqui é necessário trabalhar elemento a elemento, e o
comando for mais uma vez é indicado:
for i:= 1 to 6 do w[i]:= v[i];
c) Não existe comandos ou funções que dão o tamanho (número de elementos) de um vetor.
d) Não é permitido tentar acessar uma posição fora do intervalo de posições definido para o vetor. A
tentativa causará um erro em tempo de execução e o programa abortará. No caso do vetor v
acima, por exemplo, não é permitido escrever: v[8]:= 20, read(v[8]) ou write (v[8]) porque
a faixa de valores das posições vai de 1 a 6 apenas.
3.2.2 O que é permitido:
a) A faixa de valores das posições não precisa começar em 1. Qualquer intervalo de valores pode
ser usado na definição de um vetor. Por exemplo, podemos definir um vetor assim:
var v:array[15..20] of real;
Nesse caso o vetor v terá apenas os elementos: v[15], v[16], v[17], v[18], v[19] e v[20]
b) As posições não precisam ser necessariamente números inteiros. Podem ser qualquer tipo
ordinal, ou seja, que possa ser definido por uma seqüência ordenada de valores. Por exemplo, os
caracteres em Pascal formam uma seqüência ordenada na tabela de caracteres, e podem portanto
serem marcadores de posição em um vetor.
Podemos definir um vetor assim:
var letras: array['a'..'z'] of integer;
Nesse caso os elementos do vetor são: letras['a'], letras['b'], ….., letras['z']
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
16
4 Variáveis Compostas Homogêneas – Matrizes
Matriz é um vetor em que existem duas dimensões, linha e coluna. Serve para armazenar
várias informações em cada linha, porém todas do mesmo tipo (número ou texto). Não se pode
inserir um número e um texto na mesma matriz.
A declaração abaixo define um vetor de duas dimensões, do tipo inteiro:
var
matriz : array [ 1 .. 10, 1.. 20 ] of integer ;
matriz com 10 linhas e 20 colunas cada linha.
matriz : array [ 1 .. 5, 1.. 5 ] of integer ;
matriz com 5 linhas e 5 colunas cada linha.
Desafio: Fazer um programa que dada duas matrizes A e B, determinar a soma de A e B.
A soma de duas matrizes é bastante simples, apenas precisamos somar os elementos
correspondentes de cada matriz e o resultado colocar em uma outra matriz. Veja o seguinte exemplo
de soma de dois matrizes A e B de tamanho 3x3:
Desafio: Crie um programa em pascal que realize as seguintes operações na matriz C:
a) soma dos elementos de cada linha;
b) soma dos elementos de cada coluna
c) soma dos elementos da diagonal principal;
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
17
5 Procedimentos (procedures)
Uma procedure é uma parte do programa que pode ser
executada diversas vezes com base em algum critério.
Exemplo: de acordo com um valor de entrada, se o mesmo for
par, executa determinado cálculo, caso contrário, outro
cálculo.
A chamada ou ativação de uma procedure é feita
referenciando-se o seu nome no local do programa onde a
mesma deve ser ativada, ou seja, onde a sua execução deve
ser iniciada. Observe o exemplo:
O programa ao lado lê 2 valores e
mostra a soma e subtração dos
mesmo através de procedures.
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
18
Ao terminar a execução dos comandos de uma procedure, a seqüência do programa retorna
sempre à instrução seguinte que provocou a sua chamada.
A pocedure deve ser implementada antes da rotina principal do programa.
Desafio: elaborar um programa que faça desenhos com forma de quadrado ou retângulo
através de duas procedures.
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
19
Um posto está vendendo combustíveis com a seguinte tabela de descontos:
Álcool:
• até 20 litros, desconto de 3% por litro
• acima de 20 litros, desconto de 4% por litro
Gasolina:
• até 30 litros, desconto de 4% por litro
• acima de 30 litros, desconto de 5% por litro.
Diesel:
• somente acima de 50 litros, desconto de 6% por litro.
Escreva um algoritmo que leia o número de litros vendidos, o tipo de combustível
(codificado da seguinte forma: A-álcool, G-gasolina, D-diesel), calcule e mostre o valor a ser pago
pelo cliente sabendo-se que o preço do litro da gasolina é R$ 2,50 o preço do litro do álcool é R$
1,90 e o diesel é R$ 1,85. Mostrar o valor do desconto oferecido.
6 Variáveis Compostas Heterogêneas – Registros
Pode-se inserir informações de tipos diferentes em vetores, como exemplo, código, nome,
cidade, idade, etc, através de registros.
Os registros são conjuntos de dados logicamente relacionados, mas de tipos diferentes
(inteiro, real, literal, ...). Veja o exemplo abaixo:
Temos campos de tipos diferenciados dentro de
um único vetor com 100 posições, ou seja,
pode-se cadastrar 100 pessoas com as
informações de cada campo.
Para inserir a informação no vetor, basta
indicar qual a posição(ponteiro) e o campo no
mesmo.
Para exibir as informações, basta usar o
comando write, posição(ponteiro) do vetor e
qual o campo.
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
20
7 Menu Hierárquico
A maioria dos sistemas possui diversos módulos, clientes, cidades, vendas, produtos e
demais. Para facilitar o gerenciamento, existe um recurso muito utilizado, o Menu Hierárquico, que
consiste em dividir o sistemas em diversas Procedures dentro de uma Procedure Principal e assim
sucessivamente.
Menu Principal
Clientes
Cadastra Clientes
Vendas
Consulta Clientes
Inclui Vendas
Relatórios
Consulta Vendas
Vendas Geral
Comissão/Vendas/Ve
ndedor
Vendas/Produto
Na linguagem Pascal, cada sub módulo (3 nível do organograma), deve ser declarado como uma
procedure. Em seguida os Sub Menus que chamam as procedures e por final o Menu Principal. Ou
seja, na linguagem será como o organograma invertido, Procedure + Sub Menus + Menu Principal.
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
21
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
8 Variáveis Compostas Heterogêneas
arquivos (c:\cadastro.txt)
–
Registros
22
em
As operações básicas realizadas sobre um arquivo são abertura, leitura, escrita e fechamento.
A abertura de arquivos corresponde à ação de se associar o arquivo declarado no programa
com o arquivo físico(c:\cadastro.txt).
• O primeiro passo é associar as informações digitadas na tela a um arquivo (txt) a ser
gravado no computador: assign(arquivo, 'C:\ARQTXT.TXT');
• Para ler o conteúdo de um arquivo, usa-se o comando: reset(arquivo); Este comando
lê as informações do arquivo físico e as coloca na memória do sistema.
• Para exibir o conteúdo do arquivo, usa-se o comando: readln(arquivo, mensagem);
sendo que mensagem é um campo texto do arquivo.
• Para incluir o conteúdo da memória para o arquivo, usa-se o comando:
writeln(arquivo, mensagem);
Resumindo:
Cria a variável arquivo:text;
Cria
a
variável
mensagem:string[50];
O comando append inclui o
conteúdo da variável mensagem ao
arquivo físico.
Após manipular o arquivo, deve-se
fechar o mesmo com o comando
close(arquivo);
O comando reset pega as
informações do arquivo físico e traz
para a memória.
while not eof(arquivo) percorre
todos os registros do arquivo.
Após manipular o arquivo, deve-se
fechar o mesmo com o comando
close(arquivo);
IFSC – Chapecó – Algoritmos II (Linguagem Pascal)
23
Algoritmos II – Lista de exercícios
Faça um algoritmo que leia um vetor com 15 posições. Os números são de 1 a 5. Mostrar
quantas ocorrências crescentes e decrescentes aconteceram no vetor. Ex 1-3-4-2-3-3-5-4-5
1
2
4
3
2
3
4
1
1
5
4
1
3
5
5
Crescentes=7
Decrescentes=5
Iguais=2
Matriz
Criar duas matrizes A e B com tamanho 4x4. Inserir valores de 1 a 4. Mostrar quantos
valores estão na mesma posição em ambas as matrizes.
Preço médio
O preço médio é um recurso muito utilizado nos sistemas de gerenciamento de estoque para
saber se uma compra está sendo executada dentro do valor aceitável. Ele é calculado através da
seguinte fórmula:
Produto
Qtdade
Custo
Total
Custo Médio
Limite aceitável
Geladeira
10
% limite
15
R$ 1.000,00
R$ 10.000,00
R$ 1.000,00
R$
1.100,00
R$
R$ 13.500,00
R$
940,00
R$
1.034,00
10%
5
R$ 1.200,00
R$
R$
983,33
R$
1.081,67
900,00
6.000,00
=SOMA(D2:D4)/SOMA(B2:B4)
Com base nesta informação, elabore um algoritmo que avise quando o custo de uma compra
for maior que 10% do custo médio. Use registros para facilitar o algoritmo.