Parte I << | >> Parte III

Nesta continuação será dada ênfase à parte prática da programação em Pascal. Serão colocados igualmente Propostas de Exercícios. Esta parte do Tutorial não terá constantes explicações dos códigos para poder exercitar a leitura lógica de um programa em Pascal.

Como em qualquer linguagem, onde se começa regra geral com o famoso “Olá Mundo!”, ir-se-á realizá-lo em Pascal. Primeiramente, há que saber que, neste programa, apenas será escrita uma mensagem, pelo que bibliotecas não são necessárias. Esta parte é, então, omitida nas declarações iniciais:

program hello_world;  // Declara-se o programa, no geral.
// bibliotecas não são necessárias
// não são necessárias variáveis
 
begin
     writeln('Hello World!');  // escreve o texto “Hello World!”
     readln;  // sem isto, o programa é encerrado repentinamente: é necessário pressionar ENTER.
end.

“Embeleze-se” o programa, onde já se irá pedir o nome do utilizador e dar uma mensagem final.

program hello_world;  // Declara-se o programa, no geral.
uses crt;  // dependendo do IDE/compilador, este biblioteca será necessária ou não neste exemplo
var nome:string;
 
begin
     write('Introduza o seu nome: ');  // escreve o texto, e o cursor fica à frente deste, pois falta o sufixo LN (LiNe)
     readln(nome);
     writeln;  // faz mais um parágrafo sem escrever texto
     writeln('Hello World!');
     writeln('Seja bem-vindo, Sr.(a) ',nome);  // escreve o texto, seguido do conteúdo da variável NOME
     readln;
end.

Crie-se a primeira calculadora. O utilizador não vai escolher o operador. Simplesmente o utilizador introduz os dois valores e aparecem os resultados das quatro operações básicas. Necessitar-se-á de uma condição If… Then… Else… por causa da divisão. Se o denominador for 0 (zero), o programa, ao tentar fazer a conta, irá abaixo: a condição vai evitar este bug.

program primeira_calculadora;
uses crt;
var num1,num2:real;

Ou seja, utilizar-se-á duas variáveis reais que alojarão os dois valores necessários.

program primeira_calculadora;
uses crt;
var num1,num2:real;
 
begin
     writeln('CALCULADORA SIMPLES');
     write('Primeiro valor: ');
     readln(num1);
     write('Segundo valor: ');
     readln(num2);
end.

Neste momento, o utilizador é convidado a introduzir os dois valores que farão parte das quatro operações.

Resta, então, realizar os cálculos e mostrá-los ao utilizador:

program primeira_calculadora;
uses crt;
var num1,num2:real;
 
begin
     writeln('CALCULADORA SIMPLES');
     write('Primeiro valor: ');
     readln(num1);
     write('Segundo valor: ');
     readln(num2);
     writeln;
     writeln(num1:0:3,' + ',num2:0:3,' = ',num1+num2:0:3);
     writeln(num1:0:3,' - ',num2:0:3,' = ',num1-num2:0:3);
     writeln(num1:0:3,' * ',num2:0:3,' = ',num1*num2:0:3);
end.

Contudo, chega a fase de antever a situação de num2 = 0 por causa da divisão. Criar-se-á, então, a condição à parte.

write(num1:0:3,' / ',num2:0:3,' = ');
// não faz parágrafo, à frente ficará o resultado ou uma mensagem de erro
if (num2 = 0) then begin  // SE num2=0 ENTÃO
   write('Infinito');  // escrever “INFINITO”
end
else begin  // SE NÃO
     writeln(num1/num2:0:3);  // escrever resultado
end;

Inclua-se no código do programa:

program primeira_calculadora;
uses crt;
var num1,num2:real;
 
begin
     writeln('CALCULADORA SIMPLES');
     write('Primeiro valor: ');
     readln(num1);
     write('Segundo valor: ');
     readln(num2);
     writeln;
     writeln(num1:0:3,' + ',num2:0:3,' = ',num1+num2:0:3);
     {a cláusula “:0:3” dá duas indicações: ocupar o espaço mínimo de 0 caracteres, arredondando o número a 3 casas decimais}
     writeln(num1:0:3,' - ',num2:0:3,' = ',num1-num2:0:3);
     writeln(num1:0:3,' * ',num2:0:3,' = ',num1*num2:0:3);
     write(num1:0:3,' / ',num2:0:3,' = ');
     if (num2 = 0) then begin  // SE num2=0 ENTÃO
        writeln('Infinito');  // escrever “INFINITO”
     end
     else begin  // SE NÃO
          writeln(num1/num2:0:3);  // escrever resultado
     end;
     readln;  // esperar pelo ENTER
end.

Considere-se uma escala de avaliações, numa escola, de 0 a 20 (de zero a vinte) valores. Considere-se a negativa uma avaliação abaixo de 10 e a positiva acima deste valor, inclusive. Utilizar-se-á apenas e tão-somente, neste exemplo, avaliações inteiras (números inteiros).

program avaliacoes;
uses crt;
var nota : integer;
 
begin
     write('Escreva a avaliacao, inteira, de 0 a 20: ');
     readln(nota);
     case nota of
          // falta a selecção de casos
     else writeln('Nota invalida');
     end;
     readln;
end.

Para seleccionar os casos, pode-se utilizar a noção de intervalo¹⁾, existente no Pascal. Evita-se escrever o caso de ser 0, de ser 1, 2, 3 e por aí adiante. Se se quiser que o caso de a avaliação ser “FRACO” seja no intervalo de 0 a 3, inclusive, pode-se escrever este intervalo como 0..3

Então, faça-se a selecção de casos no programa:

program avaliacoes;
uses crt;
var nota : integer;
 
begin
     write('Escreva a avaliacao, inteira, de 0 a 20: ');
     readln(nota);
     case nota of
          0..3 : writeln('Fraco');
          4..9 : writeln('Insuficiente');
          10..12 : writeln('Pouco Suficiente');
          13..15 : writeln('Suficiente');
          16..18 : writeln('Bom');
          19..20 : writeln('Excelente')
     else writeln('Nota invalida');
     end;
     readln;
end.

Pegue-se no programa anterior e acrescentasse-lhe dois ciclos Repeat… Until…. Um para analisar a nota assim que é introduzida, e outro para controlar o fecho do programa: caso o utilizador escreva “1” o programa volta a pedir uma avaliação, caso contrário fecha o programa. A estrutura para analisar a introdução da avaliação terá de ser a seguinte:

repeat
      write('Escreva a avaliacao, inteira, de 0 a 20: ');
      readln(nota);
until (nota>=0) and (nota<=20);

Pode-se ainda avisar o utilizador caso falhe a introdução da avaliação com uma estrutura de decisão:

repeat
      write('Escreva a avaliacao, inteira, de 0 a 20: ');
      readln(nota);
      if not ((nota>=0) and (nota<=20)) then begin
         writeln('Erro! Nao esta no intervalo 0 a 20!');
         writeln;
      end;
until (nota>=0) and (nota<=20);

Para controlar o fecho do programa, necessita-se de uma variável de controlo, à qual chamar-se-á fecho e será do tipo integer.

repeat
      // programa todo
      write('“1” para reiniciar, outro número para sair: ');
      readln(fecho);
until (fecho<>1);

Implemente-se agora estas duas estruturas no programa:

program avaliacoes;
uses crt;
var nota, fecho : integer;
 
begin
     repeat
           repeat
                 write('Escreva a avaliacao, inteira, de 0 a 20: ');
                 readln(nota);
                 if not ((nota>=0) and (nota<=20)) then begin
                   writeln('Erro! Nao esta no intervalo 0 a 20!');
                   writeln;
                 end;
           until (nota>=0) and (nota<=20);
           case nota of
                0..3 : writeln('Fraco');
                4..9 : writeln('Insuficiente');
                10..12 : writeln('Pouco Suficiente');
                13..15 : writeln('Suficiente');
                16..18 : writeln('Bom');
                19..20 : writeln('Excelente')
           else writeln('Nota invalida');
           end;
           writeln;
           write('“1” para reiniciar, outro número para sair: ');
           readln(fecho);
     until (fecho<>1);
end.

Propostas de Exercícios 1. Crie a sua própria calculadora. Contudo, o utilizador terá de escolher a operação a realizar e, no caso de esta ser a divisão, o programa terá de impedir o utilizador de introduzir denominador 0 (zero), obrigando-o a introduzir outro valor para tornar a divisão possível. Mostre uma mensagem de erro neste caso. As variáveis para os valores das operações a realizar terão de ser reais, e a que selecciona a operação deverá ser uma string. Mostre ao utilizador o maior número de informações possíveis sobre a calculadora. Mas não sobre o que o programa está a processar no momento, como “A realizar a soma”. Normas:

• Limite máximo de linhas de código (exclusive comentários e linhas em branco): 40 linhas.

Para ordenar uma lista de valores, peça-se ao utilizador para criar uma lista de dez números inteiros, e de seguida mostra-se a lista por ordem crescente. Comece-se por definir as variáveis necessárias:

program crescente;
var lista : array [1..10] of integer;  // lista de 10 inteiros
    i, j : integer;  // dois contadores para os ciclos FOR
 
begin
 
end.

O programa será feito, doravante, por partes. Começa-se por pedir os 10 valores da lista ao utilizador:

     writeln('INTRODUZA OS 10 VALORES DA LISTA:');
     for i:=1 to 10 do begin
         write('Valor nº', i, ': ');
         readln(lista[i]);
     end;

Para ordenar a lista pode-se utilizar o seguinte método. Começando pelo primeiro valor, analisa-se cada número com todos os restantes valores da lista. Caso encontre um menor que este, trocam-se directamente. De seguida, analisa o segundo valor, e compara-o com os seguintes, mas NÃO com os anteriores (neste caso, o primeiro). O processo repete-se até ao último valor da lista. Exemplo:

Lista: 7 » 9 » 5 » 2 Processo: 1. “Pega” no primeiro valor da lista e compara:

• 9 < 7 – falso: 7 » 9 » 5 » 2
• 5 < 7 – verdade: 5 » 9 » 7 » 2

Agora o primeiro valor é o 5, e a análise continua:

• 2 < 5 – verdade: 2 » 9 » 7 » 5

Como se verifica, o número mais baixo da lista ficou em primeiro lugar. 2. Compara com o segundo valor da lista:

• 7 < 9 – verdade: 2 » 7 » 9 » 5

Agora o segundo valor é o 7.

• 5 < 7 – verdade: 2 » 5 » 9 » 7

3. Agora, com o terceiro valor:

• 7 < 9 – verdade: 2 » 5 » 7 » 9

E termina aqui a análise. Como se verifica, este processo coloca a lista toda por ordem crescente. Em código, necessitar-se-á de uma variável auxiliar para realizar a troca, chamada aux:

     for i:=1 to 10 do begin
         for j:=i to 10 do begin
             if (lista[j]<lista[i]) then begin
                aux:=lista[j];
                lista[j]:=lista[i];
                lista[i]:=aux;
             end;
         end;
     end;

Só resta mostrar a lista por ordem crescente obtida:

     write('Lista por ordem crescente: ');
     for i:=1 to 10 do begin
         write(lista[i],'; ');
     end;

Resta implementar estas partes no programa final:

program crescente;
var lista : array [1..10] of integer;  // lista de 10 inteiros
    i, j : integer;  // dois contadores para os ciclos FOR
    aux : integer;  // auxiliar para troca de valores em lista
 
begin
     writeln('INTRODUZA OS 10 VALORES DA LISTA:');
     for i:=1 to 10 do begin  // lê a lista
         write('Valor nº', i, ': ');
         readln(lista[i]);
     end;
 
     for i:=1 to 10 do begin  // coloca a lista por ordem crescente
         for j:=i to 10 do begin
             if (lista[j]<lista[i]) then begin
                aux:=lista[j];
                lista[j]:=lista[i];
                lista[i]:=aux;
             end;
         end;
     end;
 
     write('Lista por ordem crescente: ');
     for i:=1 to 10 do begin  // mostra a lista, agora ordenada
         write(lista[i],'; ');
     end;
     writeln;
     write('ENTER para sair. . .');
     readln;
end.

Propostas de Exercícios 2. Crie um contador de avaliações positivas de uma turma. O utilizador deverá introduzir o número de alunos que a turma tem, e de seguida o programa pedirá a avaliação de cada aluno. Para tal, o programa deverá ter um controlo da avaliação introduzida, para que esta esteja dentro de intervalo 0 a 20 valores. No final, o programa irá devolver quantas avaliações positivas existem, apresentando a percentagem, arredondada às décimas. Normas:

• O programa não deverá ter mais do que um ciclo for;
• Limite máximo de linhas de código (exclusive comentários e linhas em branco): 20 linhas.

3. Crie um programa que debite o maior de todos os n valores introduzidos pelo utilizador, sendo os n números a introduzir definidos pelo utilizador. O limite mínimo é 5 e o máximo é 50. Normas:

• O programa não deverá ter nenhum ciclo for;
• Limite máximo de linhas de código (exclusive comentários e linhas em branco): 25 linhas.

Imagine-se que é necessário saber quantos espaços e quantas palavras tem uma frase: é necessário um programa que conte o número de espaços que se encontra numa frase. Pede-se ao utilizador para escrever uma frase, e o programa dirá o número de espaços e de palavras que encontrou.

Primeiro, o contador de espaços:

program contador;
uses crt;
var frase : string;
    i, contaespacos, contapalavras : integer;
 
begin
     write('Introduza uma frase a sua escolha: ');
     readln(frase);
     for i:=1 to length(frase) do begin  // contador de espaços
         if (frase[i]=' ') then contaespacos:=contaespacos+1;
     end;
end.

Uma palavra está entre espaços, e esta é a base para a análise de palavras neste programa:

program contador;
uses crt;
var frase : string;
    i, contaespacos, contapalavras : integer;
 
begin
     write('Introduza uma frase a sua escolha: ');
     readln(frase);
 
     contaespacos:=0;
     for i:=1 to length(frase) do begin  // contador de espaços
         if (frase[i]=' ') then contaespacos:=contaespacos+1;
     end;
 
     contapalavras:=0;
     if (frase[1]=' ') and (frase[2]<>' ') then contapalavras:=1;
     // Poderá haver um espaço a começar a string "frase". Este código prevê esta situação.
     if frase[1]<>' ' then contapalavras:=1;
     // verifica igualmente se o primeiro caracter NÃO é um espaço, contando então uma palavra.
     for i:=2 to length(frase) do begin  // análise da restante string, já com a existência da primeira palavra prevista
         if (frase[i]=' ') and (upcase(frase[i+1]) in ['A'..'Z']) then contapalavras:=contapalavras+1;
         {se o actual caracter da frase é um espaço e o próximo é uma letra, então acabou a palavra - soma 1 ao contador}
     end;
 
     writeln('A frase contem ',contapalavras,' palavras, assim como ',contaespacos,' espacos');
     readln;
end.

Propostas de Exercícios 4. Crie um programa que elimine os espaços a mais. O utilizador introduz uma frase à sua escolha, e o programa irá eliminar os espaços a mais, reduzindo-os a um só, entre cada palavra. Normas:

• Terá de utilizar somente ciclos for;
• Limite máximo de linhas de código (exclusive comentários e linhas em branco): 30 linhas.

Para treinar a criação de uma função, um bom exemplo é o da tangente de um número (ângulo), já que o Pascal não tem uma. Ter-se-á de ter em atenção que cos(a) não pode ser 0 (zero), pois:

tg(a) = sen(a) / cos(a)

Nesse caso, o programa dirá que a tangente não é possível. Para saber se é possível, criar-se-á outra função que indica tal.

program tangente;
uses crt;
var a : real;
 
function tan(angulo:real):real;  // tangent = seno / co-seno
begin
     tan:=sin(angulo)/cos(angulo);
end;
 
function tangente_possivel(angulo:real):boolean;  // a tangente é possível se o co-seno for diferente de zero
begin
     if (cos(angulo)=0) then tangente_possivel:=false
     else tangente_possivel:=true;
end;
 
begin
     write('Introduza angulo, em radianos: ');
     readln(a);
     if tangente_possivel(a) then writeln('Tangente de ',a:0:10,': ',tan(a):0:10)
     else writeln('Tangente de ',a:0:10,': infinito');
     readln;
end.

Propostas de Exercícios 5. Crie um programa que calcule o factorial de um número. O programa deverá analisar se o valor introduzido é inteiro ou não, e se é positivo, ou seja, a variável que lê o número é real. Deverá prever a situação especial do factorial de zero. Normas:

• Terá de utilizar uma função para cálculo do factorial;
• Limite máximo de linhas de código (exclusive comentários e linhas em branco): 30 linhas.

Parte I << | >> Parte III