Lógica de Programação Set/2017 - Página pessoal de ... · Lógica de Programação Set/2017 José Antelo Cancela Pág.3 Lógica de Programação 1. Introdução Algorítmo Algorítmo

José Antelo Cancela

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

http://www.jose.cancela.nom.br/



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.




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.


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;




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.


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;




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.




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




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


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.





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.




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.




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




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




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




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




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




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




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.




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







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.




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




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.




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 ?




Objetivo:

Criar o programa para determinar os números primos inferiores a um valor dado.




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




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




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




Objetivo:

Criar o programa para determinar quantos e quais são os primeiros números pares cuja soma não ultrapassa 175.




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.




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




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);


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.




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




Objetivo:

Criar o programa para determinar quantos e quais são os primeiros números pares cuja soma não ultrapassa 175.




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.




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

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




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);


Readln (N1);


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.




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).




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.




Objetivo:

Criar o programa para ler e armazenar 3 números, calcular a Soma e a Média e depois imprimi-los.




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




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.




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




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;


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.




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




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.




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




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.




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




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




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;


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.




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





k2:= A[3,1]/A[1,1];


A[3,i]:= A[3,i]-A[1,i]*k2

End;

B[3]:=B[3]-B[1]*k2;


k3:= A[3,2]/A[2,2];


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('Tecle ENTER p/ Terminar');

End.




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;


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;


B1:=A1;

B2:=A2;

B3:=A3;

I:=I+1; {Contador de Iterações}

end;

writeln;




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;


writeln;

writeln('Tecle <ENTER> para Terminar');

End.




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;




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;

writeln('Tecle <ENTER> para Terminar');

End.




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);




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);




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.







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


https://leonardoandujar.wordpress.com/2012/03/21/pascal-guardando-dados-em-arquivos-text/

https://leonardoandujar.wordpress.com/2012/03/21/pascal-guardando-dados-em-arquivos-text/

Documents

Lógica de Programação Set/2017 - Página pessoal de ... · Lógica de Programação Set/2017 José Antelo Cancela Pág.3 Lógica de Programação 1. Introdução Algorítmo Algorítmo