Comando de Iteração (DO WHILE-LOOP)

A idéia básica da iteração é fazer com que uma série de comandos seja repetida enquanto uma determinada condição for verdadeira; quando a condição se tornar falsa, a repetição termina.

O comando básico de iteração (embora não seja o único comando capaz de iterar) é o comando DO WHILE-LOOP. Este comando possui o seguinte formato:

Do While Condição
Comando 1
$\vdots$
Comando N
Loop
Comando N+1

A região entre o início do comando, em Do While, e seu fim, em Loop, é chamada de malha, laço, ciclo ou, no original em inglês, ``loop''.

O comportamento do comando DO WHILE-LOOP é o seguinte: inicialmente a condição é testada. Se for falsa, nenhum comando dentro da malha é executado, e a execução prossegue no comando N+1. Se a condição for verdadeira, o programa prossegue executando um a um os comandos de 1 a N. Ao terminar o comando N, ou seja, ao atingir a instrução Loop, o programa volta ao início da malha e testa a condição novamente. Se ela continuar verdadeira então novamente são executados os comandos de 1 a N; caso contrário, a iteração termina e o programa sai da malha e prossegue a partir do comando N+1.

Desta forma, a condição de entrada controla quantas vezes a iteração será repetida. Enquanto ela permanecer verdadeira, o interior da malha será repetido. Pode ser que ela nunca fique falsa; isso quer dizer que o programa não pára nunca, e é um programa defeituoso. Portanto, bastante cuidado com o uso da iteração.

Por exemplo, vejamos o programa elevadoa(X,Y) que calcula X^Y. A idéia básica é multiplicar o número X por ele mesmo Y vezes, ou seja:

X^Y = 1 * X * ... * X onde X aparece Y vezes.

O valor 1 aparece como um valor inicial e, obviamente, não influencia o resultado final. Além disso, a presença do número 1 no cáculo garante que o resultado seja correto mesmo quando Y = 0, pois nesse caso X⁰ = 1:

Function elevadoa(Num As Integer, expoente As Integer) As Integer
Dim cont As Integer
Dim result As Integer
'Inicialização
result = 1
cont = 0
'Malha principal
Do While cont < expoente
result = result * Num
cont = cont + 1
Loop
'Finalização
elevadoa = result
End Function

Vejamos agora como calcular o fatorial de um número inteiro N, normalmente representado por N!:

N! = N * N-1 * N-2 * ... * 2 * 1

Uma das formas possíveis para computarmos o fatorial de um número é procedermos da direita para a esquerda, ou seja, começamos com um contador com o número 1, vamos incrementado-o e armazenado o valor da multiplicação em um acumulador de resultados intermediários, da seguinte forma: a cada passo da iteração, incrementamos o contador e multiplicamos esse valor pelo acumulador, armazenando o resultado no próprio acumulador. O processo continua até que o contador alcance o valor de N. Nesse instante o acumulador terá o valor do fatorial desejado:

Function fatorial(Num As Integer) As Integer
Dim cont As Integer
'contador do numero atual
Dim result As Double
'acumulador do resultado parcial
'Inicialização
result = 1
cont = 1
'Malha principal
Do While cont <= Num
result = result * cont
cont = cont + 1
Loop
'Finalização
fatorial = result
End Function

Vamos estudar o caso agora de juros compostos com uma taxa de juros que varia progressivamente com o tempo, em incrementos fixos. Por exemplo, podemos ter uma taxa de juros inicial de 2% e incrementos de 0.1% mensais: no primeiro mês a taxa de juros será de 2%, no segundo será 2,1%, etc. até o décimo-primeiro mês, quando será de 3%. Um dado capital inicial deverá sofrer juros compostos (acumulados) onde a taxa mensal varia progressivamente. Uma função que calcula o capital acumulado ao final de vários meses é a seguinte:

Function JurosProgr(CapIni As Double,TaxaIni As Double,IncrTaxaMensal As Double,NMeses As Integer) As Double
'Computa o capital final com juros progressivos: a taxa de juros
'vai sendo incrementada mensalmente pelo valor IncrTaxaMensal (que
'pode ser negativo!!!)
Dim mes As Integer
'Número de meses desde o início do investimento
Dim TaxaAtual As Double
'Taxa do mes corrente
Dim CapAtual As Double
'Capital ao final do mes corrente
'Inicialização
CapAtual = CapIni
'Capital no iníco do primeiro mês
TaxaAtual = TaxaIni
'Taxa no início primeiro mês
mes = 1
'Primeiro mes

'Malha principal
Do While mes <= NMeses
'Calcula o capital no final do mês corrente
CapAtual = CapAtual * (1 + TaxaAtual / 100)
'Próximo mês
mes = mes + 1
'Calcula a taxa do próximo mês
TaxaAtual = TaxaAtual + IncrTaxaMensal
Loop
'Retorno da função
JurosProgr = CapAtual
'Capital ao fim de NMeses
End Function

Exercícios

1.

Fazer um programa que calcule a soma dos N primeiros números inteiros: 1 + 2 + 3 + ... + N

Fazer uma planilha que testa este programa para valores de N= 1, 5, 10, 15, 25

2.

Fazer uma função S(N) que calcule a seguinte soma para N termos: $S(N) = 1 - 4 + 9 - 16 + 25 - \ldots$

Fazer uma planilha que testa este programa para valores de N= 1, 5, 10, 15, 25.

3.

Dados dois inteiros positivos N e P, escreva uma função que calcula a combinação de N sobre P:

$\frac{N * (N-1) * (N-2)* \ldots * (N-P+2) * (N-P+1) } {P * (P-1) * (P-2)* \ldots * 2 * 1 }$

Note que tanto o numerador quando o denominador possuem P fatores. A combinação de N sobre P pode ser também expressa por $\frac{N!}{P! * (N-P)!}$. Computacionalmente, a primeira versão é a mais eficiente, voce sabe explicar por quê? (Dica: conte o número de iterações em cada caso). A função deve retornar 1 se $P \geq N$.

Fazer uma planilha para N=10 e P variando de 0 a 15.

4.

(a)

Fazer uma função PA(N,A₁,R) que calcula o N-ésimo termo de uma progressão aritmética de termo inicial A₁ e razão R. Lembre-se de que A_i = R + A_i-1.

(b)

Fazer uma função PG(N,A₁,R) que calcula o N-ésimo termo de uma progressão geométrica de termo inicial A₁ e razão R. Lembre-se de que A_i = R * A_i-1.