Upload
nguyenkiet
View
214
Download
0
Embed Size (px)
Citation preview
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 2
Índice Analítico
1. INTRODUÇÃO ...................................................................................................................... 3
2. ALGORÍTMOS ...................................................................................................................... 4
3. FLUXOGRAMAS ................................................................................................................... 6
4. LINGUAGEM PASCAL ........................................................................................................... 8
5. ESTRUTURAS DE DECISÃO ................................................................................................ 15
5.1 IF THEN ......................................................................................................................................................... 15 5.2 IF ... THEN ... ELSE .......................................................................................................................................... 17
6. ESTRUTURAS DE REPETIÇÃO ............................................................................................ 21
6.1 FOR TO DO ................................................................................................................................................. 21 6.2 WHILE ... DO ................................................................................................................................................... 26 6.3 REPEAT ... UNTIL ........................................................................................................................................... 32
7. ARRAYS (VETORES E MATRIZES) ....................................................................................... 38
7.1 VETORES ............................................................................................................................................................ 39 7.2 MATRIZES .......................................................................................................................................................... 49
8. EXERCÍCIOS ...................................................................................................................... 52
8.1.1 Exercício 1 – Método de Gauss ................................................................................................................. 52 8.1.2 Exercício 2 – Método de Jacobi ................................................................................................................ 54 8.1.3 Exercício 3 – Método de Gauss-Seidel ...................................................................................................... 56
9. OPERAÇÕES COM ARQUIVOS ............................................................................................ 58
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 3
Lógica de Programação
1. Introdução
Algorítmo
Algorítmo é uma descrição sistemática, finita e ordenada dos passos necessários a resolução de um problema ou grupo de problemas semelhantes. São regras formais para obtenção de um resultado ou da solução de um problema, englobando fórmula de expressões aritméticas.
Fluxograma
Fluxograma, também conhecido como Diagrama, é descrição da sequência de operações a se efetuar em um programa.
Usa símbolos convencionais representados por desenhos geométricos básicos, que indicam a entrada, o processamento e a saída de dados.
Permite que posteriormente seja feita uma codificação em qualquer linguagem de programação de computadores, pois o fluxograma não atinge um detalhamento de instruções ou comandos específicos
Estrutura de um Programa Pascal
A linguagem Pascal foi desenvolvida no início dos anos com o objetivo do ensino da programação estruturada. Por se tratar de uma linguagem bem mais simples que as demais linguagens científicas, é ideal para o ensino da programação estruturada.
Todo programa em Pascal possui três áreas distintas:
Cabeçalho
Área de Declarações
Corpo do Programa
Abaixo temos um programa extremamente simples em Pascal que recebe dois números, calcula a média e a mostra na tela.
As linhas 1 a 3 constituem o Cabeçalho.
As linhas 4 e 5 constituem a Área de Declarações.
As linhas 6 a 15 constituem o Corpo do Programa.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 4
2. Algorítmos
Monte um algorítmo com a sequência de ações para fazer uma vitamina com mamão, uma banana, uma maçã, com leite e açúcar.
Preencha os campos de 1 a 14 com a ordenação adequada.
Preparar o mamão;
Colocar 2 colheres de açúcar no liquidificador;
Fim;
Despejar o conteúdo do liquidificador em uma jarra;
Preparar a banana;
Pegar o liquidificador;
Preparar a maçã;
Início;
Ligar o liquidificador;
Colocar as frutas no liquidificador;
Colocar um copo de leite no liquidificador;
Tampar o liquificador
Desligar o liquidificador;
Esperar 30 segundos;
Monte um algorítmo com a sequência de ações para fazer uma ligação telefônica.
Preencha os campos de 1 a 10 com a ordenação adequada.
Senão;
Tirar o telefone do gancho;
Inicia a conversa;
Início;
Espera atender;
Fim;
Tentar de novo;
Ouvir sinal de linha;
Se der sinal de chamar;
Teclar número desejado;
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 5
Monte um algorítmo com a sequência de ações para ler dois números inteiros, fazer a soma e escrever o resultado na tela.
Preencha os campos de 1 a 8 com a ordenação adequada.
Aguardar a ordem para digitar o segundo número;
Escreve o resultado na tela;
Início;
Digitar o segundo número;
Fim;
Aguardar a ordem para digitar o primeiro número;
Somar os dois números;
Digitar o primeiro número;
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 6
3. Fluxogramas
Terminal: Ponto de início e término do fluxo.
Entrada de dados (manual): Corresponde a instrução de entrada de dados (via teclado)
Entrada de dados: Corresponde a instrução de entrada de dados (leitura e gravação de arquivo)
Saída de dados: Corresponde a instrução de saída de dados e mensagens (via impressora).
Saída de dados: Corresponde a instrução de saída de dados e mensagens (via monitor).
Mensagem para o Usuário: Corresponde a informação que aparece na tela para o usuário.
Atribuição: Utilizado para indicar cálculos e atribuição de valores às variáveis.
Desvio condicional: Divide o fluxograma em dois segmentos, de acordo com o teste lógico contido no losango. Obrigatoriamente deve haver uma entrada e duas saídas que serão conhecidas por (SIM) e (NÃO), ou (VERDADEIRO) e (FALSO).
Faça enquanto: Executa uma sequência de instruções enquanto uma condição estabelecida seja obedecida.
Seta de fluxo: Indica o sentido do fluxo de execução do algoritmo. Também conecta os símbolos do fluxograma.
Conector: Indica uma ligação ou conexão entre pontos distantes de um algoritmo. Utilizado principalmente em algoritmos longos que requerem mais de uma página.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 7
Crie um fluxograma para ler dois números inteiros, fazer a soma e escrever o resultado na tela.
INÍCIO
SOMA = N1+N2
FIM
IMPRIME SOMA
DIGITE N1
DIGITE N2
N1
N2
Mensagem na tela
Aguarda digitação
Efetua cálculos
Relatório
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 8
4. Linguagem Pascal
Quando abrimos um novo programa Pascal é mostrada a tela abaixo, onde as instruções são digitadas.
Conforme visto anteriormente, todo programa Pascal possui três áreas distintas:
Cabeçalho
Área de Declarações
Corpo do Programa
Objetivo:
Criar o programa para ler dois números inteiros, fazer a soma e escrever o resultado na tela, conforme fluxograma construído no item anterior.
Cabeçalho
Linha 1: Trocamos o nome genérico (Pzim) pelo nome do nosso programa (Soma_2Num).
Linha 2: Na linhas 2 e 3 colocamos entre chaves um texto com a descrição do programa. Estas duas linhas não são entendidas como instruções de programação e nenhuma ação é executada.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 9
Área de Declarações
Linha 5: A instrução CONST informa que as constante serão definidas abaixo, nas linhas seguintes, até encontrar a instrução VAR, na linha 9.
Linha 9: A instrução VAR informa que variáveis serão definidas abaixo, nas linhas 10 a 14
Corpo do Programa
Acima temos o corpo de um programa, limitado por Begin End.
Uma vez executado, ficará conforme figura abaixo.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 10
Linha 8: A instrução Writeln escreve na tela o texto que está entre ‘ ‘ e pula para a linha
seguinte.
Linha 9: A instrução Readln aguarda que o usuário digite a valor que será atribuído à variável N1. Uma vez digitado e dado Enter, pula para a próxima linha.
Linha 10: A instrução Writeln escreve na tela o texto que está entre ‘ ‘ e pula para a linha seguinte. Uma vez digitado e dado Enter, pula para a próxima linha.
Linha 11: A instrução Readln aguarda que o usuário digite a valor que será atribuído à variável N2.
Linha 2 É criada a variável Soma e nela é armazenado o valor N1+N2.
Linha 8: A instrução Write escreve na tela o texto que está entre ‘ ‘ e permanece na
mesma linha, de forma que a próxima instrução será escrita a seguir.
Linha 14: A instrução Writeln escreve na tela valor da variável Soma e pula para a linha seguinte.
No nosso primeiro programa acima usamos os nomes N1 e N2 para identificar os números e Soma para identificar a soma deles.
Em Pascal, a escolha destes nomes ou identificadores tem que seguir algumas regras, conforme abaixo:
Iniciar com uma letra (A a Z) ou com underline ( _ )
O restante do nome só pode conter letras, números ( 0 a 9 ) ou underline
( _ )
A quantidade de caracteres tem que ser <= 63
Não existe diferença entre maiúsculas e minúsculas.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 11
Objetivo:
Criar o programa para ler dois números, calcular a média e escrever o resultado na tela.
INÍCIO
MED=(N1+N2)/2
FIM
IMPRIME SOMA
DIGITE N1
DIGITE N2
N1
N2
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 12
Objetivo:
Criar o programa para ler o raio de um círculo, calcular a área e o perímetro e escrever o resultado na tela.
INÍCIO
COMP = 2*PI*RAIO
AREA = PI*sqr(RAIO)
FIM
IMPRIME COMPIMPRIME AREA
DIGITE O RAIO
RAIO
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 13
Linha 3: A instrução CONST define PI é uma constante
Linha 6: A instrução VAR define AREA, COM e RAIO são variáveis reais
Linha 12: Calcula a área do círculo. A Instrução sqr(RAIO) equivale a RAIO2
Linha 13: Calcula o perímetro do círculo.
Objetivo:
Criar o programa para:
a) ler um nome e um número
b) Multiplicar o número por um fator FAT
c) Escrever, na mesma linha, o nome e o produto
Linha 7: Definimos nome como string (caracter).
Linha 17: Escrevemos na mesma linha o nome, --> e o produto, separados por vírgula.
INÍCIO
NUM1 = NUM * FAT
FIM
IMPRIME NUM1
DIGITE O NÚMERO
NUM
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 14
Objetivo:
Criar o programa para calcular as raízes da equação abaixo e escrever o resultado na tela.
Program Calc_Raizes ;
{Criar o programa para calcular as raízes de uma equação
do segundo grau e escrever o resultado na tela}
CONST
a=2; b=2; c=-4;
VAR
x1, x2: Real;
Begin
x1:= (-b+sqrt(sqr(b)-4*a*c))/(2*a);
Write ('Raiz 1: ');
Writeln (x1);
Writeln;
x2:= (-b-sqrt(sqr(b)-4*a*c))/(2*a);
Write ('Raiz 2: ');
Writeln (x2);
End.
Obs:
a) sqr(b):
b) sqrt(b):
2 X2
2 X 4 0
2 b
2b
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 15
5. Estruturas de Decisão
Quando uma ou mais ações dependem de uma ou mais condições são usadas Estruturas de Decisão. Elas desviam o fluxo de execução do programa de acordo com as condições impostas.
5.1 IF THEN
A instrução do Pascal IF <condição> THEN <ação> pode ser interpretada da seguinte forma:
Se <condição> for verdade então execute <ação>.
No fluxograma abaixo temos um programa que recebe duas notas e calcula a média. Este programa contém uma condição:
Se a média for >= 7 então o programa efetua um desvio e imprime Aprovado. Se esta condição não se verificar, segue o fluxo normal.
Objetivo:
Criar o programa, baseado no fluxograma abaixo, para ler duas notas, calcular a média e escrever o resultado na tela. Caso a média>=7,0 deverá enviar a informação “Aprovado”.
INÍCIO
MED = (N1+N2)/2
FIM
DIGITE N1 e N2
MED >= 7 ?IMPRIME
APROVADO
S
N
N1, N2
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 16
Program IF_THEN ;
{Criar o programa para ler dois números inteiros,
calcular a media e escrever o resultado na tela}
Var
N1,N2: Integer;
Media: Real;
Begin
Write('Digite o primeiro número: ');
Readln (N1);
Write ('Digite o segundo número: ');
Readln (N2);
Media := (N1+N2)/2;
Write ('A Média é: ');
Writeln (Media);
if Media>=7 then
Begin
writeln ('Aprovado');
End;
End.
Quando há apenas um comando, não necessita
Begin End
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 17
5.2 IF ... THEN ... ELSE
A instrução do Pascal IF <condição> THEN <ação1> ELSE <ação2> pode ser interpretada da seguinte forma:
Se <condição> for verdade então execute <ação1> senão execute <ação2>.
No fluxograma abaixo temos um programa que recebe duas notas e calcula a média. Este programa contém uma condição: Se a média for >= 7 então a Situação é Aprovado. Se esta condição não se verificar, então a Situação é Reprovado.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 18
Objetivo:
Criar o programa, baseado no fluxograma acima, para ler duas notas, calcular a média e escrever o resultado na tela. Se a média>=7,0 então deverá enviar a informação “Aprovado” senão deverá enviar “Reprovado”.
Objetivo:
Criar o fluxograma e o programa para ler o nome, duas notas, calcular a média e a situação, conforme a seguinte regra:
a). Média >= 7,0 Aprovado
b) Média <3,0 Reprovado
c) 3,0 <= Média < 7,0 Prova Final
Imprimir, na mesma linha, o Nome, as duas notas, a média e a situação
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 19
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 20
Aqui vamos usar a formatação dos dados de saída.
Nome:String:15 A variável Nome terá, no máximo, 15
caracteres.
N1:2:1 A variável N1 será impressa com dois caracteres antes
da vírgula e uma casa decimal.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 21
6. Estruturas de Repetição
6.1 FOR TO DO
O instrução FOR <variável := início> TO <fim> DO <comandos> permite a
repetição de um comando tantas vezes quanto especificado nos parâmetros início até
fim.
A sintaxe é:
a) Para um único comando:
For i=n1 to n2 do
comando
b) Para mais de um comando:
For i=n1 to n2 do
begin
comandos
end
Objetivo:
Criar o programa para ler cinco números e imprimi-los.
Program FOR_1_pas;
{Programa para ler 5 números}
Var
I : Integer;
N1 : Real;
Begin
For I:=1 TO 5 do
begin
Write ('Digite o número: ');
Readln (N1);
writeln;
writeln (' - ',N1);
writeln;
end;
End.
INÍCIO
DIGITE N1
FIM
S
N
IMPRIME N1
N1
FOR I=1 TO 5
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 22
Objetivo:
Criar o programa para calcular a soma e a média dos 50 primeiros números naturais.
Objetivo:
Criar o programa para calcular a soma e a média dos 50 primeiros números ímpares.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 23
Objetivo:
Criar o programa para determinar quantos e quais são os números inteiros inferiores a 50 que são divisíveis por 3.
Objetivo:
Dado o programa abaixo, qual o maior valor que TOT pode ter no final do programa ?
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 24
Objetivo:
Criar o programa para determinar os números primos inferiores a um valor dado.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 25
Objetivo:
Criar o programa para:
a) Ler o nome e as duas notas de 5 alunos;
b) Calcular a Média;
c) Calcular a Situação, conforme a regra:
Se a Média >= 7 Aprovado
Se a Média < 3 Reprovado
Se a 3 <= Média <= 7 Prova final
d) Imprimir, na mesma linha, Nome, Notas, Média e Situação
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 26
6.2 WHILE ... DO
O comando WHILE ... DO permite a repetição de um grupo de instruções até que uma condição seja atingida.
A cada repetição é feito teste para verificar se a condição é falsa. Quando for o processo é interrompido.
A sintaxe é:
a) Para um único comando:
While <condição> do
comando
b) Para mais de um comando:
While <condição> do
begin
comandos
end
A principal diferença entre os comandos WHILE .. DO e REPEAT .. UNTIL
é que no WHILE .. DO o teste é feito no início e no REPEAT .. UNTIL é feito no
final.
Desta forma, no WHILE .. DO pode não haver nenhuma repetição enquanto que
no REPEAT .. UNTIL haverá pelo menos uma.
É crucial ficar atento a esta diferença, pois pode ocorrer que o processo requeira o uso de um ou do outro
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 27
Objetivo:
Criar o programa para determinar quantos e quais são os primeiros números naturais (1, 2, 3, etc) cuja soma não ultrapassa 100.
Program WHILE_DO_1_pas;
{Criar o programa para achar os números
naturais cuja soma<100}
Var
I:Integer;
SOMA: Real;
Begin
I:=1;
SOMA:=0;
While SOMA <= 100 do
begin
SOMA:=SOMA+I;
writeln;
writeln (' - ',I,' - ', SOMA:3:0);
I:=I+1;
end;
writeln;
End.
INÍCIO
I = 1SOMA=0
FIM
S
N
IMPRIME I, SOMA
I = I + 1
SOMA=SOMA+I
WHILE SOMA<100
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 28
Objetivo:
Criar o programa para determinar quantos e quais são os primeiros números pares cuja soma não ultrapassa 175.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 29
Objetivo:
Considere um bloco de gelo que, exposto à temperatura ambiente, a cada hora seu volume é reduzido à metade. Desenvolva um programa para calcular quantas horas levará para seu volume atingir 1% do voluma original.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 30
Objetivo:
Desenvolva um programa para executar as tarefas abaixo:
a) ... Ler a Matrícula, o Nome e as duas notas dos alunos de uma turma
Matrícula ........... AA999 (cinco caracteres, sendo os dois primeiros letras e os demais algarismos)
Nome ................. Máximo de 15 caracteres
Notas ................. de 0,0 a 10,0
b) Calcular a Média Aritmética (MED)
c) Calcular a Situação, de acordo com a seguinte regra:
MED >= 7,0 .................. Aprovado
MED < 3,0 ................... Reprovado
3,0 <= MED < 7,0 ......... Prova Final
d) Calcular a quantidade de alunos Aprovados, Reprovados e em Prova Final
e) Imprimir, na mesma linha, a Matrícula, o Nome, as duas notas, a Média e a Situação
f) Ao final imprimir as quantidades de Aprovados, Reprovados e em Prova Final, conforme abaixo:
Alunos Aprovados: ...............XXX
Alunos Reprovados: ..............YYY
Alunos em Prova Final: .........ZZZ
INÍCIO
DIGITE MAT, NOME, N1,
N2
FIM
S
N
MED = (N1+N2)/2
MED >= 7 ?S
N
MAT, NOME, N1,
N2
WHILE NOME<> FIM
SIT= APROVADO
AP=AP+1MED <3 ?
SIT= REPROVADO
RP=RP+1
IMPRIME NOME, N1,N2, MED, SIT
SIT= PROVA FINAL
EF=EF+1
IMPRIME AP, RP, EF
S
N
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 31
Program Pkzin;
VAR
MAT, NOME, SIT: String;
N1, N2, MED: Real;
AP, RP, FIN: Integer;
Begin
While NOME<>'FIM' DO
begin
{Leitura de dados ...................................}
Writeln;
Write ('Degite NOME c/ 15 carac FIM PARA SAIR ---> ');
Readln (NOME);
Write ('Degite MATRÍCULA c/ 5 carac ---> ');
Readln (MAT);
Write ('Degite N1 ---> ');
Readln (N1);
Write ('Degite N2 ---> ');
Readln (N2);
{Fim da leitura de dados ............................}
{Cálculos ...........................................}
MED:=(N1+N2)/2;
If MED >= 7 then
begin
SIT:='Aprovado';
AP:=AP+1;
end
else
If MED <3 then
begin
SIT:='Reprovado';
RP:=RP+1;
end
else
begin
SIT:='Prova Final';
FIN:=FIN+1;
end;
{Relatório ....................................}
Writeln;
Writeln (MAT:5, ' - ', NOME:15,' - ', N1 :2:1,' - ', N2 :2:1,
' - ', MED :2:1,' - ',' - ',SIT);
end;
{Relatório Final...............................}
Writeln;
Writeln;
Writeln ('Aprovados ----->', AP);
Writeln ('Reprovados ---->', RP);
Writeln ('Prova Final --->', FIN);
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 32
6.3 REPEAT ... UNTIL
O comando REPEAT ... UNTIL permite a repetição de um grupo de instruções até que uma condição seja atingida.
A cada repetição é feito teste para verificar se a condição é verdadeira. Quando for o processo é interrompido.
A sintaxe é:
Repeat
<comandos>
Until <condição>
A principal diferença entre os comandos WHILE .. DO e REPEAT .. UNTIL
é que no WHILE .. DO o teste é feito no início e no REPEAT .. UNTIL é feito no
final.
Desta forma, no WHILE .. DO pode não haver nenhuma repetição enquanto que
no REPEAT .. UNTIL haverá pelo menos uma.
Objetivo:
Criar o programa para determinar quantos e quais são os primeiros números naturais (1, 2, 3, etc) cuja soma não ultrapassa 100.
Program REPEAT_UNTIL_1_pas;
{Criar o programa para achar os números
naturais cuja soma<100}
Var
I: Integer;
SOMA: Real;
Begin
I:=1;
SOMA:=0;
Repeat
SOMA:=SOMA+I;
writeln;
writeln (' - ',I,' - ', SOMA);
I:=I+1;
Until(SOMA>100);
End.
INÍCIO
I = 1SOMA=0
FIM
IMPRIME I, SOMA
I = I + 1
SOMA=SOMA+I
UNTIL SOMA>=100
REPEAT
REPEAT_UNTIL.vsdx
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 33
Objetivo:
Criar o programa para determinar quantos e quais são os primeiros números pares cuja soma não ultrapassa 175.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 34
Objetivo:
Considere um bloco de gelo que, exposto à temperatura ambiente, a cada hora seu volume é reduzido à metade. Desenvolva um programa para calcular quantas horas levará para seu volume atingir 1% do voluma original.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 35
Objetivo:
Desenvolva um programa para executar as tarefas abaixo:
a) Ler a Matrícula, o Nome e as duas notas dos alunos de uma turma
Matrícula ......... AA999 (cinco caracteres, sendo os dois primeiros letras e os demais algarismos)
Nome .............. Máximo de 15 caracteres
Notas .............. de 0,0 a 10,0
b) Calcular a Média Aritmética (MED)
c) Calcular a Situação, de acordo com a seguinte regra:
MED >= 7,0 ............... Aprovado
MED < 3,0 ................. Reprovado
3,0 <= MED < 7,0 ....... Prova Final
d) Calcular a quantidade de alunos Aprovados, Reprovados e em Prova Final
e) Imprimir, na mesma linha, a Matrícula, o Nome, as duas notas, a Média e a Situação
f) Ao final imprimir as quantidades de Aprovados, Reprovados e em Prova Final, conforme
abaixo:
Alunos Aprovados: ........... XXX
Alunos Reprovados: ......... YYY
Alunos em Prova Final: ..... ZZZ
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 36
INÍCIO
DIGITE MAT, NOME, N1,
N2
FIM
S
N
MED = (N1+N2)/2
MED >= 7 ?S
N
MAT, NOME, N1,
N2
REPEAT
SIT= APROVADO
AP=AP+1MED <3 ?
SIT= REPROVADO
RP=RP+1
IMPRIME NOME, N1,N2, MED, SIT
SIT= PROVA FINAL
EF=EF+1
IMPRIME AP, RP, EF
S
N
UNTIL NOME = FIM
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 37
Program Pkzin;
VAR
MAT, NOME, SIT: String;
N1, N2, MED: Real;
AP, RP, FIN: Integer;
Begin
REPEAT
begin
{Leitura de dados ...................................}
Writeln;
Write ('Degite NOME c/ 15 carac FIM PARA SAIR ---> ');
Readln (NOME);
Write ('Degite MATRÍCULA c/ 5 carac ---> ');
Readln (MAT);
Write ('Degite N1 ---> ');
Readln (N1);
Write ('Degite N2 ---> ');
Readln (N2);
{Fim da leitura de dados ............................}
{Cálculos ...........................................}
MED:=(N1+N2)/2;
If MED >= 7 then
begin
SIT:='Aprovado';
AP:=AP+1;
end
else
If MED <3 then
begin
SIT:='Reprovado';
RP:=RP+1;
end
else
begin
SIT:='Prova Final';
FIN:=FIN+1;
end;
{Relatório ....................................}
Writeln;
Writeln (MAT:5, ' - ', NOME:15,' - ', N1 :2:1,' - ', N2 :2:1,
' - ', MED :2:1,' - ',' - ',SIT);
end;
UNTIL NOME='FIM';
{Relatório Final...............................}
Writeln;
Writeln ('Aprovados ----->', AP);
Writeln ('Reprovados ---->', RP);
Writeln ('Prova Final --->', FIN);
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 38
7. Arrays (Vetores e Matrizes)
Nos nossos exemplos anteriores em que líamos o nome e as notas de alunos e calculávamos a média, os dados eram impressos logo após serem lidos ou calculados.
Se nós quiséssemos agora saber, por exemplo, a média da turma, a quantidade de notas acima e abaixo de 7, a quantidade de notas inferiores a três, e assim por diante, não seria possível, pois esses dados não foram armazenados, apenas lidos, calculados e impressos.
Como Arrays são conjuntos de variáveis de um mesmo tipo, as quais são acessadas através de índices identificadores, perderíamos ter armazenado nossos os dados em vetores, cada dado associado a um índice.
A sintaxe é:
<nome_vetor> : array [<início>..<fim>] of <tipo_dado>;
A sintaxe é:
a) Para vetores:
<nome_vetor> : array [<início>..<fim>] of <tipo_dado>;
No exemplo acima, B é um vetor com três linhas.
b) Para matrizes:
<nome_matriz> : array [<início>..<fim>, <início>..<fim>] of <tipo_dado>;
No exemplo acima, A é uma matriz 3x3 (três linhas e três colunas).
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 39
7.1 Vetores
Objetivo:
Criar o programa para ler e armazenar 5 números e depois imprimi-lo.
Objetivo:
Criar o programa para ler e armazenar uma quantidade não determinada de números (NÃO SUPERIOR A 20) e depois imprimi-lo.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 40
Objetivo:
Criar o programa para ler e armazenar 3 números, calcular a Soma e a Média e depois imprimi-los.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 41
Objetivo:
Criar o programa para ler o nome e a idade de cinco pessoas e armazena-los. Depois,
imprimir o nome e a idade de cada um e, ao final, a média das idades
INÍCIO
DIGITE NOME
S
N
NOME[I]
DIGITE IDADE
IDADE[I]
IMPRIME NOME[I], IDADE[I]
MED = SOMA / I
SOMA=SOMA+IDADE[I]
IMPRIME MÉDIA
FIM
N
S
FOR I=1 TO 5 FOR I=1 TO 5
ARRAY_1.vsdx
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 42
Program ARRAY_1 ;
{Programa focalizando o uso de Arrys}
var
NOME: Array[1..5] of String;
IDADE: Array[1..5] of Integer;
I: Integer;
SOMA, MEDIA : Real;
Begin
For I:= 1 to 5 do
begin
Write ('Digite Nome[', I, ']', ' ---> ');
Readln (NOME[I]);
Write ('Digite Idade[', I, ']', ' ---> ');
Readln (IDADE[I]);SOMA:= SOMA + IDADE[I];
end;
Clrscr; {Limpar a tela}
For I:= 1 to 5 do
begin
Writeln (NOME[I]:15, '--->', IDADE[I]);
Writeln;
end;
MEDIA:=(SOMA/I);
Writeln('Idade média: ', MEDIA:2:2);
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 43
Objetivo:
Criar o programa para ler e armazenar 5 números. Depois, classifica-los em ordem crescente e imprimi-los.
INÍCIO
DIGITE A[I]
S
N
A[I]
IMPRIME A[I]
FIM
N
S
N
X = A[I]
A[I] = A[J]
A[J] = X
N
S
S
FOR I=1 TO 5
FOR I=1 TO 5
FOR J=I+1 TO 510
FOR I=1 TO 5
A[I] > A[J] ?
S
N
ORDENA.vsdx
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 44
Program ORDENA ;
{Programa para ler 5 números e ordena-los}
var
A: Array[1..5] of Real;
I, J: Integer;
X: Real;
Begin
For I:= 1 to 5 do {Leitura dos números}
begin
Write ('Digite o número ', ' --->');
Readln (A[I]);
end;
Clrscr; {Limpar a tela}
For I:= 1 to 5 do {Ordenação}
For J:= I+1 to 5 do
begin
If A[I] > A[J] then
begin
X:= A[I];
A[I]:=A[J];
A[J]:=X;
end;
end;
For I:= 1 to 5 do {Impressão dos números}
begin
Writeln ('---> ', A[I]:3:2);
Writeln;
end;
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 45
Objetivo:
Criar o programa para ler uma quantidade indeterminada de números, não superior a 100, e ordena-los.
INÍCIO
DIGITE O NÚMERO
A[K]
IMPRIME A[I]
FIM
N
S
N
X = A[I]
A[I] = A[J]
A[J] = X
N
S
S
REPEAT
FOR I=1 TO K-1
FOR J=I+1 TO K-1
FOR I=1 TO K-1
A[I] > A[J] ?
S
N
ORDENA_Repeat_Until.vsdx
UNTIL A[K]=9999
K = K+1
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 46
Program ORDENA_Vetor ;
{Programa para ordenar até 100 números}
var
A: Array[1..100] of Real;
I, J, K: Integer;
X: Real;
Begin
{Início da leitura ---------------------}
Repeat
K:=K+1;
writeln;
Write ('Digite o número [9999 p/Terminar] ', ' --->');
Readln (A[K]);
Until A[K]=9999;
{Fim da leitura ---------------------}
{Início da ordenação -------------------}
For I:= 1 to K-1 do
Begin
For J:= I+1 to K-1 do
begin
If A[I] > A[J] then
begin
X:= A[I];
A[I]:=A[J];
A[J]:=X;
end;
end;
End;
{Fim da ordenação ---------------------}
{Início da impressão ------------------}
writeln;
For I:= 1 to K-1 do
begin
Writeln (' ', I, 'o ','---> ', A[I]:3:2);
Writeln;
end;
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 47
Objetivo:
Criar o fluxograma e o programa para ler o nome e as duas notas de dez alunos e ordena-los por nome e, ao final, imprimi-los.
INÍCIO
DIGITE NOME
S
N
NOME[I]
IMPRIME NOME[I], N1[I]), N2[I]
FIMN
S
N
X = NOME[I]NOME[I] = NOME[J]
NOME[J] = X
N
S
S
FOR I=1 TO 10
FOR I=1 TO 10
FOR J=I+1 TO 10
FOR I=1 TO 10
NOME[I] > NOME[J] ?
S
N
DIGITE NOTA1
N1[I]
DIGITE NOTA2
N2[I]
N = N1[I]N1[I] = N1[J]
N1[J] = N
N = N2[I]N2[I] = N2[J]
N2[J] = N
ORDENA_Nome_Notas.vsdx
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 48
Program ORDENA_Nome_Notas_vsdx;
{Programa para ler o nome e duas notas e imprimi-las}
VAR
Nome: Array[1..10] of String;
N1: Array[1..10] of Real;
N2: Array[1..10] of Real;
I, J: Integer;
N: Real;
X: String;
Begin
For I:= 1 to 5 do {---Inicio da leitura dos dados ------}
begin
writeln;
Write ('Digite o Nome ', ' --->');
Readln (Nome[I]);
Write ('Digite a 1a Nota ', ' --->');
Readln (N1[I]);
Write ('Digite a 2a Nota ', ' --->');
Readln (N2[I]);
end; {---Fim da leitura dos dados ------}
{Inicio da ordenação dos dados ----------------------}
For I:= 1 to 5 do
Begin
For J:= I+1 to 5 do
begin
If Nome[I] > Nome[J] then
begin
X:= Nome[I];
Nome[I]:=Nome[J];
Nome[J]:=X;
N:= N1[I];
N1[I]:=N1[J];
N1[J]:=N;
N:= N2[I];
N2[I]:=N2[J];
N2[J]:=N;
end;
end;
End;
{Fim da ordenação dos dados ------------------}
clrscr;
writeln;
{Inicio da impressão ------------------------}
Writeln('---------- ----- -----');
Writeln(' NOME P1 P2 ');
Writeln('---------- ----- -----'); For I:= 1 to 5 do
begin
Writeln ('---> ', Nome[I]:10, ' - ' , N1[I]:3:2, ' - ', N2[I]:3:2);
Writeln;
end;
{Fim da impressão -----------------------------}
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 49
7.2 Matrizes
Considere o Sistema de equações abaixo:
Construindo a Matriz dos Coeficientes (MAT) e o Vetor dos Termos Independente (VET), temos:
Objetivo:
Criar o programa para ler e armazenar a matriz MAT e o vetor VET acima e, ao final, imprimi-los.
MAT
7.82
1.31
1.42
1.15
7.20
2.40
3.60
2.50
9.30
VET
36.55
5.48
48.31
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 50
INÍCIO
DIGITE B[I]
I = 1J = 1
S
N
B[I]
IMPRIME B[I]
N
S
N
N
S
S
DIGITE A[I,J]
A[I,J]
N
N
S
S
IMPRIME A[I,J]
F I M
FOR I=1 TO 3
FOR I=1 TO 3
FOR I=1 TO 3
FOR I=1 TO 3
FOR I=1 TO 3
FOR I=1 TO 3
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 51
Program ARRAY_2 ;
{Programa focalizando o uso de Arrys}
var
VET: Array[1..3] of Real;
MAT: Array[1..3, 1..3] of Real;
I, J: Integer;
Begin
For I:= 1 to 3 do {Leitura do Vetor}
begin
Write ('Digite VET(',I,')');
Write ('--->');
Readln (VET[I]);
Writeln;
end;
For I:= 1 to 3 do {Leitura da Matriz}
For J:= 1 to 3 do
begin
Write ('Digite MAT(',I, ',', J, ')');
Write ('--->');
Readln (MAT[I,J]);
Writeln;
end;
Clrscr; {Limpar a tela}
Writeln ('VET');
For I:= 1 to 3 do {Impressão do Vetor}
begin
Writeln (VET[I]:3:2);
Writeln;
end;
Writeln ('MAT');
For I:= 1 to 3 do {Impressão da Matriz}
begin
writeln;
writeln;
For J:= 1 to 3 do
begin
Write (MAT[I,J]:3:2, ' ');
end;
end;
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 52
8. Exercícios
8.1.1 Exercício 1 – Método de Gauss
Objetivo:
Dado o sistema de equações abaixo, determinar o valor das raízes, pelo Método de Gauss.
Construindo a Matriz dos Coeficientes (MAT) e o Vetor dos Termos Independente (VET), temos:
Program Metodo_Gauss ;
Var A: Array[1..3, 1..3] of Real; B: Array[1..3] of Real;
i, j: Integer; k1, k2, k3: Real; X1, X2, X3: Real;
Begin
A[1,1]:=7.82; A[1,2]:=1.15; A[1,3]:=3.60; {A(3X3) ---> Matriz dos
coeficientes}
A[2,1]:=1.31; A[2,2]:=7.20; A[2,3]:=2.50;
A[3,1]:=1.42; A[3,2]:=2.40; A[3,3]:=9.30;
B[1]:=36.55; B[2]:=5.48; B[3]:=48.31; {B(3x1) ---> Vetor dos termos
independentes}
Writeln;
Writeln('Matriz A e vetor B');
For i:=1 to 3 do Begin {Impressão de A e B}
For j:=1 to 3 do Begin
Write (A[i,j]:2:2, ' - ');
End;
Write ('--> ',B[i]:2:2);
Writeln;
Writeln;
End;
{===== 2a Linha = 2a Linha - 1a Linha x k1 =====}
k1:= A[2,1]/A[1,1];
For i:=1 to 3 do Begin;
A[2,i]:= A[2,i]-A[1,i]*k1
End;
B[2]:=B[2]-B[1]*k1;
MAT
7.82
1.31
1.42
1.15
7.20
2.40
3.60
2.50
9.30
MAT
7.82
1.31
1.42
1.15
7.20
2.40
3.60
2.50
9.30
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 53
{===== 3a Linha = 3a Linha - 1a Linha x k2 =====}
k2:= A[3,1]/A[1,1];
For i:=1 to 3 do Begin;
A[3,i]:= A[3,i]-A[1,i]*k2
End;
B[3]:=B[3]-B[1]*k2;
{===== 3a Linha = 3a Linha - 2a Linha x k3 =====}
k3:= A[3,2]/A[2,2];
For i:=1 to 3 do Begin;
A[3,i]:= A[3,i]-A[2,i]*k3
End;
B[3]:=B[3]-B[2]*k3;
{=========================================================}
Writeln;
Writeln('Matriz de Gauss');
For i:=1 to 3 do Begin {Impressão de A e B}
For j:=1 to 3 do Begin
Write (A[i,j]:2:2, ' - ');
End;
Write ('--> ',B[i]:2:2);
Writeln;
Writeln;
End;
{==========================================================}
X3:= B[3]/A[3,3];
X2:= (B[2]-A[2,3]*X3)/A[2,2];
X1:= (B[1]-A[1,2]*X2-A[1,3]*X3)/A[1,1];
Writeln('Raízes: ');
Writeln (' X1= ',X1:2:2); Writeln;
Writeln (' X2= ',X2:2:2); Writeln;
Writeln (' X3= ',X3:2:2); Writeln;
Writeln('Tecle ENTER p/ Terminar');
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 54
8.1.2 Exercício 2 – Método de Jacobi
Objetivo:
Dado o sistema de equações abaixo, determinar o valor das raízes, pelo Método Jacobi.
Program JACOBI;
var
X1, X2, X3:real; {Raízes das equações}
D1, D2, D3:real; {Diferença entre a raíz N e a N-1}
A1, A2, A3:real; {Armazena o volor da N-1 iteração}
B1, B2, B3: real;
I:integer;
Begin
X1:=0; X2:=0; X3:=0;
D1:=1; D2:=1; D3:=1;
B1:=0; B2:=0; B3:=0;
I:=0; {Número de iterações}
while (D1>=0.001) and (D2>=0.001) and (D3>=0.001) and (I<100) do
begin
X1:= B1;X2:=B2; X3:=B3;
X1 := (30.226-0.882*X2-2.762*X3)/5.996; {Calcula o valor de X1 na 1a
equação}
A1:=X1;
D1:=abs(X1-B1); {Diferença entre a iteração atual e a anterior}
X1:=B1;X2:=B2; X3:=B3;
X2 := (22.716-0.998*X1-1.922*X3)/5.523; {Calcula o valor de X2 na
2a equação}
A2:=X2;
D2:=abs(X2-B2); {Diferença entre a iteração atual e a anterior}
X1:=B1;X2:=B2; X3:=B3;
X3 := (22.130-1.092*X1-1.838*X2)/7.130; {Calcula o valor de X3 na
3a equação}
A3:=X3;
D3:=abs(X3-B3); {Diferença entre a iteração atual e a anterior}
B1:=A1;
B2:=A2;
B3:=A3;
I:=I+1; {Contador de Iterações}
end;
writeln;
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 55
writeln('Número de iterações: ',I);
writeln;
writeln('RAÍZES:');
writeln;
writeln('X1 = ', X1:3:2);
writeln;
writeln('X2 = ', X2:3:2);
writeln;
writeln('X3 = ', X3:3:2);
writeln;
writeln('ERRO:');
writeln;
writeln('D1 = ', D1);
writeln;
writeln('D2 = ', D2);
writeln;
writeln('D3 = ', D3);
writeln;
writeln('Tecle <ENTER> para Terminar');
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 56
8.1.3 Exercício 3 – Método de Gauss-Seidel
Objetivo:
Dado o sistema de equações abaixo, determinar o valor das raízes, pelo Método GAUSS-SEIDEL.
Program GAUSS_SEIDEL ;
var
A: Array[1..3, 1..3] of Real;
B: Array[1..3] of Real;
n: Integer;
X1, X2, X3:real; {Raízes do Sitema}
D1, D2, D3:real; {Diferença entre a n-éssima iteração e a anterior}
A1, A2, A3:real; {Armazena o valor do n-éssima iteração}
I:integer; {Contador de iterações}
Begin
A[1,1]:=5.996; A[1,2]:=0.882; A[1,3]:=2.762; B[1]:=30.226;
A[2,1]:=0.998; A[2,2]:=5.523; A[2,3]:=1.922; B[2]:=22.716;
A[3,1]:=1.092; A[3,2]:=1.838; A[3,3]:=7.130; B[3]:=22.130;
X1:=0; X2:=0; X3:=0;
D1:=1; D2:=1; D3:=1;
I:=0;
while (D1>=0.001) and (D2>=0.001) and (D3>=0.001) and (I<50) do
begin
A1:=X1;
A2:=X2;
A3:=X3;
X1:= (B[1]-A[1,2]*X2-A[1,3]*X3)/A[1,1]; {Calcula o valor de X1 na 1a
equação}
X2:= (B[2]-A[2,1]*X1-A[2,3]*X3)/A[2,2]; {Calcula o valor de X2 na
2a equação}
X3:= (B[3]-A[3,1]*X1-A[3,2]*X2)/A[3,3]; {Calcula o valor de X3 na
3a equação}
D1:=abs(A1-X1); {Diferença entre a iteração atual e a anterior}
D2:=abs(A2-X2);
D3:=abs(A3-X3);
I:=I+1;
end;
writeln;
writeln('Número de iterações: ',I);
writeln;
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 57
writeln('RAÍZES:');
writeln(' X1 = ', X1:3:2);
writeln(' X2 = ', X2:3:2);
writeln(' X3 = ', X3:3:2);
writeln;
writeln('ERRO:');
writeln(' D1 = ', D1);
writeln(' D2 = ', D2);
writeln(' D3 = ', D3);
writeln;
writeln('Tecle <ENTER> para Terminar');
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 58
9. Operações com Arquivos
Dentre os comandos usados para tratamento de arquivos estão inclusos comandos para identificação, abertura e fechamento de arquivos.
O uso de arquivos do tipo texto na linguagem Pascal é feito de duas maneiras distintas:
Arquivos binários
Arquivos do tipo texto
Arquivos binários
Os arquivos binários são manipulados por meio de variáveis do tipo file of. Doravante trataremos apenas dos arquivos do tipo Texto.
Arquivos texto
Os arquivos do tipo texto são manipulados por meio de variáveis do tipo text. Os comandos para tratamento de arquivos desse tipo, implementados no compilador, são os seguintes:
Em pascal, como em outras linguagens as variáveis dois tipos de dados:
Primitivos
Char
String
Integer
Real
Boolean
Compostos.
Array
Record
etc.
Doravante trataremos de dados tipo compostos, do tipo Record.
O tipo record (ou registro) é usado para agrupar dados. Podemos dizer cada tipo record é como uma tabela de um banco de dados, e cada dado corresponde aos campos da tabela.
Type NomeDado = record
Com esta instrução criamos o dado NomeDado, do tipo Record
Assign:
Associa um arquivo a uma variável do tipo file ou text.
Assign(arq, 'db.txt');
A variável arq foi associada ao arquivo db.txt
Append:
Abre um arquivo existente para inclusão de novas informações no final.
Append(variavel);
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 59
Reset:
Abre um arquivo já existente no HD, posicionando o cursor de leitura no início do arquivo.
Reset(variavel);
Rewrite:
Cria um arquivo do tipo texto ou, se ele já existe, apaga seu conteúdo e cria um novo arquivo, posicionando o cursor de leitura no início do arquivo.
Rewrite(variavel);
Close:
Fecha um arquivo. Recomenda-se seu uso antes de finalizar o algoritmo.
Close(variavel);
Writeln:
Utilizado para imprimir comandos na tela, também é usado para gravar dados no arquivo, acrescentando na instrução o nome do arquivo.
Writeln(variavel, informações);
Readln:
Utilizado para ler comandos na tela, também é usado para ler dados do arquivo, acrescentando na instrução o nome da variável do arquivo.
Readln(variavel_arquivo, informações);
EOF
Retorna True quando for encontrado o fim do arquivo.
fim := EOF(variavel);
Seek:
Posiciona o cursor de leitura/escrita antes de uma posição específica (em número de registros) do arquivo binário.
O comando considera que o primeiro registro armazenado no arquivo está na posição zero..
Seek(variavel, 2);
FilePos:
Retorna a posição corrente (em número de registros) do cursor de leitura/escrita no arquivo binário.
FilePos(variavel);
FileSize:
Retorna a quantidade de registros de um arquivo.
numero := FileSize(variavel);
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 60
Objetivo:
Criar um programa para ler o nome a as duas notas e armazena-los em um arquivo. Ao final, calcular a média e escrever o nome, as duas notas e a média.
Program Arq_Notas;
TYPE DadosNotas = record {Cria DadosCarro do tipo record}
nome : String[15];
N1, N2 : Real; {Dados de DadosNotas}
end;
VAR
Notas : DadosNotas;
arq :text;
MED : Real;
Begin
Assign (arq, 'Arq_Notas.txt'); {Associa o arquivo Arq_Notas.txt
à variável arq}
While Notas.Nome <> 'F' do
begin
write('Digite Nome: ');
readln(Notas.Nome); {Lendo da tela para o campo Nome dentro da
variável Notas}
write('Digite N1: ');
readln(Notas.N1);
write('Digite N2: ');
readln(Notas.N2);
Append(Arq); {Abre arq no HD, posicionando o cursor no final}
Writeln(arq, Notas.Nome:15, Notas.N1:2:1, ' ',Notas.N2:2:1);
{Grava no arquivo}
Close(arq);
end;
{----------------------------------------------------}
Reset (arq); {Abre arq no HD, posicionando o cursor no início}
While NOT eof(arq) do
begin
writeln;
readln(arq, Notas.Nome, Notas.N1, Notas.N2); {Lê do arquivo}
MED:=(Notas.N1+Notas.N2)/2;
writeln(Notas.Nome:15,' ',Notas.N1:2:1,' ', Notas.N2:2:1,'
',MED:2:1);
end;
Close(arq); {Fecha o arquivo}
{----------------------------------------------------}
End.
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 61
Lógica de Programação Set/2017
José Antelo Cancela www.jose.cancela.nom.br Pág. 62
Referências:
Manual do PascalZim VERSÃO 6.0.3 beta 4 (06/07/2015)
https://leonardoandujar.wordpress.com/2012/03/21/pascal-guardando-dados-em-
arquivos-text/
www.fec.unicamp.br/reenge/aulas/pascal/aula15.html
https://leonardoandujar.wordpress.com/2012/03/21/pascal-guardando-dados-em-
arquivos-text/
https://www.jose.cancela.nom.br/Apostilas/Calc_Numerico