Algoritmos e Estruturas de Dados I

Aula 8: Pascal

Estrutura:

program <nome do programa>;
const <declaração de constantes>;
var <declaração de variáveis>;
begin
  <comandos>;
end.

Exemplo:
program salario; { Calcula comissao }
var vendas, comissao: real;;
begin
  read(vendas);
  comissao := 50 + 0.1 * vendas;
  writeln(`vendas = R$', vendas);
  writeln(`comissao = R$', comissao);
end.

Variáveis

Tipos de variáveis:

Expressões

Operadores:

Aritméticos + - *
/ div mod

Relacionais = > >=
<> < <=

Lógicos and or not

Exemplos de funções:

Aritméticas abs(x) sqrt(x) sin(x)
ln(x) trunc(x) round(x)

Lógicas eof(f) eoln(f) odd(x)

Exemplos:

2 * 3 - 4 * 5 = (2 * 3) - (4 * 5) = -14
15 div 4 * 4 = (15 div 4) * 4 = 12
(a < b + c) or (x > sqrt(y))

Comandos

Atribuição: var := expressao;

condicional:

if condicao then comando;

if condicao then comando1;

else comando2;

repetição:

while cond do comando;

repeat comando until cond;

for v := a to b do comando;

for v := a downto b do comando;

comando composto:

begin

lista de comandos;

end;

Exemplo de Programa Pascal

{Calculo de area e volume da esfera }
{ dado o raio                       }
program esfera;
  const pi = 3.1415927;
  var raio, area, volume: real;
begin
  read(raio);
  area := 4 * pi * sqr(raio);
  volume := raio * area / 3;
  writeln(`Medidas de uma esfera');
  writeln(`Raio = `, raio);
  writeln(`Area = `, area);
  writeln(`Voluma = `, volume);
end.

Exemplo de Programa Pascal

program poli2;
  var: a, b, c, delta,
       xr1, xr2, xi1, xi2: real;
begin
  while not eof do begin
    readln(a, b, c);
    delta := b * b - 4 * a * c;
    if delta >= 0 then begin
      xr1 := (-b + sqrt(delta)) /(2 * a);
      xr2 := (-b - sqrt(delta)) /(2 * a);
      xi1 := 0; xi2 := 0;
    end
    else begin
      xr1 := (-b) / (2 * a);
      xr2 := xr1;
      xi1 := (sqrt(-delta)) / (2 * a);
      xi2 := - xi1;
    end;
    writeln(a, b, c,
            xr1, xr2, xi1, xi2);
  end;
end.

Deteção de Fim de Dados: Contagem

program listadados1;
  var numero, nota, total,
      processados: integer;
begin
  readln(total);
  processados := 0;
  while processados < total do begin
    readln(numero, nota);
    writeln(numero, nota);
    processados := processados + 1;
  end;
  writeln(`fim de dados');
end.
3
1 90
4 60
10 70

Deteção de Fim de Dados: Marca

program listadados2;
  var numero, nota: integer;
begin
  readln(numero, nota);
  while numero >= 0 do begin
    writeln(numero, nota);
    readln(numero, nota);
  end;
  writeln(`fim de dados');
end.

1 90
4 60
10 70
-1 0

Deteção de Fim de Dados: eof

program listadados3;
  var numero, nota: integer;
begin
  while not eof do begin
    readln(numero, nota);
    writeln(numero, nota);
  end;
  writeln(`fim de dados');
end.

1 90
4 60
10 70

{ Graphic representation of a function }
{ f(x) = exp(-x) * sin(2 * pi * x)     }
program graph1;
  const d =  0.0625;   {1/16, 16 lines for interval [x,x+1]}
        s = 32;        {32 character widths for interval 
[y,y+1]}
        h = 34;        {character position of x-axis}
        c = 6.28318;   {2 * pi}
        lim = 32;
  var x, y: real;
      i, n: integer;
begin
  for i := 0 to lim do begin
    x := d * i;
    y := exp(-x) * sin(c * x);
    n := round(s*y) + h;
    repeat
      write(` `);
      n := n - 1;
    until n = 0;
    writeln(`*');
  end;
end.

Resultado

                                  *
                                              *
                                                      *
                                                           *
                                                           *
                                                        *
                                                  *
                                          *
                                  *
                           *
                      *
                   *
                   *
                     *
                         *
                             *
                                  *
                                      *
                                         *
                                           *
                                           *
                                          *
                                        *
                                     *
                                  *
                               *
                              *
                             *
                            *
                             *
                               *
                                *
                                  *