Capítulo 2 – parte 2

Share

2.3 – Técnicas de desenvolvimento de algoritmos

Algoritmos devem ser escritos para serem lidos por seres humanos. Além de corrigidos, mantidos e modificados, por você mesmo e por outras pessoas.

2.3.1 – Regras práticas para a construção de algoritmos legíveis

Escreva comentários no momento em que estiver escrevendo os algoritmos.
Ou seja, no momento em que você estiver atento aos detalhes do problema.

Os comentários devem acrescentar uma informação útil. Comandos dizem o que está sendo feito, comentários dizem o porquê ou descrevem detalhes. Se o algoritmo for modificado, revise os comentários.

Use espaços em branco para melhorar a legibilidade e aparência. Entre declarações e corpo do algoritmo. Separar grupos de comandos que executam
funções lógicas distintas. Indicar precedência de operadores (utilize A + B*C ao invés de A+B*C).

Escolha nomes representativos para as suas variáveis que identifique
o que elas representam. Ex: Preço ← Custo + Lucro ao invés de
P ← C + L.

Utilize um comando por linha e use identação nas estruturas de controle.

Use parênteses nas expressões para prevenir erros. Ex:

	 A*B*C/D*E*F → (A*B*C)/(D*E*F)
	 A**B**C → (A**B)**C
	 A/B/C/D → ((A/B)/C)/D
	 A>B OU X  → (A>B) OU X
 

Utilize identação em estruturas de controle e siga o mesmo padrão em todo o código.

2.3.2 – Técnicas de desenvolvimento

Um seqüência simples de passos pode auxiliar na construção de algoritmos:

  1. Leia a especificação do problema cuidadosamente até o final. Faça anotações.
  2. Releia a especificação até entender o problema. Peça mais informações caso não compreenda o problema.
  3. Analisar e tomar nota de todas as saídas(impressões) exigidas na especificação do problema. Defina tipos.
  4. Analisar e tomar nota de todas as entradas(leituras) citadas na especificação do problema. Defina tipos.
  5. Verificar se é necessário gerar valores internos (contadores, variáveis auxiliares) ao algoritmo e levantar as variáveis necessárias e os valores iniciais de cada uma.
  6. Analisar as transformações necessárias para gerar as saídas especificadas. Adicione comentários.
  7. Testar cada passo do algoritmo. Verificar se as transformações intermediárias executadas estão conduzindo aos objetivos desejados (acompanhamento do algoritmo).
  8. Fazer uma reavaliação geral. Elaborar o algoritmo através da integração das partes. Revisar também os comentários.

2.3.3 – Desenvolvimento de algoritmos por refinamentos sucessivos

O algoritmo é repartido em uma série de trechos, onde cada trecho descreve uma ação elementar. O conjunto das ações e estruturas de controle descrevem o algoritmo total. Se a ação for simples a ponto de poder ser expressa em um comando, usamos o comando em pseudo linguagem. Senão, usamos um pseudo comando, uma frase descritiva entre “<>”.

{
Faz a soma de números lidos pelo teclado.
Só são permitidos valores entre 20 e 30.
Valores fora desta faixa são travados no limite.
FLAG de saída -1;
}
algoritmo somaComLimite;
início
	inteiro: soma, valor;
	soma ← 0;
	leia(valor);
	enquanto <Houver dados> faça
		<Converte para valor válido>;
		soma ← soma + valor;
		leia(valor);
	fim-enquanto;
fim.

Em seguida descreve-se os detalhes de cada pseudo comando usando estruturas de
controle e outros pseudo comandos e/ou comandos em pseudo código.

Refinamento: <Houver dados>
	valor != -1;
Refinamento: <Converte para valor válido>
	se valor>30 então
		valor ← 30;
	fim-se;
	se valor<20 então
		valor ← 20;
	fim-se;

A partir daí repete-se o refinamento até que tenhamos todos os pseudo comandos descritos apenas em pseudocódigo.

2.4 – Algoritmos baseados em estruturas de dados homogêneos

2.4.1 – Estrutura de repetição com teste no final

Vamos definir uma segunda estrutura de repetição que funciona de modo complementar ao enquanto-faça. Nesta estrutura o teste é feito ao final do bloco a ser repetido. Desta forma temos que o bloco é executado pelo menos uma vez.

repita
	C1;
	C2;
	...
	Cn;
até <Condição>

Segue um exemplo das duas estruturas lado a lado para comparação:

I ← 1;			I ← 1;
repita			enquanto I<=10 faça
   imprima(I);		   imprima(I);
   I ← I + 1;		   I ← I + 1;
até I > 10;		fim-enquanto;

2.4.2 – Estrutura de repetição com variável de controle

Uma terceira estrutura de repetição tem a característica de integrar a definição, inicialização e incremento de uma variável de controle em apenas uma estrutura.

para <Variável> de <Valor Inicial> até <Valor Final> passo <Incremento> faça
	C1;
	C2;
	...
	Cn;
fim-para;

Segue um exemplo das três estruturas lado a lado para comparação:

I ← 1;			I ← 1;			para I de 1 até 10 passo 1 faça
repita			enquanto I<=10 faça	   imprima(I);
   imprima(I);		   imprima(I);		   I ← I + 1;
   I ← I + 1;		   I ← I + 1;		fim-para;
até I > 10;		fim-enquanto;

Atenção: o valor de I é indefinido fora do bloco da estrutura de repetição. Se o passo for igual a 1 não é necessário escrever esta especificação no comando.

2.4.3 – Estrutura de múltipla escolha

Para casos com um grande número de condicionais utiliza-se a estrutura de escolha.

	escolha <Expressão>
		caso v11,v12,...v1n: C1;
		caso v21,v22,...v2n: C2;
		...
		caso vn1,vn2,...vnn: Cn;
		senão Cs;
	fim-escolha;

Share

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

*