5.1 - INTRODUÇÃO
Até agora, escrevemos alguns algoritmos utilizando uma linguagem com caráter narrativo. Nós praticamente contamos a história das ações praticadas sobre os objetos. E para esta prática, usamos muitos elementos (verbos, adjetivos, substantivos,...) de uma linguagem natural. Quando trabalhamos textos com muitos elementos de uma linguagem, podemos cair no problema da ambigüidade, além do texto ficar muito extenso.
Considerando estes fatos, padronizaremos uma linguagem algorítmica que utilizará um número pequeno de elementos; os quais serão chamados de ações ou instruções.
Estas ações utilizarão tanto recursos textuais como gráficos, mas terão uma sintaxe e uma semântica própria que não deixará vazão à dupla interpretação do texto escrito. Isto significa que o texto que escrevermos nesta linguagem, ou estará absolutamente correto, ou absolutamente errado. Pois cada ação deverá ter um significado lógico no contexto de sua aplicação.
Para facilitar o entendimento lógico dos algoritmos usaremos os seguintes fluxogramas:
Início e Termino do fluxo Entrada de dados / conheça ou leia Saída de dados / informe ou escreva Processos / instrução ou comando Decisão
Repetição Conector
5.2 - ESTRUTURA FÍSICA GERAL DE UM ALGORITMO
Padronizaremos aqui, uma estrutura única de escrita de todos os algoritmos, o qual será composto de duas partes:
2ª.) o corpo do algoritmo, onde deverão ser descritas as ações que o algoritmo deve executar.
var identificadores : tipo;
{área de definição dos objetos que serão manipulados pelas ações do algoritmo}
início {início das descrições das ações do algoritmo} {corpo do algoritmo}
fim. {fim do algoritmo}
5.3 - INSTRUÇÃO DE ENTRADA – COMANDO LEIA
Um algoritmo descreve as ações que manipulam dados iniciais para transformá-los em uma solução de um problema qualquer. Quando estes dados devem ser fornecidos em tempo de execução do algoritmo, dizemos que os mesmos pertencem ao conjunto de argumentos de entrada do algoritmo, pois sem os mesmos, não é possível ao indivíduo que o está executando obter a solução do problema.
Na forma narrativa, os argumentos de entrada são fornecidos através da instrução: conheça o valor da altura do triângulo e atribua-o ao objeto altura;
Na nossa linguagem algorítmica, isto resumir-se-á em:
leia (altura);
Na sintaxe geral desta ação é: leia (identl, ident2, ..., identN);
onde: ident1, ident2, ..., identN são os identificadores que pertencem ao conjunto de argumentos de entrada do algoritmo.
Exemplo de uso: leia (altura, base);
Semântica desta instrução será: leia dois valores. Associe o primeiro valor ao identificador altura e o segundo valor ao identificador base.
Assim, se tivermos como dados de entrada os valores 3 e 5, o valor de altura será 3 e da base 5. início corpo do algoritmo fim. leia
5.4 - INSTRUÇÃO DE SAÍDA – COMANDO ESCREVA
A solução que um algoritmo deve produzir, pertence ao conjunto de argumentos de saída do algoritmo. Este conjunto serve para informar ao indivíduo que executa o algoritmo, que aquele dado é a solução do problema que estamos procurando.
Na forma narrativa, utilizamos a seguinte ação para que seja informado o valor do argumento de saída:
informe o valor associado ao objeto área;
Na nossa linguagem algorítmica, isto resumir-se-á em: escreva (área);
A sintaxe geral desta ação é escreva (identl, ident2, ..., identN);
onde: ident1, ... identN são idenficadores que pertencem ao conjunto de argumentos de saída do algoritmo.
Exemplo: escreva (raizl, raiz2);
A semântica desta instrução será: escreva o valor associado ao identificador raiz1 e em seguida escreva o valor associado ao identificador raiz2.
Assim, se tivermos, em um dado momento, os seguintes valores associados a raiz1 e raiz2.
raiz1 raiz2
5.5 - COMENTÁRIOS
Os comentários dentro de um algoritmo devem ser usados para explicar a finalidade de cada identificador e também explicar o porque do uso de certas instruções em um algoritmo, principalmente nos pontos de maior dificuldade lógica de solução.
Um comentário deve explicar o porque do uso das instruções. Não se deve usar comentários para explicar o que uma instrução faz, isto é redundante. Exemplo:
st sf + se; {somando sf e se}
Isto é um comentário redundante, basta olhar para a instrução que conseguimos ver que se está somando sf e se. Supondo que sf represente o salário fixo de um funcionário, e que se represente o salário extra do mesmo, poderíamos ter:
-3 2.5
st sf + se; {cálculo do salário total do funcionário}
Os comentários não têm nenhum efeito lógico sobre o algoritmo. Eles apenas nos ajudarão a lembrar para que servem os identificadores declarados, e/ou esclarecer o que determinadas partes do algoritmo fazem.
Todo o texto que for usado como comentário, deverá ser escrito entre chaves ({}). {isto é um comentário}
5.6 - INSTRUÇÕES DE SEQÜENCIALIDADE
Nas linguagens naturais, nós utilizaremos um certo conjunto de pontuação (.,;?!), os quais nos permite saber onde começa e onde termina uma frase, dentre outras funções.
Na nossa linguagem algorítmica, também teremos que indicar o começo e fim de uma instrução. Para esta função, usaremos o ponto-e-vírgula (;).
Exemplo de uso: inst1;
inst2; {inst = instrução} …….
instN;
5.7 - INSTRUÇÃO DE ATRIBUIÇÃO
Os valores de dados são associados aos identificadores através de uma ação de atribuição. É necessário certificar-se de que o valor de dado e o identificador sejam de tipos compatíveis.
Na forma narrativa, escrevemos da seguinte forma as ações de atribuição: atribua o valor 3.14 ao objeto PI;
calcule a expressão A + B e atribua o resultado ao objeto SOMA;
Na nossa linguagem algorítmica o símbolo será utilizado para representar a ação de atribuição.
A sintaxe geral desta ação é: ident expressão; inst1; instN; inst2; início fim. ident expressão;
onde:
ident representa o identificador que irá receber o valor dado
representa a ação de atribuição
expressão representa o valor de dado que irá ser atribuído ao identificador. Podendo ser de origem constante, ou, associado a outro identificador, ou ser resultado de uma expressão.
Exemplo de uso:
pi 3.14; c a;
soma a + b;
A semântica desta ação será: atribua ao identificador à esquerda o valor da expressão à direita.
pi 3.14 {atribua a PI o valor 3. l4}
c a; {atribua a c o valor associado ao identificador a} soma a + b; {atribua a soma o resultado da expressão a + b} Vamos supor o nosso algoritmo, escrito na forma narrativa, para calcular a área de um triângulo retângulo sendo conhecidos a sua base e sua altura.
ae (base, altura); as (área);
objetos base, altura, área: real; início das ações:
conheça o valor da altura do triângulo e o atribua ao objeto altura; conheça o valor da base da triângulo e o atribua ao objeto base;
calcule a expressão altura.base/2 e armazene o resultado no objeto área; informe o valor armazenado no objeto área;
fim das ações.
Este mesmo algoritmo escrito na nossa nova linguagem algorítmica, terá o seguinte formato.
var
base, altura, area : real; início
leia(base, altura); area base * altura / 2; escreva(area);
fim.
area base * altura / 2;
início
fim. leia(base, altura);
5.8 - EXERCÍCIOS RESOLVIDOS
R.4.1 - Faça um algoritmo que calcule as raízes reais de uma equação do 2°. grau do tipo: ax2 + bx + c = 0.
Solução:
Para que possamos resolver problemas deste tipo, devemos ter em mãos os valores coeficientes a, b e c para calcularmos as raízes reais r1 e r2 usando a equação de Báscara:
2a ac 4 b b - 2 − ±
Utilizaremos também, o objeto DELTA como auxiliar para facilitar evitando assim, o processamento de cálculos repetidos.
var a, b, c, r1 , r2, delta : real; início leia (a, b, c); delta b**2-4*a*c; r1 (-b + delta ** (1 / 2)) / (2 * a); r2 (-b - delta ** (1 / 2)) / (2 * a); escreva(r1, r2); fim.
R.4.2 - Faça um algoritmo que calcule o resto da divisão (inteira) de um número inteiro por 2. Solução:
Numa divisão real, o resto da divisão é sempre zero. Mas numa divisão inteira nem sempre isto acontece. Veja o exemplo:
4 2 5 2 n 2
0 2 1 2 r q onde: n = n°. inteiro, q = quociente e r = resto.
4 = 2 x 2 + 0 5 = 2 x 2 + 1 n = 2 x q + r Como queremos r r = n - 2 x q , r1 (-b+delta**(1/2))/(2*a); início fim. leia(a, b, c); escreva(r1, r2); delta b**2-4ac; r2 (-b-delta**(1/2))/(2*a);
onde q é a parte inteira da divisão real de n por 2 ou (n / 2).
Logo, para calcularmos o resto da divisão inteira entre dois números inteiros temos que: r = n - 2 (parte inteira de (n/2))
Como calcular a parte inteira de um número real?
A partir deste ponto, necessitamos definir algumas funções matemáticas, as quais serão inseridas na nossa linguagem algorítmica.
Função Tipo de argumento Tipo de Resultado
e inteiro/real inteiro/real valor absoluto
e inteiro/real inteiro parte inteira[ ]
e inteiro/real real parte fracionáriaAssim, nossa equação fica r = n - 2 (
n / ): 2
para n = 4, teremos para n = 5, teremos
r = 4 - 2 (
4 / 2
) r = 5 - 2 (
5 / 2
) r = 4 - 2 (
2.0 )
r = 5 - 2 (
2.5 )
r = 4 - 2 (2) r = 5 - 2 (2) r = 4 – 4 r = 5 - 4 r = 0 r = 1 var n, resto : inteiro; início leia (n); resto r = n - 2 (
n / ); 2
escreva (resto); fim. resto r = n - 2 (
n /2
); inícioleia(n, resto); altura);
fim. escreva(resto);
R.4.3 - Faça um algoritmo que troque os valores de dois identificadores inteiros.
var
numl, num2 : inteiro; início
leia (numl, num2); num1 num2; num2 num1; escreva(numl, num2); fim.
Ás vezes nós praticamos certas ações que nos parecem corretas. Mas a confiabilidade de um algoritmo necessita ser provada. Para provar a confiabilidade de um algoritmo, devemos testar a sua dinâmica, ou seja, executar manualmente cada instrução do algoritmo e observar o que acontece com os identificadores em função das ações que sobre eles atuam. A este teste, damos o nome de teste de mesa.
Para fazer um teste de mesa, primeiramente devemos discriminar todos os identificadores que estão envolvidos no processo, os quais devem estar relacionados na lista de objetos do algoritmo.
num1 num2
O segundo passo é executar as ações contidas no algoritmo uma a uma, obedecendo a ordem em que as mesmas aparecem no papel. Os valores que devem ser fornecidos aos argumentos de entrada do algoritmo são hipotéticos. Caso o algoritmo tenha mais de uma possibilidade de execução (o que ocorre em processos de seleção, o que não é o nosso caso, por enquanto) devemos executar o algoritmo tantas vezes quanto forem as suas possibilidades, com valores de entrada devidamente selecionados para a verificação de cada possibilidade do algoritmo.
Por enquanto, nos é suficiente escolher dois valores simples, como, por exemplo, 2 e 3.
1ª. instrução do algoritmo: leia(num1, num2);
num1 num2 num1 num2; início fim. leia(num1, num2); escreva(num1, num2); num2 num1; 2 3
2ª. instrução do algoritmo: num1 num2;
O identificador num1 está associado ao valor 2. Mas com esta ação é feita uma nova associação do identificador com o conteúdo de num2. Um identificador não pode estar associado a dois valores ao mesmo tempo, devido ao fator ambigüidade, logo esta instrução faz com que seja feita uma cópia do conteúdo de num2 e esta cópia é associada com o identificador num1. Como o mesmo já possuía um valor associado (2), esta associação é desfeita, para que ela possa ser refeita com o novo valor.
Lembre-se, um identificador só pode representar um único valor de dado de cada vez, e sempre representará o último valor que for atribuído a ele.
num1 num2
2
3ª. instrução do algoritmo: num2 num1
num1 num2
Veja o aspecto interessante ambos os identificadores estão associados com valores iguais logo a ação de atribuir o valor de num1 para num2, faz com que num2 se dissocie de seu valor, 3, e seja associado ao valor de num1, que também é 3;
4ª. instrução do algoritmo: escreva(num1, num2);
num1 num2
O resultado produzido é: 3; 3. O valor 2 desapareceu dentro do processo no nosso algoritmo. É óbvio que alguma coisa saiu errado.
O problema todo ocorreu quando atribuímos num2 a num1 (2ª. instrução), pois como um identificador só pode ser associado a um valor por vez, foi necessário que num1 se dissociasse do valor 2 para fazer a nova associação com o valor 3 originado de num2. E com isto o valor 3 ficou repetido em ambos os identificadores.
Para corrigir este erro é necessário "salvar" o valor de num1 em um terceiro identificador, para que o mesmo não seja perdido no processo.
Utilizaremos o identificador aux como auxiliar. A função do mesmo será a de salvar o valor do identificador num1, para que o mesmo não seja perdido.
3 3
3 3
var
numl, num2, aux : inteiro; início
leia (numl, num2); aux num1; num1 num2; num2 aux;
escreva(numl, num2); fim.
Experimente fazer agora o teste de mesa sobre este novo algoritmo. num1 num2; início fim. leia(num1, num2); escreva(num1, num2); aux num1; num2 aux;
