O documento aborda a lógica de programação, focando em estruturas de repetição como 'for', 'while' e 'do while'. Apresenta exemplos de algoritmos que utilizam essas estruturas para executar comandos repetidamente, incluindo a impressão de frases, cálculos de médias e somas. Além disso, discute a importância das condicionais para controlar as execuções dentro dos laços.

1. Estácio Idez
Lógica de
Programação PSEUDOCÓDIGO
REPETIÇÃO

2. ESTRUTURA DE REPETIÇÃO
★Permitem executar mais de uma vez um mesmo trecho
de código.
★Trata-se de uma forma de executar blocos de
comandos somente sob determinadas condições, mas
com a opção de repetir o mesmo bloco quantas vezes
for necessário

3. Faça um algoritmo exibindo 10 vezes a frase: “Eu amo aula de lógica”.
algoritmo "repeticao"
var
inicio
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
escreval ("Eu amo aula de lógica.")
fimalgoritmo

4. PARA
FOR

5. para <VARIÁVEL> de <VALOR INICIAL> ate <VALOR FINAL> [passo] <INCREMENTO>] faca
<COMANDOS>
fimpara
<VARIÁVEL>!é!a!variável!que!vai!fazer!a!contagem!do!número!de!repe7ção!dos!!
<COMANDOS>;!
!
<VALOR0INICIAL>0e0<VALOR0FINAL>0são,!!respec7vamente,!o!primeiro!valor!e!o!
!úl7mo!valor!!da!<VARIÁVEL>;!
!
passo0<INCREMENTO>!especifica!o!valor!de!mudança!da!<VARIÁVEL>.0
É!um!elemento!opcional!(por!isso!foi!indicado!entre!os!colchetes).!Caso!não!seja!
usado,!o!incremento!será!de!1.!Caso!se!deseje!um!incremento!com!valor!
diferente,!deveFse!u7lizar!esta!palavraFchave.!
!

6. algoritmo "repeticao"
var
contador : inteiro
inicio
para contador de 1 ate 10 faca
escreval ("Eu amo aula de lógica.")
fimpara
fimalgoritmo

7. algoritmo "loop"
var
num : inteiro
inicio
para num de 1 ate 10 faca
escreval ("Volta número ", num)
fimpara
fimalgoritmo

8. Escreva um algoritmo para exibir os números
inteiros, partindo de 0 até 20,
mas com variação de 2 na contagem.
Exemplo: 0, 2, 4, ..., 20.
INCREMENTO

9. algoritmo)"loop")
var)
num):)inteiro)
)
inicio)
)para)num)de)0)ate)20)passo)2)faca)
))))))) ) )escreval)("Número)",)num))
)fimpara)
fimalgoritmo)

10. Escreva um algoritmo para exibir todos os
números inteiros de 0 até 20 em ordem
decrescente.
INCREMENTO

11. algoritmo "loop"
var
num : inteiro
inicio
para num de 10 ate 0 passo -1 faca
escreval ("Número ", num)
fimpara
fimalgoritmo

13. algoritmo "loop"
var
soma, num: real
aux, numLoop: inteiro
inicio
escreva("Digite o número de loop: ")
leia(numLoop)
para aux de 1 ate numLoop faca
escreva("Digite um número: ")
leia(num)
soma <- soma + num
fimpara
escreval("A soma total do(s) ", numLoop, " loop(s) é: ", soma)
fimalgoritmo

14. Escreva um programa que leia um valor
correspondente ao número de jogadores de
um time de vôlei. O programa deverá ler uma
altura para cada um dos jogadores e, ao final,
informar a altura média do time.

15. algoritmo "loop"
var
qtdJogadores, aux : inteiro
altura, somaAlturas, mediaAlturas: real
inicio
escreva("Digite a quantidade de jogadores: ")
leia(qtdJogadores)
para aux de 1 ate qtdJogadores faca
escreva("Jogador nº", aux, ", digite a altura (metros): ")
leia(altura)
somaAlturas <- somaAlturas + altura
fimpara
mediaAlturas <- somaAlturas / qtdJogadores
escreval("A média de alturas dos Jogadores é: ", mediaAlturas:2:2)
fimalgoritmo

17. Escreva um algoritmo que leia 10
valores inteiros e ao final exiba:
a) a soma dos números positivos;
b) a quantidade de valores negativos.

18. algoritmo "loop"
var
loop, valor, contarNegativo, somaPositivos : inteiro
Inicio
para num <- 1 ate 10 faca
escreva ("Digite um valor: ")
leia (valor)
se valor > 0 entao
somaPositivos <- valor + somaPositivos
senao
contarNegativo <- contarNegativo + 1
fimse
fimpara
escreval ("A soma dos valores positivos é: ", somaPositivos)
escreval ("A quantidade de valores negativos digitadas foi: ", contarNegativo)
fimalgoritmo

20. ENQUANTO
WHILE

21. • Verifica(primeiro,(executa(depois;(
• Repete(somente(enquanto(<clausula>(=(verdade;(
enquanto <<clausula>> faca
<<comandos>>
fimenquanto

22. algoritmo "loop enquanto"
var
contador : inteiro
inicio
contador <- 1
enquanto contador <= 5 faca
escreval ("Volta numero ", contador)
contador <- contador + 1
fimenquanto
fimalgoritmo

23. algoritmo "loop enquanto"
var
repetirCadastro : caracter
nome : caracter
idade : inteiro
inicio
repetirCadastro <- "S"
enquanto repetirCadastro = "S" faca
escreva ("Nome")
leia (nome)
escreva ("Idade")
leia (idade)
escreval ("Cadastrar novamente? (S/N)")
leia (repetirCadastro)
fimenquanto
fimalgoritmo

24. Escreva um algoritmo que percorra os
números entre 100 e 200 e exiba apenas
os números ímpares
1. Usando a estrutura ENQUANTO
2. Usando a estrutura PARA

25. algoritmo "enquanto impar"
var
contador : inteiro
impar : real
inicio
contador <- 100
enquanto (contador >= 100) E (contador <= 200) faca
se (contador MOD 2 = 1) entao
escreval (contador)
fimse
contador <- contador + 1
fimenquanto
fimalgoritmo
ENQUANTO

26. algoritmo "para impar"
var
num : inteiro
inicio
para num de 100 ate 200 faca
se (num MOD 2 = 1) entao
escreval (num)
fimse
fimpara
fimalgoritmo
PARA

27. Faça um algoritmo que receba a média de
um aluno, se a média for maior ou igual a 7
exiba uma mensagem dizendo que o aluno
está aprovado caso contrário exiba
informando que o aluno está reprovado.
Caso o usuário digite alguma média menor
que zero ou maior que 10 peça que digite a
média novamente.

30. REPITA - ATÉ
DO - WHILE

31. As instruções de repetição servem para que uma determinada sequência de
instruções seja repetida um número finito de vezes. O número de repetições é
controlado por uma instrução lógica que caso VERDADEIRA executa as instruções do
laço e caso FALSA abandona o laço, seguindo para a primeira instrução após o
repita
“fimenquanto” .
<lista de comandos>
ate <expressão lógica ou relacional>

32. A diferença entre o REPITA e o
ENQUANTO é que será executado a
primeira vez o bloco de comandos sem
verificar a condição. Assim, só depois
do bloco ser executado uma vez é que
a condição vai ser testada