Algoritmos e Técnicas de Programação

Prof. Ivan Fontainha

ivan.alvarenga@pitagoras.com.br
 Bibliografia
• ARTERO, Marcio Aparecido; SCHEFFER, Vanessa
Cadan. Algoritmos e Lógica de programação.
Londrina: Editora e Distribuidora Educacional S.A.,
2018.

• ARTERO, Marcio Aparecido; SCHEFFER, Vanessa

Cadan. Algoritmos e Técnicas de programação.
Londrina: Editora e Distribuidora Educacional S.A.,
2018.

• FORBELLONE, A. L., EBERSPACHER, H., Lógica de

Programação, Makron Boorks, 1993.

• MANZANO, José Augusto N. G. & OLIVEIRA, Jayr

Figueiredo de, Algoritmos e Lógica para
Desenvolvimento de Programação de
Computadores, Érica, 1997.
 O que veremos:

Unidade 4: Conceitos de Programação

Seção 4.1 – Estruturas de repetição

3
 Algoritmos
Estruturas de Repetição

▪ Em alguns algoritmos temos a necessidade de repetir o

código várias vezes

▪ Podemos simplesmente copiar o código várias vezes no

algoritmo (o que tornaria o algoritmo grande) ou
utilizarmos o que chamamos de loops ou laços de
repetição
 Algoritmos
Estruturas de Repetição

▪ Quando iniciamos um loop ou laço de repetição

devemos sempre garantir que ele terminará em algum
momento.

▪ Isto é:
▪ sempre devemos ter dentro do bloco algum
método que force a condição a ser falsa
(caso contrário o laço continuará eternamente...)
 Algoritmos
Estruturas de Repetição

▪ Temos 3 tipos de estrutura de repetição:

▪ Repetição com teste no início;

▪ Repetição com teste no final;

▪ Repetição com variável de controle.

 Algoritmos
Estruturas de Repetição

▪ Repetição com teste no início;

▪ Estrutura de controle do fluxo que permite repetir

diversas vezes um mesmo comando ou bloco de
comandos, sempre verificando antes de cada
execução se é “permitido” executar o código

▪ Executa os códigos enquanto o teste for verdadeiro

 Algoritmos
Estruturas de Repetição

▪ Repetição com teste no início;

Sintaxe:

while ( condição )
{
comando ou bloco de comandos
}
 Algoritmos
Estruturas de Repetição

▪ Repetição com teste no final:

▪ Neste caso os códigos são executados e somente

após a condição (teste) é avaliada. Caso for
verdadeiro, executa novamente os comandos ou
bloco de comandos até que ele se torne falso.

▪ Este tipo de repetição garante que o comando ou

bloco de comandos é executado ao menos 1 vez,
mesmo que a condição seja falsa.
 Algoritmos
Estruturas de Repetição

▪ Repetição com teste no final:

Sintaxe:

do
{ comando ou bloco de comandos }
while ( condição );
 Algoritmos
Estruturas de Repetição

▪ Repetição com variável de controle:

▪ O comando FOR é projetado para fazer uma ação

repetitiva com um contador que é inicializado e
incrementado / decrementado a cada iteração.

▪ Isto é, usamos o comando for quando precisamos

repetir um comando (ou um bloco de comandos)
um número definido de vezes a partir de um valor
inicial até um valor final, definindo o valor que este
valor será acrescido ou decrescido.
 Algoritmos
Estruturas de Repetição

▪ Sintaxe do comando for:

for (inicialização; condição ; incremento / decremento)

{ comando ou bloco de comandos }

onde:

“inicialização” é a atribuição de um valor inicial para a

variável de controle. (este comando é executado
apenas uma vez);
 Algoritmos
Estruturas de Repetição

▪ Sintaxe do comando for:

for (inicialização; condição ; incremento / decremento)

{ comando ou bloco de comandos }

onde:

“condição” é o teste que é feito para saber se executa o

bloco de comando (caso verdadeiro) ou se vai para o
próximo comando após o bloco (caso falso);
 Algoritmos
Estruturas de Repetição

▪ Sintaxe do comando for:

for (inicialização; condição ; incremento / decremento)

{ comando ou bloco de comandos }

onde:

“incremento / decremento” é a operação que será

executada após a execução do bloco de comandos.
Ao terminar esta operação é executado o teste
novamente.
 Algoritmos
Estruturas de Repetição

▪ Sintaxe do comando for:

for (inicialização; condição ; incremento / decremento)

{ comando ou bloco de comandos }

onde:

“{ bloco de comandos }” é o bloco de comandos que

serão executados após a condição (caso verdadeiro)
e antes do incremento / decremento.
 Algoritmos
Estruturas de Repetição

▪ Exemplo de repetição com variável de controle:

Inicialização

int main( ) {
int num;
for (num = 5; num > 0 ; num--)
{
printf("O numero agora vale: %d \n", num);
}
printf("A condição ficou falsa.”);
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num);
}
 Algoritmos
Estruturas de Repetição

▪ Exemplo de repetição com variável de controle:

Inicialização Condição
int main( ) {
int num;
for (num = 5; num > 0 ; num--)
{
printf("O numero agora vale: %d \n", num);
}
printf("A condição ficou falsa.”);
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num);
}
 Algoritmos
Estruturas de Repetição

▪ Exemplo de repetição com variável de controle:

Inicialização Condição
int main( ) { Decremento
int num;
for (num = 5; num > 0 ; num--)
{
printf("O numero agora vale: %d \n", num);
}
printf("A condição ficou falsa.”);
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num);
}
 Algoritmos
Estruturas de Repetição

▪ Exemplo de repetição com variável de controle:

Inicialização Condição
int main( ) { Decremento
int num;
for (num = 5; num > 0 ; num--)
{ Bloco de
Comandos
printf("O numero agora vale: %d \n", num);
}
printf("A condição ficou falsa.”);
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num);
}
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição

▪ Sequencia de execução: 1 – Inicializa

2 – Testa condição
int main( ) Caso verdadeira:
3 – Executa Bloco de Comandos
{
4 – Decrementa
int num; 5 – Testa condição
for (num = 5; num > 0 ; num--)
{ Caso verdadeira:
printf("O numero agora vale: %d \n", num); 6 – Executa Bloco de Comandos
} 7 – Decrementa
printf("A condição ficou falsa.”); 8 – Testa condição
printf(“\nO numero não e mais maior que 0.");
printf("\nEle vale: %d", num); Caso teste falso
9 – Executa próximo comando
}
após o “ } “
 Algoritmos
Estruturas de Repetição com variável de controle

▪ Também podemos criar uma variável dentro do laço,

com intuído de somente existir dentro deste bloco de
comandos e fazer somente o controle de vezes que irá
executar.
int main( )
{
for (int cont = 0; cont < 7 ; cont++)
{
printf(“Este programa executo a %d vez. \n", cont + 1);
}
printf("A condição ficou falsa, ele saiu do loop.”);
printf(“\nPerceba que ele foi executado %d vezes.“, cont);
}
 Algoritmos
Estruturas de Repetição com variável de controle

▪ O programa anterior vai dar erro pelo conceito de

variável local, isto é, a variável CONT somente é válida
dentro do { } do comando FOR.
 Exercícios

1. Faça um algoritmo em C++ que imprima a soma de 7

números digitados pelo usuário.
2. Faça um algoritmo em C++ onde o usuário solicite a
quantidade de números ele quer somar e faça a soma
destes números.
3. Faça um algoritmo em C++ que solicite 5 números
múltiplos de 4 ao usuário e imprima sua soma.