Lógica de programação pascal

Programação em Pascal

Profª Jocelma Rios
Maio/2012

Linguagem de programação Pascal

Saiba mais: http://pt.wikipedia.org/wiki/Blaise_Pascal
Linguagem de programação estruturada, que
•

recebeu este nome em homenagem ao matemático
Blaise Pascal
Foi criada em 1971 pelo suíço Niklaus Wirth,
•

visando promover o uso de código estruturado
Teve grande sucesso na década de 1980, sendo
•

utilizada em computadores baseados na
arquitetura 8080 e 8086
•
Gera programas compilados (.EXE)
Pascal é normalmente uma das linguagens de
•

escolha para ensinar programação

Compiladores
Pascalzim: compilador gratuito que foi
desenvolvido na UnB e é utilizado em várias
disciplinas de introdução a programação
Turbo Pascal: era o principal compilador
Pascal para PC durante os anos 1980 e início
dos anos 1990
Free Pascal: compilador escrito em Pascal,
distribuído sob a licença de uso GNU/GPL.
Pode ser utilizado em conjunto com código
escrito em Turbo Pascal ou Delphi, e pode
ser usados em várias plataformas e sistemas
operacionais


Estrutura básica de um programa em
Pascal:

1.Cabeçalho do programa
2.Área de declarações
3.Corpo do programa Exemplo de código:

program OlaMundo;
begin
writeln('Olá, Mundo!');
end.

Estrutura básica de um programa em Pascal:
{comentários entre chaves não são lidos pelo compilador}
1.program Nome_do_programa; {identificação do
programa}
2.uses CRT; {acessar uma biblioteca de funções, necessário
no Turbo Pascal}
3.var {declaramos as variáveis}
4. a,b,c:real; {variáveis:tipo}
5.begin {início do corpo do programa}
6. read(a); {comandos dentro do corpo}
7. c:=a; {comandos terminam com ponto e vírgula}
8.end. {fim do corpo do programa com ponto}

Área de declarações:

Uses: define as bibliotecas de funções que serão
utilizadas
Label: utilizados em conjunto com a instrução GOTO
Const: define as constantes que serão utilizadas
Var: define as variáveis que serão utilizadas
Procedure: define as sub-rotinas necessárias
Function: define as funções necessárias

Bibliotecas:

Crt: rotinas para tratamento/formatação de vídeo e som
Dos: manipulação do sistema operacional (DOS), rotinas
que permitem controle de
baixo nível
Graph: rotinas para tratamento gráfico
Printer: rotinas para tratamento de impressões
Overlay: rotinas para tratamento de overlays
(sobreposição)

Biblioteca Crt:
Clrscr → limpa a tela
Delay(x) → aguarda x/100 segundos
Delline → deleta uma linha
Gotoxy(lin,col) → desloca o cursor para a posição x,y
Highvideo → aumenta brilho dos próximos textos
Lowvideo → diminui brilho dos próximos textos
Normvideo → retorna o brilho do vídeo ao normal
Nosound → desabilita som
Readkey → armazena o valor lido de uma tecla
Sound(1) → emite som

Biblioteca Dos:
GetTime(hora,min,seg,cent) → retorna hora
GetDate(ano,mes,dia,diaSemana) → retorna data

Constantes

Constante é um determinado valor
fixo que não se modifica ao longo
do tempo, durante a execução de um
programa. Conforme o seu tipo, a
constante é classificada como sendo
numérica, lógica e literal.

Program CalculaArea;
Const
Pi=3,141516;

Variáveis
Variável é a representação simbólica dos
elementos de um certo conjunto. Cada
variável corresponde a uma posição de
memória, cujo conteúdo pode se alterado
ao longo do tempo durante a execução de
um programa. Embora uma variável possa
assumir diferentes valores, ela só pode
armazenar um valor a cada instante.

Var
Raio: real;

Variáveis – tipos
Numéricas: armazenam números, que poderão
ser utilizados para cálculos
– Inteiras → para armazenamento de números
inteiros
• Integer – 2 bytes (-32768 … 32767)
• Shortint – 1 byte (-128 … 127)
• Longint – 4 bytes (-2147483648 … 2147483647)
• Byte – 1 byte (0 … 255)
• Word – 2 bytes (0 … 65535)
– Reais → para armazenamento de números que
possuam casas decimais
• Real – 6 bytes (2.9e-39 … 1.7e38)
• Single – 4 bytes (1.5e-45 … 3.4e38)
• Double – 8 bytes (5.0e-324 … 1.7e308)
• Extended – 10 bytes (3.4e-4932 … 1.1e4932)

Alfanuméricas: para armazenamento de dados
que contenham letras e/ou números

• Pode em determinados momentos conter somente
dados numéricos ou somente literais
• Se forem usadas somente para armazenamento de
números, não poderá ser utilizada para
operações matemáticas

– Char – 1 byte (um caracter)
– String – 2 a 256 bytes (2 a 256 caracteres)
• Ex: nome: string[30];

• Lógicas: armazenam somente dados lógicos
que podem ser Verdadeiro ou Falso
– Boolean

• Ponteiro: armazena a posição de memória e
não o conteúdo do dado, de outra variável

Variáveis – declaração
• As variáveis só podem armazenar valores
de um mesmo tipo, de maneira que também
são classificadas como sendo numéricas,
lógicas e literais.

Var
base, altura, raio: real;
tipo: string[20];
raio: real;
realizado: boolean;

Palavras reservadas
• Visando interpretar a lógica desenvolvida
pelo programador, as linguagens de
programação limitam o uso de algumas
palavras, que tem função específica nos
programas, em forma de sentença, comando
ou instrução
→ são chamadas de palavras reservadas
→ ex: const, var, program, read, readln,
write, writeln, if, then, eles, begin, end,
while, do, case, of, repeat, until,
integer, real, boolean, string, procedure,
function, uses, array, clrscr, delay etc.

Operadores

Os operadores são meios pelo qual
incrementamos, decrementamos,
comparamos e avaliamos dados dentro do
computador.

Há três tipos de operadores:
– Operadores Aritméticos
– Operadores Relacionais
– Operadores Lógicos

Operadores aritméticos
• Adição +
• Subtração -
• Multiplicação *
• Divisão (real) /

OBS: A linguagem Pascal não possui um operador para
potenciação; a mesma é calculada a partir de cálculos de
produto ou através de uma função exponencial (ex) e
função logarítmica (LN(X)).

Sintaxe:
XY := EXP(Y*LN(X))
EX:
X0.5 = EXP(0.5 * LN(X))

Operadores aritméticos
• (x)DIV(y) – retorna o quociente inteiro da divisão de x
por y
• MOD(x) – retorna o resto da divisão
• INT(x) – retorna a parte inteira de um número
• ABS(x) - pega o valor absoluto de x
• Exp – expoente
• Round(x) – retorna o valor arredondado de x
• Frac(x) – retorna a parte fracionária de x
• Ln – logaritmo
• Sqr(x) – retorna o quadrado de x
• Sqrt(x) – retorna a raiz quadrada de x
• Trunc(x) – pega a parte inteira do número real

Operadores relacionais

Descrição Símbolo
• Igual a =
• Diferente de <>
• Maior que >
• Menor que <
• Maior ou igual a >=
• Menor ou igual a <=
• Atribui valor a :=

Operadores lógicos

• E → AND
• OU → OR
• NÃO → NOT

Prioridade dos Operadores

1.Parênteses e funções
2.Sinais unários (=, :=)
3.Exponenciação
4.Divisão e multiplicação
5.Adição e subtração
6.Operadores relacionais
7.NOT
8.AND
9.OR

Comandos
•Read(): Comando que solicita o dado a ser
fornecido pelo usuário

•Readln(): Comando que solicita o dado a ser
fornecido pelo usuário, e salta uma linha na tela
de interface com o usuário

•Write(): Comando que define a escrita de um
resultado na tela ou impressora

•Writeln(): Escreve e salta para a próxima linha.
Pode ser usado também para imprimir uma linha em
branco

Comandos
•While <condição> Do <comandos>: Enquanto
<condição> Faça <comandos>

•Repeat <comandos> Until <condição> : Repita
<comandos> até <condição>

•For <ValorInicial> to <ValorFinal> do
<comandos>: Para ValorInicial até ValorFinal Faça
<comandos>

•If <condição> then <comandos> else <comandos>:
Se <condição> então <comandos> senão <comandos>
{semelhante ao SE(Teste_Lógico;ValorVerdadeiro;ValorFalso) do Excel}

Exemplo:Somar dois números Program Soma; {nome do programa}

... Uses CRT;
Definir os tipos de dados
Solicitar o primeiro número N1 Var {define as variaveis}
Solicitar o segundo número N2 N1, N2, Soma,Pi,AreaCirc1: Real;
Soma=N1+N2 Tecla:Char;
Calcular a área do círculo Begin {Inicia a programação}
Emitir o valor de Soma e da Área Pi:=3.141516;
... Clrscr; {limpa a tela}
Write(“Digite o primeiro numero”);
Variáveis: São valores que
variam durante a execução do Readln(N1);
programa Write(“Digite o segundo numero”);
Constantes: São valores que não Readln(N2);
variam durante a execução do Soma:=N1+N2;
programa. AreaCirc1:=Pi*N1**2;
Integer(inteira),Boolean Writeln(“N1+N2= “,Soma);
Begin (inicia o Programa ou um Writeln(“A area do circulo eh:
“AreaCirc1);
procedimento)
End.
End (Termina o programa (se
seguido de ponto’.’) ou um
procedimento)

Program Precofim;

Var 1

NomeVeiculo:String[25];
PrecoFabrica,Imposto,Lucro,PrecoFim:R write('Digite o percentual do lucro: ');
eal; read(Lucro);
Tecla:char;
/*Cálculo de Imposto e lucro*/
Begin Imposto:=(Imposto*PrecoFabrica)/100;
Lucro:=(Lucro*PrecoFabrica)/100;
/*Digitação das variáveis*/
write('Digite o nome do veículo: '); /*Cálculo do preço final*/
readln(NomeVeiculo); PrecoFim:=PrecoFabrica+Imposto+Lucro;

write('Digite o preço do veículo: '); /*Emissão de resultados*/
readln(PrecoFabrica); write('O valor final do veículo ',
Nomeveiculo,' é: ',PrecoFim);
write('Digite o percentual do readkey;
imposto: ');
readln(Imposto); end.

1

Estrutura de Decisão e Repetição

Os comandos de decisão ou desvio fazem
parte das técnicas de programação que
conduzem a estruturas de programas que
não são totalmente sequenciais
As principais estruturas de decisão são:
If … then
If … then … eles …
Case of … do

If … then (Se … então)

A estrutura de decisão if...then vem
acompanhada de um ou mais comandos, ou
seja, se determinada condição for
satisfeita pelo comando if...then, o
comando é executado

If MEDIA >= 5.0 then
aluno_aprovado := true;

Sempre um comando será executado
independente da condição, ou seja, caso
a condição seja “verdadeira” o comando
da condição será executado, caso
contrário o comando da condição “falsa”
será executado.

If MEDIA >= 5.0 then
aluno_aprovado := true
else
aluno_aprovado := false;

.
.
Program Compara_Num;
. var
N1, N2: integer;
N1=N2 S begin
N1=N2
? read (N1);
N read (N2);
N if N1=N2 then
N1>N2
N1<N2 write ('N1=N2')
?
else
S
if N1>N2 then
N1>N2 write ('N1>N2')
. else
.
. write ('N1<N2');
end.

Início 1

Declara
Constantes: S
Pi=3,14; Reat>100?
FreqN=60; “Reatância
FreqAlt=70; Alta”

Declara Variáveis: N
Indut: Real;
Reat: Real;
S
Reat=100? “Reatância
Ler Indut Padrão”

Reat:=2*Pi*FreqN*Indut N
“Reatância Baixa”
“Reatância
Indutiva=“,reat
Término
1

Código Pascal
Program Maior;
Uses crt;
Var
N1,N2:real;
Begin
clrscr;
write ('Digite o primeiro número: ');
readln (N1);
write ('Digite o segundo número: ');
readln (N2);
if N1=N2 then
writeln ('O numero ',N1,' é igual ao ', N2)
else
if N1>N2 then
writeln ('O numero ',N1,' é maior que ',N2)
else
writeln ('O numero ',N2,' é maior que ',N1);
End.

Program MaioMenor3;
else
Uses crt; if N1>N2 then
begin
Var Maior:=N1;
N1,N2,N3,Maior,Menor:Real; Menor:=N2;
tecla:char; end
Begin else
clrscr; {Comando para limpar tela} begin
write ('Digite o primeiro numero: '); Maior:=N2;
readln (N1); Menor:=N1;
writeln (''); end;
write ('Digite o segundo numero: '); if N3>Maior then
readln (N2); Maior:=N3;
writeln (''); if N3<Menor then
write ('Digite o terceiro numero: '); Menor:=N3;
readln (N3);
writeln (''); writeln ('O maior numero é ',Maior:2:2);
if N1=N2 then writeln ('');
begin writeln ('O menor numero é ',Menor:2:2);
writeln ('O numero ',N1:2:2,'é igual ao
',N2:2:2); readkey;
if N1=N3 then
begin End.
writeln ('O numero ',N1:2:2,'é igual
ao ',N3:2:2);
if N2=N3 then
writeln ('O numero ',N2:2:2,'é
igual ao ',N3:2:2);
end;
Maior := N1;
Menor := N1;
end

Ler dois números e uma letra. Se a letra for 'a', adicionar, se for 's', subtrair,
se for 'm', multiplicar, se for 'd', dividir, senão, exibir “Operação inexistente”
Início 1

Definir N1,N2,Resultado: Real; S
Resultado:= Operação:
Definir Letra,Tecla: Char; Letra=m? multiplicação
N1*N2
n

Ler (N1) S
Letra=d?
divisão
N1*N2
Ler (N2)

Ler (Letra) Operação:
Inexistente
S
Letra=a? adição
N1+N2
n Fim

S
Letra=s? N1-N2 subtração

n

1

Program Operacao; if letra=‘m’ or letra=‘M’ then
Uses CRT; begin
Var Resultado:=N1*N2;
N1,N2,Resultado:Real; writeln (‘A operação escolhida foi a
Letra,Tecla: Char; multiplicação e resultado eh: ‘,Resultado);
end;
begin if letra=‘d’ or letra=‘D’ then
begin
clrscr;
Resultado:=N1/N2;
write (‘Digite o primeiro número: ‘);
writeln (‘A operação escolhida foi a
readln (N1);
divisão e resultado eh: ‘,Resultado);
write (‘Digite o segundo número: ‘);
end
readln (N2);
else
write (‘Escolha a operação:
writeln (‘A operação escolhida é
a(Adição);S(Subtração),m(multiplicação),d(D
inválida’);
ivisão): ‘);
readln (Letra);
End.
if letra=‘a’ or letra=‘A’ then
begin
Resultado:=N1+N2;
adição e resultado eh: ‘,Resultado);
end;
if letra=‘s’ or letra=‘S’ then
begin
Resultado:=N1-N2;
subtração e resultado eh: ‘,Resultado);
end;

Select … Case
A estrutura de decisão select … case é
utilizada para testar, na condição, uma
única expressão, que produz um
resultado, ou, então, o valor de uma
variável, em que está armazenado um
determinado conteúdo

Compara-se, então, o resultado obtido no
teste com os valores fornecidos em cada
cláusula “Case”

Select … Case → Exemplo
INICIO

Título=“”

Recebe Opção
sim
Opção=1 Título=“Opção 1”
não
sim
Opção=2 Título=“Opção 2”
não
não sim
Opção=3
Título=“Opção 3”
Opção Errada
Título

FIM

Estrutura de Decisão Múltipla (CASE-OF)
( http://www.scribd.com/doc/31075622/linguagens-e-t-cnicas-de-
programa%C2%A6Eo-pdf): É usada quando se deseja executar um dentre
vários comandos, dependendo do resultado de uma expressão:
Sintaxe:
CASE <expressão> OF
<lista de constantes-1>: <comando-1>;
<lista de constantes-2>: <comando-2>;
....
ELSE <comando-n>
End;
<expressão>: Deve resultar um tipo escalar, diferentemente do REAL
e do STRING;

<lista de constantes-x>:contém uma ou mais constantes, separadas
por vírgula e contém o mesmo tipo de <expressão>.

<comando-x>: pode ser comando simples ou composto.

O resultado de <expressão> é comparado com <lista de
constante>,para verificação de igualdade. Se a igualdade acontece o
comando correspondente é executado, caso contrário, o comando
correspondente em ELSE será executado.

Program UsoCase;
{Simulador de calculadora básica de inteiros}

var
X,Y: integer;
Op: char;

begin
clrscr;
write ('Digite X: ');
readln (X);
write ('');
1
write ('Digite Y: '); case Op of
readln (Y); '+': writeln (X+Y);
write (''); '-': writeln (X-Y);
write ('Digite o Operador:'); 'x', 'X', '*': writeln (X*Y);
readln (Op); '/': writeln (X/Y);
else
Writeln ('Operação inválida');
1 end;

end.

Comando de repetição
Utilizamos os comandos de repetição quando
desejamos que um determinado conjunto de
instruções ou comandos sejam executados um
número definido ou indefinido de vezes, ou
enquanto um determinado estado de coisas
prevalecer ou até que seja alcançado.

Trabalharemos com modelos de comandos de
repetição:
• Enquanto x, processar (Do While ...Loop);
• Até que x, processar ... (Do Until ... Loop);
• Processar ..., Enquanto x (Do ... Loop While);
• Processar ..., Até que x (Do ... Loop Until)
• Para ... Até ... Seguinte (For ... To ... Next)

• Enquanto x, Processar (Do While … Loop)
Neste caso, o bloco de operações será
executado enquanto a condição x for
verdadeira. O teste da condição será
sempre realizado antes de qualquer
operação.
Enquanto a condição for verdadeira o
processo se repete.
Podemos utilizar essa estrutura para
trabalharmos com contadores.

Comando de repetição → exemplo

N=0

não
N<=100

sim

N=N+1

loop

Continue

• Até que x, processar … (Do until … loop)
Neste caso, o bloco de operações será
executado até que a condição seja
satisfeita, ou seja, somente executará os
comandos enquanto a condição for falsa.

Exemplo – faça … até …
N=0

sim
N=100

não

N=N+1

Continue

• Processar …, Enquanto x (Do … Loop While)
Neste caso, primeiro são executados os
comandos, e somente depois é realizado o
teste da condição. Se a condição for
verdadeira, os comandos são executados
novamente, caso seja falso é encerrado o
comando DO.

Exemplo – de … até …

N=N+1

sim
N<=100

não

Continue

• Processar …, Até que x (Do … Loop Until)
Neste caso, executa-se primeiro o bloco
de operações e somente depois é realizado
o teste de condição.
Se a condição for verdadeira, o fluxo do
programa continua normalmente. Caso
contrário é processado novamente os
comandos antes do teste da condição.

Exemplo – faça … até …

N=N+1

não
N>=100

sim

Continue

For … to … next
Permite a repetição dos comandos contidos nesta
estrutura seja repetida um número específico
de vezes.

Descrição Narrativa: Imprima na tela os números
de 1 a 100.

Linguagem Algorítmica:

for N := 1 to 100 do
begin
writeln (N);
end;

For … to … next
Neste exemplo, ao iniciar o comando for a
variável N recebera o valor do primeiro
número da condição (no caso 1) e será
impresso na tela o valor do mesmo, quando
esse comando se repetir o N passara a ter o
valor de N+1 ou seja 2, e será impresso
novamente na tela, isso se repetira até que N
seja igual a 100. Temos também no comando for
a opção que vai decrescendo N até chegar em
um valor igual ao segundo da condição.
Exemplo:

For N := 100 dowto 1 do
Begin
Writeln (N);
End;

Program ContrTemp;
var
Temp, TemPad, DiferTemp: real;
Opcao: char;
begin
TempPad:=30;
while opção <> 'n' do
begin
read (Temp);
if Temp>Temppad then
begin
DiferTemp:=Temp-TempPad;
writeln ('A temperatura deve ser diminuida em' , DiferTemp);
end
else
if Temp<Temppad then
begin
Difertem:=Temppad-Temp;
writeln (‘A temperatura deve ser aumentada em ‘, DiferTemp);
end;
read (Opcao);
end;
end.

Estrutura de Repetição(Laço): While CÓDIGO PASCAL
Program SomaN;

var
Início
N1,N2,Soma: real;
Opcao: Char;
Definir N1,N2,Soma:Real; begin
Definir Tecla, Opcao: Char; clrscr; {Limpa a tela}
Opcao:='S'; {Inicializar a variável}
N
Enquanto Opcao<>´n´ faça Fim while Opcao<>'n' do
begin
S
write ('Digite o primeiro número: ');
Ler N1; readln (N1);
Soma:=N1+N2;
Soma:=N1+N2
writeln ('');
writeln (N1:2:2, '+', N2:2:2, '=',
Soma:2:2);
Ler Opcao; writeln ('');
write ('Deseja continuar(s{n)? ');
readln (Opcao);
end;
read (Opcao);
end.

Exemplo: Digitar Nome e turma de alunos usando estrutura de repetição

Program NomeTurm;

var
nome: string[30];
turma: string[4];
opcao: char;

begin
opcao:='s';
while opcao<>'n' do
begin
write ('Digite o nome do aluno: ');
readln (nome);
write ('Digite a turma do aluno: ');
readln (turma);
Writeln ('');
write ('Deseja continuar(s/n): ');
readln (opcao);
writeln ('');
end;
end.

Exemplo: Digitar Nome e turma de alunos usando estrutura de repetição, totalizando os alunos digitados e cada
turma digitada
Program NomeTurm;
var
nome: string[30]; writeln('');
turma: string[4]; writeln ('Total de alunos cadastrados:
TotAluno,Tot5811,Tot5812,Tot5911,Tot5912: ',TotAluno);
integer; writeln ('');
opcao: char; writeln ('Turma 5811: ',Tot5811);
begin writeln ('');
opcao:='s'; writeln ('Turma 5812: ',Tot5812);
while opcao<>'n' do writeln ('');
begin writeln ('Turma 5911: ',Tot5911);
write('Digite o nome do aluno: '); writeln ('');
readln(nome); writeln ('Turma 5912: ',Tot5912);
write('Digite a turma do aluno: '); end.
readln(turma);
Writeln('');
TotAluno:=Totaluno+1;
If turma='5811' then
Tot5811:=Tot5811+1;
Tot5812:=Tot5812+1;
Tot5911:=Tot5911+1;
Tot5912:=Tot5912+1;
write('Deseja continuar(s/n): ');
readln(opcao);
writeln('');
end;

Estrutura de Repetição(Laço):
CÓDIGO PASCAL
Repeat...Until
Program SomaN;
var
Início
N1,N2,Soma:real;
Opcao: Char;
Definir N1,N2,Soma:Real;
begin
Definir Tecla, Opcao: Char;
repeat
clrscr;
Repeat Fim
write ('Digite o primeiro número:
');
soma := N1+N2;
Soma:=N1+N2 writeln (' ');
writeln (N1:2:1, '+', N2:2:1, '=',
Ler Opcao; Soma:2:1);
writeln (' ');
Until Opcao=´n´ write ('Deseja continuar(s{n)? ');
readln (Opcao);
until opcao = 'n';
end.

Array
É semelhante a uma planilha eletrônica, porém,
pode ter mais de duas dimensões.
Um vetor, tipo especial de matriz, possui apenas
uma dimensão. Por exemplo, uma linha ou uma
coluna de uma planilha do Excel possui apenas
uma dimensão. Uma planilha com mais de uma linha
ou coluna possui duas dimensões.
A matriz só pode armazenar valores de um mesmo
tipo.

Array
Sintaxe de um array (matriz):

<nome_variavel>: [<nº inicial de linhas>..<nº final de
linhas>,<nº inicial de colunas>..<nº final de
colunas>,...,<nº inicial da dimensão N>..<nº final da
dimensão N>]<tipo que o array pode conter];

Ex.:
Var
Notas: array [1..200, 1..4] of real;

Array
var
Nota: array [1..200, 1..4] of real;
i, j: integer;
...
for i:=1 to 200 do
for j:=1 to 4 do
write ('Digite a nota do aluno: ');
read (Nota[i,j]);
for i:=1 to 200 do
for col=1 to 4 do
write ('A nota do aluno é: ', Nota[i,j]);
…

Obs.: Para cada linha deve-se varrer todas as colunas,
só após acessar a última coluna, pula-se para a
próxima linha. Isso á análogo para todas as dimensões
e suas subdimensões.

Array
Exemplo – leitura de um array unidimensional:

var
nota: array [1..20] of real;
i: integer;

begin
for i:=1 to 20 do
begin
write ('Digite a nota da unidade: ');
readln (nota[i]);
end;

Array
Exemplo – leitura de um array bidimensional:

var
NotaMedia: array [1..20,1..4] of real;
i, j: integer;
begin
for i:=1 to 20 do
for j:=1 to 4 do
begin
write ('Digite a nota da unidade ', j, '.');
readln (NotaMedia[i,j]);
end;

Lógica de programação pascal

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Lógica de programação pascal

Mais de Jocelma Rios

Lógica de programação pascal