BASES PASCAL

 

VARIÁVEIS

OPERADORES

A) Operações sobre inteiros, com resultado inteiro

B) Operações sobre reais com resultado real

TABELA ASCII  (American Standard Code for Information Interchange)

C) Operadores relacionais binários, operando sobre inteiros e reais, com resultado lógico

d) Operadores lógicos  operando sobre valores lógicos, com resultado lógico

e) Constantes

 

 

 

 

 

 

VARIÁVEIS:

Idade: INTEGER
Salario: REAL
Sexo: CHAR
Nome: STRING
True: Boolean


 

A cada tipo básico da linguagem corresponde um conjunto de valores possíveis. Os tipos que usaremos e que existem na linguagem Pascal são inteiro, real, lógico e caracter. Valores podem ser armazenados em variáveis na memória da máquina, e podem ser manipulados na unidade aritmética-lógica ALU.

 

Linguagem PASCAL

CHAR

REAL

INTEGER

BOOLEAN

Tipo de variável

Caracteres

Números reais  

Números inteiros   

Valores lógicos

Programa em pascal

Program CharCaracters ;

   var c: char;

begin

writeln('Digite um caracter');

readln(c);

writeln(' Voce digitou ', c, '.');

end.

program RealMediaDe3Versao1;

var a, b, c : real;

begin

writeln('escreve 3 números');

readln(a, b, c);

write((a + b + c)/3);

end.

program IntegerMediaDe3Versao2;

var a, b, c : INTEGER;

begin

writeln('escreve 3 números');

readln(a, b, c);

write((a + b + c)/3);

end.

program VerdadeiroFalso;

const

 n1= 5;

 n2= 3;

var

 x,y:integer;

 comp: boolean;

begin

 writeln('Digite um multiplo de ',n1, ' e outro multiplo de ', n2, ': ');

 read(x,y);

 comp:= x > y;

 writeln(x, ' > ', y, ' = ', comp);

 readln; readln;

end.

Exemplo

ex:  (símbolos)  ex:  ‘*’  ‘?’  ‘G’  ‘p’   ‘4’ 

ex:  2.45 2.450  2.4500  1267.54   (os 3 primeiros representam o mesmo valor)

     (e também  em notação cientifica:  1.6754 x 103  ou 1.6754E+3  ou 1.6754e3  ou 0.126754E4 )

ex:  10  345  -27

Ex: (verdadeiro/sim   e  falso/não)

Download prog pascal

PascalZim

CharCaracteres.pas

RealMediaDe3Versao1.pas

IntegerMediaDe3Versao2.pas

VerdadeiroFalso.pas

Mais info para construção do algoritmo

 

 

 

Const – O que é uma Contante

Exercícios

Crie os seguintes programas:

a)  Um programa que leia uma letra maiúscula e que a transforme em minúscula.

b)  Um programa que faça o contrario do anterior

 

c)  Crie um programa para cada um dos seguintes operadores (+  -  *   div e mod)

d)  Descreva de forma sucinta a conclusões a que chegou relativamente ao operador mod e div

e)  Crie um programa que verifique se 2 números são iguais

Ajuda

Minuscula:=Chr(Ord(Maiuscula)+32);

 

 

 

Programas a enviar para o professor profcarlos2006@gmail.com

2 programas a enviar ao professor

 

5 programas a enviar ao professor + 2 conclusões

1 programa a enviar ao professor

 

 

OPERADORES:

Uma operação  é realizada com valores, na Unidade Aritmética-Lógica da máquina, e produz como resultado outro valor, que fica armazenado temporariamente nos registros, podendo ser usado em operações subsequentes.

As operações podem ser unárias ou binárias , dependendo se operam sobre um ou dois valores. Uma operação é formada por um operador(sinal de + - *…) e um ou dois operandos(números da opração) (operação unária  ou binária). Os operadores possíveis dependem do tipo dos operandos envolvidos.

 

Linguagem PASCAL

Resumo dos Operadores

 

 

 

Operadores

 

 

 

Programa em pascal

begin

  writeln('2 + 5 = ', 2+5);

  writeln('7 - 3 = ', 7-3);

  writeln('2 x 6 = ', 2*6);

  writeln('(2 + 6) x 3 = ', (2+6)*3);

  writeln('2 + 6 x 3 = ', 2+6*3);

  writeln('5 mod 3 = ', 5 mod 3);

  writeln('10 div 3 = ', 10 div 3);

  writeln('10 / 3 = ', 10/3:6:2);

  writeln('100 / 3 = ', 100/3:0:2);

  writeln;

  writeln;

  writeln('Press <Enter> To Quit');

  readln;

end. 

 

begin

  SOMA +

  Subtração -

  Multiplicação *

  Soma multiplica

  Multiplica soma

  mod (módulo, ou resto da divisão inteira)

  div (divisão inteira)   

  Divisão ...10/3:6(space):2(casas decimais));

  Divisão /

 

 

 

 

 

 

 

 

 

 

A) Operações sobre inteiros, com resultado inteiro:

operadores binários:   +  -  *   div e mod

+  (soma)     

- (subtração)   

* (multiplicação)   

div (divisão inteira)   

mod (módulo, ou resto da divisão inteira)

Exemplo

ex:   10 + 30   resultado:  40

ex:   30 -  12    resultado:  18

ex:   20 * 4   resultado:  80

ex:  30 div 4   resultado: 7

ex:  30 mod 7   resultado: 2

 

 

 

 

 

 

operador unário:  -  (produz o negativo do seu operando)

 

 

ex:  - 7      operador -  aplicado sobre o operando 7 produz o resultado –7

       -(-7)  produz o resultado 7.

 

 

 

 

 

B) Operações sobre reais com resultado real:

operadores binários:  +  -  *   /

+  (soma)     

- (subtração)   

* (multiplicação)    

/   (divisão real) 

Exemplo

ex:   10.5 + 30.27   resultado:  40.77

ex:   30.2 -  12.8    resultado:  17.4

ex:   20.0 * 4.2   resultado:  84.0

ex:  30.0 / 4.0    resultado:  7.5

 

 

 

 

 

Casos

Caso a operação envolva um operando real e um inteiro, o resultado será sempre real:

30 – 2.5  resultado:  27.5

30 / 4.0   resultado: 7.5

O operador /  quando usado com 2 operandos inteiros, produz o resultado real:   30/4  resultado: 7.5

 

 

C) Operadores relacionais binários, operando sobre inteiros e reais, com resultado lógico:

 

 

>   <  >=    <=   <>   =

>  (maior)

<(menor)

>=  (maior ou igual)

<=  (menor ou igual)

<>  (diferente)

= (igual)

Exemplo

ex:   20  >  30     resultado:  falso  (não)

ex:   20 <  30     resultado:  verdadeiro (sim)

ex:  20 >= 30  

resultado:  falso       20>=20  

resultado:  verdadeiro

ex:  20 <= 30

resultado: verdadeiro  

ex:  20 <> 30 

resultado:  verdadeiro     30.6 <> 10.78

resultado:  verdadeiro    

ex:   20 = 20  resultado: verdadeiro

 

 

 

 

 

 

 

Comparação de caracteres:

 

Os operadores relacionais também podem ser usados para comparar dois valores do tipo caracter. Por exemplo, é correto escrever a operação:   ‘d’ > ’b’  

Nas linguagens de programação em geral, e em Pascal em particular, essas comparações devem ser interpretadas de forma especial.

A linguagem permite utilizar 256 caracteres diferentes. Os caracteres são colocados em ordem, em uma tabela que começa na posição 0 e vai até 255. Essa tabela é hoje em dia um padrão da indústria, e é conhecida como “tabela ASCII - (American Standard Code for Information Interchange)

”. A cada posição da tabela corresponde um caracter. O “valor” de cada caracter é na realidade o número inteiro que representa a posição desse caracter na tabela.  O caracter em si deve ser visto apenas como um símbolo, ou um desenho.

A tabela é longa, mas é importante saber alguns detalhes úteis:

-          os caracteres das letras maiúsculas estão na tabela por ordem alfabética

-          os caracteres das letras minúsculas também.

-          os caracteres dos algarismos (‘0’ a ‘9’) seguem a ordem crescente dos números

-          as letras acentuadas estão em posições sempre acima de 128

-          algumas teclas do teclado correspondem a 2 caracteres seguidos. A tecla ENTER corresponde ao caracter CR (carriage return, ou retorno de carro), da posição 13, seguido do caracter LF (line feed, ou alimentação de linha), da posição 10.

O programador Pascal não precisa saber mais detalhes sobre as posições dos caracteres na tabela para poder programar sem problemas, mas por curiosidade a tabela é mostrada parcialmente abaixo:

 

 

 

 

 

TABELA ASCII  (American Standard Code for Information Interchange)

 

 

Decimal

Octal

Hex

---Binary---

Value

Description

048

060

030

0011 0000

0

049

061

031

0011 0001

1

050

062

032

0011 0010

2

051

063

033

0011 0011

3

052

064

034

0011 0100

4

053

065

035

0011 0101

5

054

066

036

0011 0110

6

055

067

037

0011 0111

7

056

070

038

0011 1000

8

057

071

039

0011 1001

9

058

072

03A

0011 1010

:

Colon

059

073

03B

0011 1011

;

semi-colon

060

074

03C

0011 1100

< 

less than

061

075

03D

0011 1101

=

equal sign

062

076

03E

0011 1110

> 

greater than

063

077

03F

0011 1111

?

question mark

064

100

040

0100 0000

@

"at" symbol

065

101

041

0100 0001

A

066

102

042

0100 0010

B

067

103

043

0100 0011

C

068

104

044

0100 0100

D

069

105

045

0100 0101

E

070

106

046

0100 0110

F

071

107

047

0100 0111

G

072

110

048

0100 1000

H

073

111

049

0100 1001

I

074

112

04A

0100 1010

J

075

113

04B

0100 1011

K

076

114

04C

0100 1100

L

077

115

04D

0100 1101

M

078

116

04E

0100 1110

N

079

117

04F

0100 1111

O

080

120

050

0101 0000

P

081

121

051

0101 0001

Q

082

122

052

0101 0010

R

083

123

053

0101 0011

S

084

124

054

0101 0100

T

Decimal

Octal

Hex

---Binary---

Value

Description

085

125

055

0101 0101

U

086

126

056

0101 0110

V

087

127

057

0101 0111

W

088

130

058

0101 1000

X

089

131

059

0101 1001

Y

090

132

05A

0101 1010

Z

091

133

05B

0101 1011

[

left/opening bracket

092

134

05C

0101 1100

\

back slash

093

135

05D

0101 1101

]

right/closing bracket

094

136

05E

0101 1110

^

caret/circumflex

095

137

05F

0101 1111

_

Underscore

096

140

060

0110 0000

`

097

141

061

0110 0001

a

098

142

062

0110 0010

b

099

143

063

0110 0011

c

100

144

064

0110 0100

d

101

145

065

0110 0101

e

102

146

066

0110 0110

f

103

147

067

0110 0111

g

104

150

068

0110 1000

h

105

151

069

0110 1001

i

106

152

06A

0110 1010

j

107

153

06B

0110 1011

k

108

154

06C

0110 1100

l

109

155

06D

0110 1101

m

110

156

06E

0110 1110

n

111

157

06F

0110 1111

o

112

160

070

0111 0000

p

113

161

071

0111 0001

q

114

162

072

0111 0010

r

115

163

073

0111 0011

s

116

164

074

0111 0100

t

117

165

075

0111 0101

u

118

166

076

0111 0110

v

119

167

077

0111 0111

w

120

170

078

0111 1000

x

121

171

079

0111 1001

y

122

172

07A

0111 1010

z

 

 

 

Então, quando fazemos a comparação de dois caracteres usando operadores relacionais, no entanto, o que é comparado na realidade são as posições correspondentes na tabela.  Como as letras estão em ordem alfabética crescente na tabela, teremos que:   ‘D’ <  ‘F’   resulta em verdadeiro  (na realidade está a ser feita a operação  68<  70)

 

Da mesma forma, ‘d’ < ‘f’ também resulta em verdadeiro  (será feito 100< 102 ), ou seja, os operadores < , >, etc, podem ser interpretados como “antes” e “depois” na ordem alfabética. Mas isso só vale para comparação entre letras maiúsculas ou entre letras minúsculas. Se compararmos uma maiúscula com outra minúscula, essa interpretação pode falhar. Por exemplo,  ‘D’  <  ‘a’  dará verdadeiro  (pois 68 < 97), embora a letra ‘D’ esteja alfabeticamente “depois” da letra ‘a’.

 

Para evitar que isto aconteça, em programas que comparam palavras alfabeticamente, primeiro converter todas as letras para maiúsculas ou para minúsculas, e só depois fazer as comparações.

 

Outro ponto importante a ressaltar, é dificuldade existente em comparar letras acentuadas com as não acentuadas, para determinar a ordem alfabética relativa. Vemos acima o exemplo de ‘à’  e do ‘á’, em posições muito distantes das outras letras. Infelizmente o padrão da tabela ASCII vale apenas para os primeiros 128 caracteres, e as letra acentuadas estão numa área da tabela que não é padronizada. Ainda estão em utilização muitos ambientes de programação com valores diferentes entre si para as letras acentuadas. Por esse motivo, o uso de letras acentuadas em muitas aplicações é desencorajado. Neste curso evitaremos trabalhar com letras acentuadas.

 

Também é importante observar que os caracteres que representam os algarismos estão também em posições contíguas na tabela, e seguem a ordem crescente dos números que representam. Assim vemos que, por exemplo, ‘7’ > ‘3’ dará verdadeiro   (porque  55 > 51).

 

 

 

 

 

 

 

 

d) Operadores lógicos  operando sobre valores lógicos, com resultado lógico:

Negação

A

~A

V

F

F

V

 

 

 

 

 

 

A negação da proposição "A" é a proposição "~A", de maneira que se "A" é verdade então "~A" é falsa, e vice-versa.

Exemplo com apenas uma instrução:

   Uses Crt;

   var X, Y : Integer;

 

   begin

     Writeln ('Insere dois Números:'); { Mostra no monitor a mensagem}

     Readln (X, Y); { Lê os dois números }

     If (X > Y) Then {Condição - SE X for maior que Y}

       Writeln ('X é Maior que Y, e seu valor é = ', X);

   end.

 

Exemplo com mais de uma instrução:

   uses Crt;

   var X, Y : Integer;

 

   begin

     Writeln ('Insere dois Números:'); { Mostra no monitor a mensagem}

     Readln (X, Y); { Lê os dois números }

     If (X = Y) Then {Condição - SE X for igual a Y}

     Begin  {INICIO - Repare abaixo que existem duas instruções, dois comandos Writeln, por isso estão entre BEGIN e END}

       Writeln ('X é igual que Y');

       Writeln ('O Valor de X é =', X);

     End; {FIM}

   end.

Conjunção (E)

 

A

B

A^B

V

V

V

F

V

F

F

F

F

V

F

F

 

 

 

 

 

 

 

 

A conjunção é verdadeira se e somente se os operandos são verdadeiros.

Disjunção (OU)

 

A

B

AvB

V

V

V

V

F

V

F

V

V

F

F

F

A disjunção é falsa se, e somente se ambos os operandos forem falsos.

 

 

 

 

Exercício

a)  Explique passo a passo o que faz o algoritmo à direita.

Exercício a enviar para o professor profcarlos2006@sapo.pt

Program aluno;

 var

 nome:string;

 n1,n2,n3,media:real;

 f:integer;

 Begin

    clrscr;

    writeln('Digite os dados do aluno');

    write('Nome: ');

    readln(nome);

    write('3 notas: ');

    readln(n1,n2,n3);

    if (n1<0) or (n1>10) or (n2<0) or (n2>10) or (n3<0) or (n3>10) then

      begin

       write('Notas inválidas, digite notas de 0 a 10!');

       readln(n1,n2,n3);

      end;

    media:=(n1+n2+n3)/3; 

    write('Quantidade de faltas :');

    readln(f);

    if f<0 then

      begin

        write('Faltas inválidas! digite um número maior ou igual a 0!');

        readln(f);

      end; 

    write('O aluno ',nome,' está ');

    if (media>=5) and (f<18) then write('aprovado com média: ',media:2:2);

    if media<5 then write('reprovado por média: ',media:2:2);

    if f>17 then write('reprovado por falta: ',f:2);

    readkey;

 End.

 

Program aluno;

 Var            {Início da declaração de variáveis}

 nome:string;   {Nome do tipo string (cadeia de texto)}

 n1,n2,n3,media:real; { (Variaveis: números reais) }

 f:integer;           { (variáveis:números inteiros) }

 Begin                { (começa uma intrução) }

    clrscr;           { (limpa a ecra) }

    writeln('Digite os dados do aluno');

    write('Nome: ');

    readln(nome);

    write('3 notas: ');

    readln(n1,n2,n3);

    if (n1<0) or (n1>10) or (n2<0) or (n2>10) or (n3<0) or (n3>10) then { (esta a analisar se n1 é menor que 0 ou maior que 10; se n2 é menor que 0 ou maior que 10; se n3 é menor que 0 ou maior que 10) }

      begin (começa uma instrução)

      write('Notas inválidas, digite notas de 0 a 10!');

      readln(n1,n2,n3);

      end; (acaba uma instrução) 

    media:=(n1+n2+n3)/3; 

    write('Quantidade de faltas :');

    readln(f);

    if f<0 then

      begin (começa uma instrução)

        write('Faltas inválidas! digite um número maior ou igual a 0!');

        readln(f);

      end;(acaba uma instrução) 

    write('O aluno ',nome,' está ');

    if (media>=5) and (f<18) then write('aprovado com média: ',media:2:2); (se media é maior ou igual a 5 e f é menor que 18, então aprovado com media 2:2)

    if media<5 then write('reprovado por média: ',media:2:2);

(se media é menor que 5 então reprovado com media 2:2)

    if f>17 then write('reprovado por falta: ',f:2);

(se media é maior que 17 então reprovadopor falta f:2)

 

    readkey; espera que o utilizador digite uma tecla}

 

 End.

 

 

 

Mais informação sobre tabelas de verdade

Neste site

http://pt.wikipedia.org/wiki/Tabela_verdade

 

 

e) CONSTANTES

Uma constante é um identificador que corresponde a uma área da memória onde fica armazenado um valor que não deve ser alterado pelo algoritmo. Por exemplo, o identificador PI pode ser associado a uma área da memória onde será armazenado o valor 3.1416 no início de um algoritmo, mas que não deverá ser mais modificado.

 

Um identificador pode ser formado por letras, algarismos e o caracter sublinhado (‘_’) em qualquer quantidade, desde que não iniciado por um algarismo. Em geral procura-se formar uma palavra que lembre mnemonicamente o significado do valor correspondente no problema que está sendo resolvido pelo algoritmo.

Por exemplo, o identificador salário pode ser associado a um valor real que representa o salário de alguém, e o identificador achou  pode ser associado a um valor lógico que indica se a busca por um determinado valor numérico em uma lista foi bem-sucedida ou não.

 

 

 

 

 

D1- Recorrendo ao PascalZim elabore o seguinte algoritmo. Descreva de forma sucinta a conclusões a que chegou relativamente ao programa elaborado.

 

D2 – Sabendo que a fórmula para o cálculo da área da circunferência é A=Pi*r2. Elabore um algoritmo que, quando fornecido o valor do raio da circunferência calcule a área da circunferência.

 

D3- Recorrendo ao PascalZim elabore o seguinte algoritmo. Descreva de forma sucinta a conclusões a que chegou relativamente ao programa elaborado.

D3.1. Explique para que serve o comando uses crt.

program exemplo;

const

 n1= 5;

 n2= 3;

var

 x,y:integer;

 comp: boolean;

begin

 writeln('Digite um multiplo de ',n1, ' e outro multiplo de ', n2, ': ');

 read(x,y);

 comp:= x > y;

 writeln(x, ' > ', y, ' = ', comp);

 readln; readln;

end.

 

 

program exemplo;

uses crt;

const

 Ano = 11;

var

 nome:string;

begin

 writeln('Digite o nome do aluno');

 readln (nome);

writeln('O aluno ', nome:3, ' pertence ao ',ano, ' B');              

end.

A enviar para o professor profcarlos2006@sapo.pt (Duas conclusões e um programa)

 

Exercícios de consolidação de conhecimentos

1-  Elabore um algoritmo que calcule a área de um quadrado, depois de solicitar ao utilizador a medida do lado do quadrado

2-  Elabore um algoritmo que a tabuada de um número solicitado ao utilizador

 

 

 

 

 

 

 

 

EXPRESSÕES:

Uma expressão é uma fórmula contendo valores, operandos, identificadores de variáveis ou constantes, e outros símbolos permitidos, e que pode ser calculada de modo a ser reduzida a um valor final. No cálculo de uma expressão os identificadores são substituídos pelos valores correspondentes que estão na memória no momento em que a expressão é calculada.

As operações que fazem parte de uma expressão são executadas da esquerda para a direita, respeitando as regras de precedência.

Regras de Precedência: 

maior precedência:     -  unário,   NÃO

  *  /   div  mod  E

  +   -  (binário)   OU  OU-EXCLUSIVO

menor precedência      >  <  >=   <=    <>  =

 

Além disso, se houver parênteses na expressão, terão prioridade de execução as operações que estiverem nos níveis mais internos de parênteses.

 

Exemplo de expressão:    PI + 3 * x – 2.5

onde PI  tem o valor 3.1416  e x tem o valor 10, no momento em que a expressão será calculada na Unidade Aritmética Lógica da máquina.

Para reduzir essa expressão a um valor, os identificadores são inicialmente substituídos pelos valores correspondentes na memória. A seguir, as operações são executadas da esquerda para a direita. Como o operador * tem precedência sobre o operador +, a operação  3 * x  será feita primeiro. Como + e – têm a mesma precedência, a operação de soma será feita a seguir, e finalmente a subtração. Os valores intermediários resultantes de cada operação são usados como operandos das operações seguintes.

O gráfico abaixo indica os passos que levam à redução da expressão ao seu valor final:

 

   PI + 3 * x – 3.1

3.1416 + 3 * 10 – 3.1    (subst. dos valores dos identificadores)

  3.1416 + 30 – 3.1      (* tem precedência sobre +)

    33.1416 – 3.1       ( + e – tem a mesma precedência, então a operação mais à esquerda é feita primeiro)

      30.0416                (valor final da expressão)

 

Uso de parênteses permite violar as regras de precedência:

      PI + 3 *( x – 3.1)

3.1416 + 3 * (10 – 3.1 )

    3.1416 + 3 * 6.9

    3.1416 + 20.70

23.8416 (valor final da expressão)

 

OBS: usar parênteses em excesso não é erro:   (3+4)  ou ((3+4))  tem o mesmo valor que 3+4

 

Neste próximo exemplo, a expressão se reduz a um valor lógico. Note que não são necessários parênteses porque a precedência dos operadores relacionais é menor que a dos operadores aritméticos:

 

PI + 3*x>   x – 2

3.1416 + 3 * 10> 10 –2

3.1416 + 30 > 10-2

33.1416 > 10 – 2

  33.1416 > 8         ( - tem precedência sobre >)

    verdadeiro        (valor final da expressão)

 

 

Expressões bem e mal formadas:

Uma expressão precisa estar bem formada sintaticamente para poder ser calculada. Por exemplo, a expressão abaixo não pode ser calculada, pois exige operações impossíveis:

 

10 > 20  OU  100 = 40     (expressão malformada )

 

Como o operador OU tem precedência sobre o operador >, a operação  20 OU 100 deveria ser feita primeiro. Mas não é possível fazer essa operação, porque o operador OU só se aplica a operandos lógicos. Existe nessa fórmula um erro de sintaxe (forma gramatical errada). Para corrigir o erro, introduzimos parênteses para forçar que a operação relacional seja feita antes:

 

(10 > 20)  OU  (100 = 40)

     falso  OU   falso

            falso

 

Nota: essa observação é válida para a linguagem Pascal. Na linguagem C, por exemplo, os operadores lógicos têm menor precedência que os operadores relacionais. Por isso, em C, a expressão acima sem parênteses estaria correta.

 

Expressões Triviais:

Uma única constante literal, ou um único identificador de variável, constitui uma expressão trivial, mas é uma expressão legítima:

Por exemplo:  

    3   é uma expressão trivial, seu valor é 3.

    Se x  tem o valor 3,  a expressão:   x   é trivial, com valor 3.  

 

Expressões envolvendo funções:

Assim como na Matemática, uma expressão pode conter também o uso de funções com argumentos que são também expressões. Funções serão vistas mais adiante, mas para ilustrar a expressão abaixo usa a função sqrt( )  (de square root – raiz quadrada):

                                                                                             ____

x + 3 * sqrt(y-2)     equivalente em Matemática a    x + 3 Ö y-2