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.