Download - Linguagem Pascal
Linguagem Pascal: Comandos Básicos
Tipos de Dados
Numéricos
o Inteiro é Integer
o Real é Real
Literais
o Literal[N] é String[N]
Lógico
o Lógico (valores Verdadeiro e Falso) é boolean (valores True e False)
Variáveis
Seção var
Exemplo:
var
Contador: integer;
Preco: real;
Nome: string[30];
Termino: boolean;
Instruções Primitivas
Atribuição := (exemplo: Contador := 1)
Saída: writeln ('O preço é:', Preço);
Entrada: readln(Preco, Nome);
SE
if <condição> then
<comando1>
else
<comando2>;
CASO
case <expressão> of
<R1>: <comando1>;
<R2>: <comando2>;
...
else
<comandos>
end;
PARA
for <contador> := <Inicio> to <Fim> do
<comando>;
ENQUANTO
while <condição> do
<comando>;
REPITA
repeat
<comandos>
until <condição>
Outros
algoritmo é program
início é begin
fim é end
Exemplos
program Fatorial;
var
Res, Num : integer;
begin
Res := 1;
readln(Num);
while Num > 1 do
begin
Res := Res * Num;
Num := Num - 1
end;
writeln(Res)
end.
program PG;
var
Contador, Termo, Soma : integer;
begin
Contador := 1;
Termo := 3; writeln(Termo);
Soma := 3;
repeat
Termo := Termo * 3;
Soma := Soma + Termo;
Contador := Contador + 1;
writeln(Termo);
until Contador = 20;
writeln(Soma);
end.
Exercícios
Implemente os programas referentes às questões:
37) Q21 - básico.
38) Q22 - caso.
39) Q26 - para.
40) Q30 - enquanto.
41) Q32 - repita
42) Q33 - repita
43) Q35 - repita
Tipos Definidos pelo Usuário
Introdução
Além dos tipos de dados simples estudados no capítulo II, na composição das soluções algorítmicas podemos fazer uso de tipos definidos pelo usuário. São eles:
o Tipo Registro o Tipo Vetor o Tipo Arquivo
Estes são definidos na seção tipo (algoritmo) ou type (Pascal). São úteis à definição dos conteúdos de composição dos dados manipulados pelos algoritmos.
Tipo Registro
Diferente dos demais tipos de dados, possibilitam o armazenamento de valores de diversos tipos (heterogêneo).
Estrutura em algoritmo:
tipo
<registro> = registro
<campo1>: <tipo1>;
<campo2>: <tipo2>;
...
<campoN>: <tipoN>;
fim;
Estrutura em Pascal:
type
<registro> = record
<campo1>: <tipo1>;
<campo2>: <tipo2>;
...
<campoN>: <tipoN>;
end;
Exemplo 1 (definição de um tipo que representa um aluno):
type
TipoAluno = record
Nome: string[30];
Matricula: string[8];
Media: real;
Frequencia: integer;
end;
var
Aluno: TipoAluno;
Exemplo 2 (definição de um tipo que representa um professor):
type
TipoProfessor = record
Nome: string[30];
Codigo: string[8];
Salario: real;
Ingresso: string[8];
end;
var
Prof: TipoProfessor;
Cada elemento de composição de um registro é chamado campo. Os campos do registro TipoProfessor, por exemplo, são: nome, código, salário e ingresso.
Para fazer referência aos comandos de um registro deve ser usado: <registro.campo>. Exemplo:
program RelTurma;
type
TipoAluno = record
Nome: string[30];
Matricula: string[8];
Media: real;
Frequencia: integer;
end;
var
Aluno: TipoAluno;
Aprovados,
Reprovados : integer;
begin
Aprovados := 0;
Reprovados := 0;
write('Nome:'); readln(Aluno.Nome);
while Aluno.Nome <> 'fim' do
begin
write('Matricula:'); readln(Aluno.Matricula);
write('Media:'); readln(Aluno.Media);
write('Frequencia:'); readln(Aluno.Frequencia);
if (Aluno.Media >= 7) and (Aluno.Frequencia >= 60) then
Aprovados := Aprovados + 1
else
Reprovados := Reprovados + 1;
write('Nome:'); readln(Aluno.Nome);
end;
writeln('Total de Aprovados:', Aprovados);
writeln('Total de Reprovados:', Reprovados);
end.
Exercícios
44) Escreva um programa para ler os dados dos professores de um curso, a saber: nome,
código, salário e ingresso. Exibir o número de professores com salário acima de R$
500,00 e com ingresso após 01/01/2000.
45) Ajuste o algoritmo RelTurma de forma que: seja exibido o número de aprovados,
reprovados por média, reprovados por falta e o cálculo da média da turma.
46) Escrever um programa para ler os dados dos atletas de um clube (nome, idade, sexo,
altura e peso) e determinar o número de atletas (1) do sexo masculino com peso inferior
a 80, (2) com mais de 25 anos com altura superior a 1,75 e (3) com altura entre 1,60 e
1,75 ou com peso superior a 55.
47) A firma de entrega de encomendas deseja identificar: (1) o maior nº de entregas
efetuadas por um funcionário num dia de trabalho e (2) o menor tempo, em horas gasto
por um funcionário para efetuar as entregas num dia de trabalho Para tanto, foi
encomendado um algoritmo que lê (diariamente): o código do funcionário, o número de
entregas efetuadas por este (funcionário) e o tempo gasto por este (funcionário) para
efetuar as entregas.
48) Implementar programa correspondente à questão 45.
Tipo Vetor e Matriz
Os vetores e matrizes constituem o segundo tipo de dado definido pelo usuário. Estes apresentam a capacidade de armazenar coleções (homogêneas) de dados. Vetor
100 4 20 33 51
Matriz
'A1' 'A2' 'A3'
'B1' 'B2' 'B3'
'C1' 'C2' 'C3'
Estrutura Tipo Vetor type
<ident> = array [1..N] of <Tipo>;
Onde: o <Ident> identifica o tipo vetor
o N determina o máximo de elementos componentes do vetor o <tipo> tipo dos elementos do vetor
Exemplo:
type
TipoVetor = array [1..10] of integer;
var
Vetor: TipoVetor;
Neste, Vetor é uma variável com capacidade para armazenar até 10 números inteiros.
Estrutura Tipo Matriz type
<ident> = array [1..L, 1..C] of <Tipo>;
Onde: o <Ident> identifica o tipo matriz o L determina o máximo de linhas o C determina o máximo de colunas o <tipo> tipo dos elementos da matrizr
Exemplo:
type
TipoMatriz = array [1..5, 1..12] of real;
{ Balanço anual de vendas de uma rede de lojas: 5 unidades x 12
meses }
var
Matriz: TipoMatriz;
Matriz com capacidade para armazenar até 60 valores (5x12) reais. Para fazer referência aos elementos de um vetor ou matriz, fazemos uso dos índices,
como segue: o Vetor[7] := 43; o sétimo elemento do vetor é 43. o writeln(Vetor[2]); escreva o segundo elemento.
o readln(Vetor[6]); leia o sexto elemento. o Matriz[3,10] := 850,75; a terceira linha (loja 3) da décima coluna
(mês de outubro) teve um faturamento de R$ 850,75. Exemplo 1: programa para ler N valores, calcular a média destes e determinar quais
dos números lidos são maiores que a média.
program MaiorQueMedia;
type
TipoVetor = array [1..100] of real;
var
Vetor: TipoVetor;
N, I: integer;
Soma,
Media: real;
begin
Soma := 0;
write('N:'); readln(N);
for I := 1 to N do
begin
write('Vetor[', I, ']:'); readln(Vetor[I]);
Soma := Soma + Vetor[I];
end;
Media := Soma / N;
for I := 1 to N do
if Vetor[I] > Media then
writeln(Vetor[I]);
end.
Exemplo 2: programa para ler N palavras, armazenar em um vetor, ordenar no vetor e imprimir.
program OrdenaPalavras;
type
TipoVetor = array [1..30] of string[20];
var
Vetor : TipoVetor;
I, N,
Menor,
Ordenadas : integer;
Temp : string[20];
begin
write('N:'); readln(N);
for I := 1 to N do
readln(Vetor[I]);
Ordenadas := 0;
repeat
inc(Ordenadas); { equivale a Ordenadas := Ordenadas + 1; }
Menor := Ordenadas;
for I := Ordenadas + 1 to N do
if (Vetor[I] < Vetor[Menor]) then
Menor := I;
Temp := Vetor[Ordenadas];
Vetor[Ordenadas] := Vetor[Menor];
Vetor[Menor] := Temp;
until Ordenadas = N;
for I := 1 to N do
writeln(Vetor[I]);
end.
Exemplo 3: programa para criar as seguintes estruturas.
Arenoso Cimento Bloco Telha Tijolo ... Vetor Produtos
SE 200 80 250 300 20
SP 20 150 700 500 5
RJ 150 70 180 900 500
...
Vetor
Lojas Matriz
Estoque
E definir:
a) estoque de um dado produto numa dada loja.
b) estoque de um dado produto.
c) estoque de uma dada loja.
d) loja em que um dado produto apresenta menor estoque.
e) produto com menor estoque em uma dada loja.
program RedeLojas;
type
VetorProdutos = array[1..5] of string[10];
VetorLojas = array[1..3] of string[2];
MatrizEstoque = array[1..3, 1..5] of integer;
var
Produtos: VetorProdutos;
Lojas: VetorLojas;
Estoque: MatrizEstoque;
Produto: string[10];
Loja: string[2];
Quant, P,
L, I, J: integer;
begin
{ Leitura dos produtos }
writeln('Digite os 5 produtos');
for I := 1 to 5 do
readln(Produtos[I]);
{ Leitura das lojas }
writeln('Digite as 3 lojas');
for I := 1 to 3 do
readln(Lojas[I]);
{ Leitura do estoque por loja }
writeln('Digite o estoque dos produtos por loja');
for I := 1 to 3 do
for J := 1 to 5 do
readln(Estoque[I,J]);
{ Item A - estoque de um dado produto numa dada loja }
write('Digite o produto:'); readln(Produto);
for I := 1 to 5 do
if Produtos[I] = Produto then
P := I;
write('Digite a loja:'); readln(Loja);
for J := 1 to 3 do
if Lojas[J] = Loja then
L := J;
writeln('Estoque do produto ', Produto, ' na loja ', Loja, ':',
Estoque[L,P]);
{ Item B - estoque de um dado produto }
write('Digite o produto:'); readln(Produto);
for I := 1 to 5 do
if Produtos[I] = Produto then
P := I;
Quant := 0;
for J := 1 to 3 do
Quant := Quant + Estoque[J,P];
writeln('Estoque do produto ', Produto, ':', Quant);
{ Item C - estoque de uma dada loja }
write('Digite a loja:'); readln(Loja);
for J := 1 to 3 do
if Lojas[J] = Loja then
L := J;
Quant := 0;
for I := 1 to 5 do
Quant := Quant + Estoque[L,I];
writeln('Estoque da loja ', Loja, ':', Quant);
{ Item D - loja em que um dado produto apresenta menor estoque }
write('Digite o produto:'); readln(Produto);
for I := 1 to 5 do
if Produtos[I] = Produto then
P := I;
Quant := Estoque[1,P];
L := 1;
for J := 2 to 3 do
if Estoque[J,P] < Quant then
begin
Quant := Estoque[J,P];
L := J;
end;
writeln('Loja ', Lojas[L], ' tem o menor estoque (', Quant,
') do produto ', Produto);
{ Item E - produto com menor estoque em uma dada loja }
write('Digite a loja:'); readln(Loja);
for J := 1 to 3 do
if Lojas[J] = Loja then
L := J;
Quant := Estoque[L,1];
P := 1;
for I := 2 to 5 do
if Estoque[L,I] < Quant then
begin
Quant := Estoque[L,I];
P := I;
end;
writeln('O produto ', Produtos[P], ' tem o menor estoque na loja ',
Loja);
end.
Exercícios
49) Implementar um programa para ordenar números.
50) Implementar programa para ler nome e média dos alunos de uma turma e escrever a
relação de estudantes com média superior ou igual à media da turma.
51) Implementar programa para criar as seguintes estruturas:
Prova Seminário Exercícios Projeto Vetor Avaliação
Filosofia 10 9 9 8
Psicologia 8 8 7 9
Economia 10 10 5 2
Administração 2 1 10 8
História 6 6 9 4
Vetor
Disciplinas Matriz
Notas
E determinar:
a) a média em uma dada disciplina
b) a média em uma dada modalidade de avaliação
c) a média do aluno
d) a disciplina em que o aluno obteve maior nota em uma dada modalidade de avaliação
Turbo Pascal: Instruções de Uso
Introdução
O Turbo Pascal 7 é um ambiente integrado de desenvolvimento (IDE), que
permite editar, compilar e executar programas escritos na linguagem Pascal.
A compilação é o processo pelo qual o programa escrito em linguagem de alto
nível (Pascal) é convertido em um programa executável (EXE) que contém
instruções apropriadas para o computador.
Existem outras IDE's e compiladores para o Pascal, mas esse será adotado no
nosso curso.
Em um ambiente integrado de desenvolvimento é mais fácil programar, pois
podemos editar, compilar e executar programas em um ambiente que
proporciona um conjunto de facilidades.
Instalação
Criar um diretório chamado TP7 no diretório raiz. (C:\TP7)
o Se tiver baixado o arquivo compactado TP7.zip, descompacte e coloque
os arquivos (TURBO.EXE, (2) TURBO.ICO, (3) TURBO.TPH e (4)
TURBO.TPL) no diretório C:\TP7.
o Caso contrário, copie os arquivos (1) TURBO.EXE, (2) TURBO.ICO,
(3) TURBO.TPH e (4) TURBO.TPL para o diretório C:\TP7.
O Turbo Pascal 7 é um ambiente integrado de desenvolvimento (IDE), que
permite editar, compilar e executar programas escritos na linguagem Pascal.
Para facilitar o uso do TP7, pode-se criar um atalho para o arquivo
TURBO.EXE e colocá-lo na área de trabalho, menu ou barra de tarefas.
Principais Comandos
Menu File
o New => Cria um novo arquivo PAS. Deve-se informar o nome e
diretório para o arquivo.
o Open => Abre um arquivo PAS existente. Deve-se informar o nome e
diretório do arquivo.
o Save => Salva o arquivo que está sendo editado.
o Save as => Salva o arquivo que está sendo editado com um
nome/diretório diferente.
o Save all => Salva todos os arquivos que estão sendo editados.
o Change dir => Muda o diretório corrente. O padrão é o diretório de
instalação do TP7.
o Print => Imprime o arquivo sendo editado.
o Printer setup => Configuração de impressão.
o Dos shell => Executa o prompt do MS-DOS. Para voltar ao TP7, execute
EXIT.
o Exit => Sai do TP7.
Menu Edit
o Undo => Desfaz um comando.
o Redo => Refaz um comando que foi desfeito.
o Cut => Corta a parte do programa selecionado, colocando-a na área de
transferência.
o Copy => Copia a parte do programa selecionado, colocando-a na área de
transferência.
o Paste => Cola o conteúdo da área de transferência.
o Clear => Limpa a parte do programa selecionado.
o Show clipboard => Exibe o conteúdo da área de transferência
Menu Search
o Find => Busca por um conjunto de caracteres qualquer no programa.
o Replace => Substitui um conjunto de caracteres no programa por outro.
o Search again => Executa a busca até a próxima ocorrência do conjunto
de caracteres no programa.
o Go to line number => Move o cursor para a linha especificada.
Menu Run
o Run => Executa o programa corrente. Após a execução, volta ao editor.
Menu Compile
o Compile => Compila o arquivo atual
o Make => Compila o arquivo atual e todos os dependentes modificados
o Build => Compila o arquivo atual e todos os dependentes (mesmo sem
terem sido modificados)
o Destination => Pode indicar Memory ou Disk. O último grava um
arquivo (EXE) que pode ser executado fora do ambiente do TP7.
Menu Options
o Open => Abre um arquivo de configuração da IDE.
o Save => Salva a configuração do IDE.
o Save as => Salva a configuração do IDE, dando-lhe um nome e
diretório.
Menu Window
o Tile => Divide a tela em janelas para permitir visualização de mais de
um programa ao mesmo tempo.
o Cascade => Arruma as janelas em cascata, permitindo ver apenas o
nome do programa e o conteúdo do que que está na janela da frente.
o Close all => Fecha todas as janelas.
o Size/Move => Permite dimensionar e mover janelas.
o Zoom => Faz com que a janela atual ocupe toda a tela disponível.
o Next => Passa da janela atual para a seguinte.
o Previous => Volta para a janela anterior.
o Close => Fecha a janela atual.
o List => Exibe uma lista das janelas abertas (cada uma com um
programa).
Menu Help
o Contents => Mostra o conteúdo da ajuda.
o Index => Permite procurar comandos através do nome.
Modularização
Introdução
Modularizar consiste no processo de resolução de problemas a partir da divisão
desses em subproblemas.
Um programa pode ser particionado em módulos ou rotinas. As rotinas juntas
constituem a resolução computacional para um dado problema.
Uma rotina consiste num bloco de comandos, com a mesma estrutura de um
programa, que pode ser executado zero, uma ou mais vezes.
Há dois tipos principais de rotinas: procedimentos (procedures) e funções
(functions)
Procedure
Estrutura
procedure <Ident>;
<declarações>
begin
<comandos>
end;
Onde:
o <Ident> nome que identifica o procedimento.
o <declarações> declarações de tipos, constantes, variáveis e de outros
procedimentos ou funções.
o <comandos> comandos que pertencem ao procedimento.
Para promover a execução de um procedimento, o identificador deste deve
constar (como outro comando qualquer) no código principal do programa ou em
outra rotina.
As variáveis definidas no procedimento são chamadas de locais. Estas somente
existem durante a execução do procedimento.
As variáveis declaradas no programa são denominadas globais, existindo
enquanto durar a execução do programa.
Exemplo: retomando o exemplo anterior de controle de estoque de uma rede de
lojas:
program RedeLojas;
type
VetorProdutos = array[1..5] of string[10];
VetorLojas = array[1..3] of string[2];
MatrizEstoque = array[1..3, 1..5] of integer;
var
Produtos: VetorProdutos;
Lojas : VetorLojas;
Estoque : MatrizEstoque;
Opcao : integer;
(*********************************************)
procedure LerDados;
var
I, J : integer;
begin
{ Leitura dos produtos }
writeln('Digite os 5 produtos');
for I := 1 to 5 do
readln(Produtos[I]);
{ Leitura das lojas }
writeln('Digite as 3 lojas');
for I := 1 to 3 do
readln(Lojas[I]);
{ Leitura do estoque por loja }
writeln('Digite o estoque dos produtos por loja');
for I := 1 to 3 do
for J := 1 to 5 do
readln(Estoque[I,J]);
end;
(*********************************************)
{ (1) estoque de um dado produto numa dada loja }
procedure EstoqueProdutoLoja;
var
Produto : string[10];
Loja : string[2];
P, L, I, J: integer;
begin
write('Digite o produto:'); readln(Produto);
for I := 1 to 5 do
if Produtos[I] = Produto then
P := I;
write('Digite a loja:'); readln(Loja);
for J := 1 to 3 do
if Lojas[J] = Loja then
L := J;
writeln('Estoque do produto ', Produto, ' na loja ', Loja, ':',
Estoque[L,P]);
end;
(*********************************************)
{ (2) estoque de um dado produto }
procedure EstoqueProduto;
var
Produto : string[10];
Quant,
P, L, I, J: integer;
begin
write('Digite o produto:'); readln(Produto);
for I := 1 to 5 do
if Produtos[I] = Produto then
P := I;
Quant := 0;
for J := 1 to 3 do
Quant := Quant + Estoque[J,P];
writeln('Estoque do produto ', Produto, ':', Quant);
end;
(*********************************************)
{ (3) estoque de uma dada loja }
procedure EstoqueLoja;
var
Loja : string[2];
Quant,
L, I, J: integer;
begin
write('Digite a loja:'); readln(Loja);
for J := 1 to 3 do
if Lojas[J] = Loja then
L := J;
Quant := 0;
for I := 1 to 5 do
Quant := Quant + Estoque[L,I];
writeln('Estoque da loja ', Loja, ':', Quant);
end;
(*********************************************)
{ (4) loja em que um dado produto apresenta menor estoque }
procedure MenorEstoqueProduto;
var
Produto : string[10];
Quant,
P, L, I, J: integer;
begin
write('Digite o produto:'); readln(Produto);
for I := 1 to 5 do
if Produtos[I] = Produto then
P := I;
Quant := Estoque[1,P];
L := 1;
for J := 2 to 3 do
if Estoque[J,P] < Quant then
begin
Quant := Estoque[J,P];
L := J;
end;
writeln('Loja ', Lojas[L], ' tem o menor estoque (', Quant,
') do produto ', Produto);
end;
(*********************************************)
procedure MenorEstoqueLoja;
{ (5) produto com menor estoque em uma dada loja }
var
Loja : string[2];
Quant,
P, L, I, J: integer;
begin
write('Digite a loja:'); readln(Loja);
for J := 1 to 3 do
if Lojas[J] = Loja then
L := J;
Quant := Estoque[L,1];
P := 1;
for I := 2 to 5 do
if Estoque[L,I] < Quant then
begin
Quant := Estoque[L,I];
P := I;
end;
writeln('O produto ', Produtos[P], ' tem o menor estoque na loja ',
Loja);
end;
BEGIN
LerDados;
repeat
writeln('1 - Estoque de Produto em Loja');
writeln('2 - Estoque de Produto');
writeln('3 - Estoque em Loja');
writeln('4 - Menor Estoque de Produto');
writeln('5 - Menor Estoque em Loja');
writeln('6 - Sair');
readln(Opcao);
case Opcao of
1: EstoqueProdutoLoja;
2: EstoqueProduto;
3: EstoqueLoja;
4: MenorEstoqueProduto;
5: MenorEstoqueLoja;
end;
until Opcao = 6;
END.
Exercício
52) Modularizar o programa implementado em resposta à questão 51.
Function
Estrutura
function <Ident> : <Tipo>;
<declarações>
begin
<comandos>
end;
Onde:
o <Ident> nome que identifica a função.
o <Tipo> tipo do dado de retorno.
o <declarações> declarações de tipos, constantes, variáveis e de outros
procedimentos ou funções.
o <comandos> comandos que pertencem ao procedimento.
As funções diferem dos procedimentos porque devem ser usadas em atribuições.
Exemplo: função que, dado um produto, retorna o índice desse em Produtos.
function DefineProduto (Produto : string) : integer;
var
I : integer;
begin
for I:= 1 to 5 do
if Produtos[I] = Produto then
DefineProduto := I;
end;
O funcionamento e aplicação de funções é bastante similar aos procedimentos.
Definida a função acima, o procedimento EstoqueProduto passaria a ser:
procedure EstoqueProduto;
var
Produto : string[10];
J, P, Quant : integer;
begin
readln(Produto);
P := DefineProduto(Produto);
Quant := 0;
for J := 1 to 3 do
Quant := Quant + Estoque[J,P];
writeln(Quant);
end;
Exercício
53) Implementar função que, dada uma loja, retorna o índice dessa e reescreva o
procedimento EstoqueLoja.