Estruturas de repetição

Motivação
Escrever um programa para calcular a soma dos 5 primeiros números
inteiros positivos.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int soma;

soma = 1 + 2 + 3 + 4 + 5;

printf("Soma = %d\n", soma);

system("PAUSE");
return(0);
}
Motivação
As somas parciais podem ser explicitadas através do seguinte programa:
#include <stdio.h>
#include <stdlib.h>

int main()
{
int soma;

soma = 0;
soma = soma + 1;
soma = soma + 2;
soma = soma + 3;
soma = soma + 4;
soma = soma + 5;
printf("Soma = %d\n", soma);
system("PAUSE");
return(0);
}
Motivação
A cada comando, adiciona-se um novo termo:
#include <stdio.h>
#include <stdlib.h>

int main()
{
int termo, soma;

termo = 0; soma = 0;
termo = termo + 1; soma = soma + termo;
termo = termo + 1; soma = soma + termo;
termo = termo + 1; soma = soma + termo;
termo = termo + 1; soma = soma + termo;
termo = termo + 1; soma = soma + termo;
printf("Soma = %d\n", soma);
system("PAUSE");
return(0);
}
Fluxograma

início do algoritmo Início

inicializar o valor termo = 0

do termo num

inicializar o valor soma = 0

da soma

F exibir o valor da
ainda há termos a termo < 5 soma
soma
adicionar?
V
Fim fim do algoritmo
calcular o próximo termo = termo + 1
termo

adicionar o termo à
soma e retornar soma = soma + termo
Definição

• Uma estrutura de repetição é utilizada quando um trecho de um

algoritmo precisa ser executado diversas vezes.

• A cada execução do trecho, algumas variáveis terão seus valores

modificados por algum cálculo ou alguma sequência de instruções.

• O número de repetições pode ser fixo ou pode depender do valor de uma

condição.

• Se o número de repetições for atingido ou se a condição estabelecida for

falsa, o fluxo de execução é desviado para o primeiro comando após a
estrutura de repetição.
Tipos de estruturas de repetição

Teste no início while()

Estrutura de repetição com teste no início.

F Sintaxe:
expressão
while (expressão)
{
V
// comandos executados enquanto
comandos executados // a expressão for verdadeira
enquanto a expressão }
for verdadeira

Atenção
Não se usa “;” após o while()
Exemplo: estrutura de repetição while()
Calcular a soma dos 500 primeiros inteiros positivos.
#include <stdio.h>
Início
#include <stdlib.h>

termo = 0 int main()

{
int termo, soma;
soma = 0
termo = 0;
soma = 0;
F
termo < 500 soma while ( termo < 500 )
{
V termo = termo + 1;
Fim
termo = termo + 1 soma = soma + termo;
}
printf("Soma = %d\n", soma);
soma = soma + termo system("PAUSE");
return(0);
}
Exemplo: estrutura de repetição while()
Generalizando: Calcular a soma dos n primeiros números positivos.
Início #include <stdio.h>
#include <stdlib.h>

“n?” int main()

{
n int n, termo, soma;

termo = 0 printf("Número de termos na soma: ");

scanf("%d", &n);
termo = 0;
soma = 0
soma = 0;
while ( termo < n )
termo < 500
F {
soma
termo++;
V soma = soma + termo;
Fim }
termo = termo + 1
printf("Soma = %d\n", soma);
system("PAUSE");
soma = soma + termo return(0);
}
Exemplo: estrutura de repetição while()
Calcular o valor da soma até que um dos termos seja menor que 10–5.
#include <stdio.h>
#include <stdlib.h>
1 1 1 1 1
S = 1+ + + + + + ... int main()
2 3 4 5 6 {
int den;
float soma;

den = 1;
soma = 0;
while (1.0/den > 0.00001)
{
soma = soma + 1.0/den;
den++;
}
printf("Soma = %d\n", soma);
system("PAUSE");
return(0);
}
Mas só dá pra fazer somas?
Escrever um programa para calcular n! = 1 × 2 × 3 × ... × n.
Início #include <stdio.h>
#include <stdlib.h>
int main()
“n?” {
int i, n;
n double fat;
printf(”Apresentar o fatorial de:");
i=0 scanf("%d", &n);
i = 0;
fat = 1 fat = 1;
while ( i < n )
F
{
i<n fat i++;
fat = fat * i;
V
Fim }
i=i+1 printf(”%d! = %.0f\n", n, fat);
system("PAUSE");
fat = fat * i return(0);
}
Tipos de estruturas de repetição

Teste no final do-while()

Estrutura de repetição com teste no final.

comandos executados Sintaxe:

enquanto a expressão do
for verdadeira
{
// comandos executados enquanto
V // a expressão for verdadeira
expressão
} while (expressão);
F

Atenção
Não se usa “;” após o do
Exemplo: estrutura de repetição do-while()
Calcular a precisão do computador.
#include <stdio.h>
Início #include <stdlib.h>

eps= 1.0 int main()

{
float eps;
eps= eps/2 eps = 1.0;

V do
1 + eps > 1 {
F eps = eps/2;
} while ( 1 + eps > 1 );
eps
printf(”Precisao: %f\n", eps);
Fim system("PAUSE");
return(0);
}
Repetição e seleção
Exibir quais e quantos são os números ímpares de um intervalo [a, b]
informado pelo usuário.
int main()
{
int a, b, num, cont;

printf("Intervalo: ");
scanf("%d %d", &a, &b);
num = a;
cont = 0;
while (num <= b)
{
if (num % 2 != 0)
{
cont++;
printf("%d\n", num);
}
num++;
}
printf("Existem %d numeros impares no intervalo [%d, %d]\n", cont, a, b);
system("PAUSE");
return(0);
}
Outro exemplo
Determinar o maior de um conjunto de 10 valores informados pelo usuário.
int main()
{
float maior, valor;
int cont;

maior = -999999;
cont = 0;
while (cont < 10)
{
printf("Valor: ");
scanf("%f", &valor);
if (valor > maior)
maior = valor;
cont++;
}
printf("Maior valor informado: %f\n", maior);
system("PAUSE");
return(0);
}
Repetição dentro de repetição
Imprimir a tabuada do 1 ao 10.
int main()
{
int a, b, valor;
a = 1;
while (a <= 10)
{
printf("\nTabuada do %d\n", a);
b = 1;
while (b <= 10)
{
valor = a * b;
printf(”%2d x %2d = %3d\n", a, b, valor);
b++;
}
a++;
}
system("PAUSE");
return(0);
}
Repetições com intervenção do usuário
int main()
{
int num;
char op;
do
{
system("CLS");
printf("Informe um numero inteiro: ");
scanf("%d", &num);

if (num % 2 == 0)
printf("%d é par\n", num);
else
printf("%d é ímpar\n", num);

printf("Deseja executar novamente(S/N)? ");

op = getchar();
} while (op == 's' || op == 'S');

system("PAUSE");
return(0);
}
O que será feito?
int main()
{
float soma, termo;
Se condição for:
int cont, n; soma < 1000
printf("Número de termos: ");
scanf("%d", &n); Serão somados termos até que a
cont = 0; soma ultrapasse 1000.
soma = 0;
termo = 0;

do {
termo > 0
cont++; A soma considera apenas termos
soma = soma + termo; positivos.
printf("Novo termo: ");
scanf("%f", &termo);
} while (condição);
cont < n
printf("Soma: %f (%d termos)\n",soma,cont); Serão somados exatamente n
system("PAUSE");
termos.
return(0);
}
Controle do número de repetições
• A cada execução dos comandos de uma estrutura de repetição dá-se o
nome de iteração.

• Em alguns problemas o número de iterações é fixo ou determinado em

tempo de execução. Nestes casos, usa-se uma variável de controle do
número de iterações.

• A variável de controle deve ser inicializada antes do primeiro comando da

estrutura de repetição.

• Dentro da estrutura, a variável de controle terá seu valor atualizado de

acordo com algum incremento ou decremento.

• A variável de controle será usada na expressão que determina se haverá a

execução de uma nova iteração.
Controle no número de iterações
Exibir os n primeiros números ímpares positivos.
int main()
{
int impar, n, cont; variável de controle
printf("Quantos números ímpares deseja exibir? ");
scanf("%d", &n);
cont = 1; inicialização
impar = 1;

while ( cont <= n ) expressão

{
printf("%d ", impar);
impar = impar + 2;
cont++; incremento
}

system("PAUSE");
return(0);
}
Tipos de estruturas de repetição

Controle no número de repetições for()

Estrutura de repetição com controle do número de
repetições.

inicialização
Sintaxe:
for(inicialização; expressão; incremento)
F
expressão {
// comandos executados enquanto
V
// a expressão for verdadeira
comandos executados
}
enquanto a expressão
for verdadeira

incremento Atenção
Não se usa “;” após o for()
Exemplo: estrutura de repetição for()
Exibir os n primeiros números ímpares positivos.
int main()
{
int impar, n, cont; variável de controle

printf("Quantos números ímpares deseja exibir? ");

scanf("%d", &n);
impar = 1; inicialização
for ( cont = 1; cont <= n; cont++ )
{
printf("%d ", impar); expressão
impar = impar + 2;
}
incremento
system("PAUSE");
return(0);
}
Aninhamento: for() dentro de for() dentro de...
No aninhamento, todas as iterações do laço mais interno serão executadas
antes da próxima iteração do laço mais externo.
int main()
{
int i, j;

for ( i = 1; i <= 10; i++ )

{
for ( j = 0; j < i; j++ )
{
printf("*");
}
printf("\n");
}

system("PAUSE");
return(0);
} Neste exemplo, a condição de execução do laço interno
depende do valor da variável de controle do laço externo.
O laço infinito
Uma estrutura de repetição pode apresentar execução infinita se:
 A condição de execução for mal formulada: a expressão realiza
comparações exatas (== ou !=) ou envolve variáveis de controle cujo valor
não se altera.
 A atualização da variável de controle não produz os valores esperados,
devido às limitações na representação de números reais pelo computador.

float x, y;

x = 1.0;
y = 0.1; // atenção: este valor não admite representação exata!
while( x != 0.0 )
{
x = x - y;
printf("%.1f\n", x);
}
Comandos de controle de fluxo

Permitem alterar o fluxo de execução de uma estrutura de repetição.

break;
Ignora os comandos restantes do bloco, desviando imediatamente o fluxo de execução do
programa para o primeiro comando após o final do bloco.

continue;
Ignora os comandos restantes do bloco e força a próxima iteração do laço, dependendo do
valor da expressão de controle.

exit(0);
Encerra a execução do programa.
Comandos de controle de fluxo: break;
Exemplo: Adivinhe o número que estou pensando...
#include <time.h>
int main()
{
int cont = 0, num, chute;
srand( time(0) ); // inicializa o gerador de números aleatórios
num = rand() % 100; // rand() gera um número inteiro entre 0 e 2 31 – 1

while ( 1 ) // laço infinito

{
cont++;
system("CLS");
printf("Advinhe o numero que estou pensando... [0, 99]: ");
scanf("%d", &chute);
if (chute == num)
break;
}
printf("Acertou em %d tentativas\n", cont);
system("PAUSE");
return(0);
}
Comandos de controle de fluxo: continue;
Exemplo: Apresentar o inverso de n valores (apenas quando possível.)
int main()
{
int i, n;
float valor;
printf("Quantos valores deseja informar? ");
scanf("%d", &n);

for ( i = 0; i < n; i++ )

{
printf("%do. valor: ", i+1);
scanf("%f", &valor);
if ( valor == 0.0 )
continue;
printf("O inverso de %f é %f\n", valor, 1.0/valor);
}

system(“PAUSE”);
return(0);
}
Comandos de controle de fluxo: exit(0);
Exemplo: Apresentar o inverso de n valores (até que não seja possível.)
int main()
{
int i, n;
float valor;
printf("Quantos valores deseja informar? ");
scanf("%d", &n);
for ( i = 0; i < n; i++ )
{
printf("%do. valor: ", i+1);
scanf("%f", &valor);
if ( valor == 0.0 )
{
puts("Divisão por zero!");
system("PAUSE");
exit(0);
}
printf("O inverso de %f é %f\n", valor, 1.0/valor);
}
system(“PAUSE”);
return(0);
}