Estrutura de repetição

Estrutura de repetição para

Essa estrutura de repetição é usada quando sabemos o número de vezes que um trecho do algoritmo deve ser repetido.

para i de 1 ate 15 faça 
inicio 
     <comando1>
     <comando2>
     ...
     <comandon>
fim 

Os comandos serão executados um após o outro utilizando a variável i como controle, e seu conteúdo vai variar do valor inicial até o valor final.

Podemos dizer para ele pular de 1 em 1 (padrão) como no exemplo acima ou podemos especificar de 2 em 2, de 3 em 3 etc. Observe:

para i de 1 ate 15 faça passo 2
inicio 
     <comando1>
     <comando2>
     ...
     <comandon>
fim 

Estrutura de repetição enquanto

Essa estrutura de repetição é usada para um número indefinido de repetições com teste no início.

enquanto (<condição>) faça
inicio
     <comando1>
     <comando2>
     ...
     <comandon>
fim

Embora seja utilizada para um número indefinido de repetições também pode ser usada quando sabemos esse número.

x <- 1
y <- 6
enquanto (x < y) faça
inicio
     x <- x + 2
     y <- y + 1
fim

Funcionamento:

A estrutura de repetição teve 5 laços. Nesse caso foi repetido um número indefinido de vezes. Imagine que o valor de x fosse 1547892435 saberia dizer quantos laços foram necessários para satisfazer a condição? Agora veja:

x <- 1
y <- 1
enquanto (x <= 6) faça
inicio
     x <- x * y
     x <- x + 1
fim

Funcionamento:

Nesse caso sabemos quantas vezes a estrutura ira repetir, pois, x é acrescido de 1 ao final de cada laço e como o laço termina com x sendo igual a 6 teremos 6 repetições.

Estrutura de repetição repita

repita
     <comando1>
     <comando2>
     ...
     <comandon>
até que (<codição>)

Essa estrutura de repetição, assim como o enquanto, é utilizada quando não se conhece o número de vezes que um trecho do algoritmo deve ser repetido, mas também pode ser utilizado quando sabemos esse número.

A estrutura repita tem como base uma condição. A repetição ocorre até que a condição seja satisfeita. A principal diferença entre a estrutura enquanto e a estrutura repita é que nesta última os comandos serão repetidos pelo menos uma vez já que a verificação é feita no final do laço.

x <- 1
y <- 6
repita
     x <- x + 2
     y <- y + 1
até que (x >= y)

A estrutura repita aqui tem o mesmo funcionamento mostrado na tabela 1.1 porém a verificação é feita sempre no final do laço e da mesma forma como aconteceu com a estrutura enquanto não sabemos quantas vezes irá repetir.

Agora observe o caso abaixo e veja que é possível saber quantas vezes a estrutura irá se repetir.

x <- 1
y <- 6
repita
     x <- x * y
     x <- x + 1
até que (x = 6)

Algoritmo SalariodeUmEstranho
var
     i, ano_atual, salario, novo_salario, percentual: real
início
     salario <- 1000
     percentual <- 1.5/100
     novo_salario <- salario + percentual*salario
     ano_atual <- 2022

     para i de 2007 até ano_atual faça
     inicio
          percentual <- 2*percentual
          novo_salario <- novo_salario + percentual*novo_salario
     fim
     escreva(novo_salario)
fim.

Algoritmo UmaFormulQqFatorial
var
     n, e, i, j, fatorial: inteiro
início
     escreva("Digite o valor de n: ")
     leia(n)

     e <- 1

     para i de 1 até n faça 
     início
          fatorial <- 1
          para j de 1 até i faça
          inicio
               fatorial <- fatorial*j
          fim 
          e <- 1/fatorial
     fim
     escreva(e)
fim.

Algoritmo UmFatorialQq
var
     n, num, i, j, fatorial: inteiro
início
     escreva("Digite o valor de n: ")
     leia(n)

     e <- 1

     para i de 1 até n faça 
     início
          leia(num)
          fatorial <- 1
          para j de 1 até num faça
          inicio
               fatorial <- fatorial*j
          fim 
          e <- 1/fatorial
     fim
     escreva(e)
fim.