Aula 4 Comandos de Repetio Prof Filipe Mutz

Aula 4 Comandos de Repetição Prof. Filipe Mutz.

Instrução . . . Instrução Condicional (seleção) Instrução Repetitivo (loops)

Comandos de repetição permitem que um conjunto de instruções seja executado repetidas vezes, enquanto uma ou mais condições forem verdadeiras Instrução Repetitivo (loops)

Exemplos – Lavar a louça Enquanto existirem louças sujas, repita o procedimento abaixo: • Pegue uma louça suja • Passe detergente • Enxágue • Coloque no secador

Exemplos – Escrever Convites de Casamento Enquanto existirem convidados sem convites repita o procedimento abaixo: • Escolha um convidado que ainda não possui convite • Escreva o convite • Coloque o convite no envelope • Lacre o envelope • Coloque o envelope na caixa • Risque o nome do convidado

Exemplos • Fazer uma lista de exercícios • Enquanto existirem exercícios não feitos, selecione um exercício, resolva e marque como resolvido • Ver as atualizações do Facebook • Enquanto existirem atualizações não vistas, continue olhando • Contar quanto dinheiro possui em um cofre • Enquanto existirem moedas não contadas, pegue uma moeda, some com o valor total e retire da pilha • Estudar uma matéria atrasada • Enquanto existir uma parte da matéria que eu não sei, continue estudando

Algoritmos com Repetições início <instruções 1> Enquanto <condição>: <instruções 2> <instruções 3> fim início instruções 1 Condições são Verdadeiras? sim instruções 2 não instruções 3 fim

Algoritmo Verificar. Senha início int senha Escreva “Digite sua senha: ” Leia senha enquanto a senha está incorreta: Escreva “Senha inválida!” Escreva “Digite sua senha: “ leia senha Escreva “Conectado!” fim inicio Int senha Escreva “Dig. . . ” Leia senha Senha incorreta? sim não Escreva “Sen. . ” Escreva “Con. . . ” Escreva “Dig. . . ” fim Leia senha

Repetições em C. . . while (<condições>) { instruções }. . . #include <stdio. h> int main (void) { int senha; printf("digite sua senha: "); scanf("%d", &senha); while (senha != 1024) { printf("senha incorreta!n"); printf("digite sua senha: "); scanf("%d", &senha); } printf("Conectado!n"); return 0; } Defini que a senha correta seria 1024 apenas por simplicidade Cada repetição é chamada de uma iteração.

Identificação de Repetições Quando estudamos condicionais , vimos que deveríamos buscar na descrição do problema, instruções que fossem executadas apenas em certas condições. • Mostrar um número se ele fosse par. • Mostrar a mensagem “pode dirigir” apenas quando a pessoa tiver mais de 18 anos e, mostrar “não pode dirigir” caso contrário. • Verificar se a pessoa pode se aposentar e mostrar a mensagem “Pode descansar”, em caso afirmativo.

Identificação de Repetições são mais sutis e é necessário um atento para identificar instruções que são realizadas várias vezes. Busque as estruturas: • “enquanto <condição> faça __ ”, • “até que <condição> seja satisfeita”, • “faça __ <n> vezes”. Mas cuidado! Em certas situações eles não estarão presentes.

Identificação de Repetições • Mostre seu nome na tela 10 vezes. • Peça que o usuário digite um número até que ele acerte qual é o número mágico. • Mostre na tela os 100 primeiros números pares, um por linha. • Mostre na tela os números entre 500 e 700 que são múltiplos de 6 e 7, simultaneamente.

• Assim fica mais fácil ver a repetição!

Como resolver problemas de Repetição 1. 2. 3. 4. 5. 6. Busque instruções que são executadas várias vezes. Identifique em que condições acontece a repetição. Identifique o que muda a cada iteração. Encontre uma forma de calcular os valores que mudam! Identifique qual é o resultado esperado ao final da repetição. * Atualize a cada iteração o resultado. * * Nem toda repetição possui um resultado final esperado.

Exemplo O que se repete? Se repete em que condições? A cada repetição, o que muda? Como calcular o que muda a cada repetição? Existe um resultado final esperado? Faça um programa que mostre na tela 100 números a partir do 1. Algoritmo Números Início Escreva “ 1” Escreva “ 2” Escreva “ 3”. . . Escreva “ 100” Fim

Exemplo Faça um programa que mostre na tela 100 números a partir do 1. O que se repete? Escreva Se repete em que condições? Enquanto não mostramos os 100 números. A cada repetição, o que muda? O número escrito Como calcular o que muda a cada repetição? Anterior + 1 Existe um resultado final esperado? não Algoritmo Números Início Escreva “ 1” Escreva “ 2” Escreva “ 3”. . . Escreva “ 100” Fim

Exemplo Faça um programa que mostre na tela 100 números a partir do 1. Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 A maioria das repetições possui um contador para contar quantas repetições já fizemos. . int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1

Exemplo valor_inicial Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 _ 1

Exemplo valor_inicial 1 nums_para_contar 100 Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 _

Exemplo valor_inicial 1 nums_para_contar 100 nums_contados 0 Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 0 numero_atual 1 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 0 numero_atual 1 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 0 numero_atual 1 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 0 numero_atual 2 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 1 numero_atual 2 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 1 numero_atual 2 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 1 numero_atual 2 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 1 numero_atual 3 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 2 numero_atual 3 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 2 numero_atual 3 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 2 numero_atual 3 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 2 numero_atual 4 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 3 numero_atual 4 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 3 numero_atual 4 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3 _

Algumas repetições depois. . .

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 98 numero_atual 99 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 98 numero_atual 99 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 98 numero_atual 100 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 99 numero_atual 100 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 99 numero_atual 100 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 99 numero_atual 100 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 100 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 99 numero_atual 101 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 100 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 100 numero_atual 101 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 100 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 100 numero_atual 101 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 100 _

Exemplo Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 valor_inicial 1 nums_para_contar 100 nums_contados 100 numero_atual 101 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1 1 2 3. . . 97 98 99 100 _

Exemplo Faça um programa que mostre na tela os números inteiros entre 1 a 100 (limites inclusos). Algoritmos Números início int valor_inicial = 1 int nums_para_contar = 100 int nums_contados = 0 int numero_atual = valor_inicial fim Obs: note que a variável nums_contados e numero_atual são praticamente iguais! Será que não podemos usar isso para melhorar nosso algoritmo? Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 1 nums_contados = nums_contados + 1

Exemplo Faça um programa que mostre na tela os números inteiros entre 1 a 100 (limites inclusos). Algoritmos Números início int valor_inicial = 1 int valor_final = 100 int numero_atual = valor_inicial fim Enquanto numero_atual <= valor_final: Escreva numero_atual = numero_atual + 1

Algoritmo Numeros Início int na int nf #include <stdio. h> int main (void) { int na; int nf; nf = 100; na = 1; nf = 100 na = 1 Fim while (na <= nf) { printf("%dn", na); na = na + 1; } while na <= nf: Escreva na na = na + 1 return 0; }

Algoritmo Numeros Início int na int nf escreva “numero de itens a serem escritos: ” leia nf #include <stdio. h> int main (void) { int na; int nf; printf("numero de itens a serem escritos: "); scanf("%d", &nf); na = 1; na = 1 Fim while (na <= nf) { printf("%dn", na); na = na + 1; } while na <= nf: Escreva na na = na + 1 return 0; }

E se quiséssemos mostrar os números entre -300 e 967? OBS: Equivale a mostrar 1267 números a partir de -300!

Exemplo Algoritmos Números início int valor_inicial = -300 int valor_final = 967 int numero_atual = valor_inicial fim Enquanto numero_atual <= valor_final: Escreva numero_atual = numero_atual + 1

E se quiséssemos mostrar os números entre 100 e 0 (de trás para frente)?

Exemplo Algoritmos Números início int valor_inicial = 100 int valor_final = 0 int numero_atual = valor_inicial fim Enquanto numero_atual > valor_final: Escreva numero_atual = numero_atual - 1

E se quiséssemos mostrar os 20 primeiros números pares?

Exemplo Algoritmos Números início int valor_inicial = 0 int nums_para_contar = 20 int nums_contados = 0 int numero_atual = valor_inicial fim Enquanto nums_contados < nums_para_contar: Escreva numero_atual = numero_atual + 2 nums_contados = nums_contados + 1

Exemplo Algoritmos Números início int nums_para_contar = 20 int nums_contados = 0 fim OU Enquanto nums_contados < nums_para_contar: Escreva nums_contados * 2 nums_contados = nums_contados + 1

Exercícios • Faça um programa em C que mostre seu nome na tela 13 vezes. • Exercício para casa: Traduza as variações de algoritmos que fizemos p/ C.

Loops Definidos São loops em que sabemos a priori quantas vezes realizaremos uma repetição. • Ex: Mostre seu nome na tela 10 vezes, leia as informações de 20 pessoas, calcule a soma dos 50 primeiros termos de uma série, . . .

Contadores int contador; contador = [inicio]; contador = 0; while (contador < [final]) { <instruções> contador = contador + 1; } while (contador < 10) { printf(“olan”); contador = contador + 1; }

Loops Indefinidos São loops em que NÃO sabemos a priori quantas vezes realizaremos uma repetição. Exemplo: Peça ao usuário que digite um número e mostre na tela o valor do número ao cubo. Repita esse processo enquanto o usuário não digitar 0.

Exercícios • Para casa: Faça um algoritmo em C mostre na tela as 20 primeiras potências de 2 (2, 4, 8, . . . ) • Faça um algoritmo em C mostre na tela os 20 primeiros números da sequência (1 / 1), (-1 / 2), (1 / 3), (-1 / 4), . . . • Faça um algoritmo em C mostre na tela os 30 primeiros números da sequência de Fibonacci

Operadores de incremento e decremento int contador; contador = [inicio]; while (contador < [final]) { <instruções> contador += 1; } contador = contador + 1

Operadores de incremento e decremento int contador; contador = [inicio]; while (contador < [final]) { <instruções> contador += 2; } contador = contador + 2

Operadores de incremento e decremento int contador; contador = [inicio]; while (contador < [final]) { <instruções> contador++; } contador = contador + 1

Operadores de incremento e decremento int contador; contador = [inicio]; while (contador < [final]) { <instruções> contador -= 1; } contador = contador - 1

Operadores de incremento e decremento int contador; contador = [inicio]; while (contador < [final]) { <instruções> contador -= 2; } contador = contador - 2

Operadores de incremento e decremento int contador; contador = [inicio]; while (contador < [final]) { <instruções> contador--; } contador = contador - 1

Outros Operadores x /= 2; y *= x; A += (x + pow(2, x));

Vamos ver mais alguns exemplos

printf("digite um numero: "); scanf("%f", &numero); Exemplo: Leia 5 números e mostre na tela qual é o menor deles if (numero < menor) menor = numero; #include <stdio. h> int main (void) { float numero; float menor; Resultado esperado printf("digite um numero: "); scanf("%f", &numero); if (numero < menor) menor = numero; printf("digite um numero: "); scanf("%f", &numero); menor = numero; if (numero < menor) menor = numero; printf("digite um numero: "); scanf("%f", &numero); printf("menor: %fn", menor); if (numero < menor) menor = numero; } return 0;

contador = 0; Exemplo: Leia 5 números e mostre na tela qual é o menor deles while (contador < 4) { printf("digite um numero: "); scanf("%f", &numero); #include <stdio. h> int main (void) { int contador; float numero; float menor; if (numero < menor) menor = numero; contador = contador + 1; printf("digite um numero: "); scanf("%f", &numero); } menor = numero; printf("menor: %fn", menor); return 0; }

Exemplo: Leia 5 números e mostre na tela qual é o menor deles while (contador < 5) { printf("digite um numero: "); scanf("%f", &numero); #include <stdio. h> int main (void) { int contador; float numero; float menor; if (numero < menor) menor = numero; truque contador = contador + 1; menor = 99999; } contador = 0; printf("menor: %fn", menor); return 0; }

Exemplo: Leia 5 números e mostre na tela qual é o menor deles #include <stdio. h> int main (void) { int contador; float numero; float menor; Nas sequências, tínhamos um resultado por iteração. Neste caso, atualizamos um resultado único em todas as iterações. while (contador < 5) { printf("digite um numero: "); scanf("%f", &numero); if (numero < menor) menor = numero; contador = contador + 1; menor = 99999; } contador = 0; printf("menor: %fn", menor); return 0; }

E se quiséssemos o maior?

Exemplo: Leia 5 números e mostre na tela qual é o maior deles while (contador < 5) { printf("digite um numero: "); scanf("%f", &numero); #include <stdio. h> int main (void) { int contador; float numero; float maior; if (numero > maior) maior = numero; contador = contador + 1; maior = -99999; } contador = 0; printf(“maior: %fn", maior); return 0; }

Faça um programa que leia 4 números e mostre na tela a soma deles printf("digite um numero: "); scanf("%f", &numero); soma += numero; #include <stdio. h> int main (void) { float numero; float soma; printf("digite um numero: "); scanf("%f", &numero); soma += numero; printf("digite um numero: "); scanf("%f", &numero); soma = 0; soma += numero; printf("digite um numero: "); scanf("%f", &numero); soma += numero; } printf("soma: %fn", soma); return 0;

Faça um programa que leia 4 números e mostre na tela a soma deles contador = 0; #include <stdio. h> while (contador < 4) { printf("digite um numero: "); scanf("%f", &numero); soma += numero; contador ++; } int main (void) { float numero; float soma; int contador; soma = 0; } printf("soma: %fn", soma); return 0;

Exercício: Implemente um programa em C que calcule o somatório abaixo: Em seguida, modifique o programa para que o usuário possa digitar o limite superior do somatório (por exemplo, 200 ao invés de 50 no caso acima).

Exercício: Faça um programa em C que calcule o somatório da série abaixo. Em seguida, execute o programa para valores crescentes de n e verifique se o somatório converge para algum valor. OBS: Use variáveis double para uma maior precisão. Lembre-se de usar %lf para ler e escrever doubles. O que se repete? O que muda a cada repetição? Como calcular os elementos da série?

Para Casa: Faça um programa em C que calcule o somatório da série abaixo. Em seguida, execute o programa para valores crescentes de n e verifique se o somatório converge para algum valor. OBS: Use variáveis double para uma maior precisão. Lembre-se de usar %lf para ler e escrever doubles.

Exemplo: leia um número inteiro n. Em seguida, leia n números e mostre na tela a média dos números digitados.

Redução (Reduction) • Conjunto de problemas em que a partir de um conjunto de valores, obtemos um valor único. Este valor é obtido pela aplicação de um determinado operador aos elementos do conjunto. • Exemplos: maior, menor, somatório, média, contagem, produtório, etc. • Definição: Condição inicial, operador de transição e pós operação.

Para Casa: Faça um algoritmo que leia um número e calcule seu fatorial.

Loops aninhados Faça um algoritmo que mostre na tela a tabuada de 1 a 10.

Loops aninhados Peça que o usuário digite um número repetidamente, até que ele digite 0. Para cada número digitado, mostre uma mensagem na tela tantas vezes quanto o número (ex. : se o usuário digitar 2, o programa deve mostrar a mensagem 2 vezes na tela).

Loops infinitos e Loops vazios • Loops infinitos são aqueles em que a condição do while é sempre verdadeira. • Loops vazios são aqueles em que a condição do while é sempre falsa.

Repetições com Condicionais Leia as gravidades de 5 multas recebidas por um motorista. A gravidade de uma multa é representada por um caractere e pode ser ‘l’ (leve – 3 pontos), ‘m’ (média – 4 pontos), ‘g’ (grave – 5 pontos), e ‘G’ (gravíssima – 7 pontos). Ao final, mostre na tela a pontuação total perdida pelo motorista e se ela for maior que 21 pontos, mostre na tela uma mensagem dizendo que a carteira foi suspensa. ATENÇÃO: ao ler caracteres em loops, use scanf(“n%c”, &var); para evitar que o “n” seja lido como um caractere na próxima iteração!!!!

Exercício para Casa Modifique o exemplo anterior para que a pontuação do motorista comece com 21 pontos e sejam lidas multas enquanto a pontuação for maior que zero.

Mais repetições com condicionais Uma empresa deseja fazer uma pesquisa de satisfação com seus clientes. Leia de 10 pessoas, o gênero (‘f’ p/ feminino e ‘m’ para masculino) e se gostaram ou não do produto de interesse (caractere ‘s’ p/ sim e ‘n’ para não), e mostre na tela a porcentagem de entrevistados de cada gênero e a porcentagem de pessoas de cada gênero que se consideravam satisfeitas com o produto. ATENÇÃO: ao ler caracteres em loops, use scanf(“n%c”, &var); para evitar que o “n” seja lido como um caractere na próxima iteração!!!!

Outros comandos de repetição: FOR Usado em loops definidos (quando o número de repetições é conhecido a priori). int i; for (i = [valor inicial]; i < [valor final]; i += [passo]) { <instruções> } i = [valor inicial]; while (i < [valor final]) { <instruções>; i += [passo]; }

Exemplo: FOR #include <stdio. h> int main (void) { int i; for (i = 0; i < 10; i += 1) { printf("i: %dn", i); } } return 0;

Exemplo: FOR #include <stdio. h> int main (void) { int i; for (i = 0; i < 10; i++) { printf("i: %dn", i); } } return 0;

Exemplo: FOR #include <stdio. h> int main (void) { int i; Assim como no if, podemos omitir se o bloco só tiver 1 instrução. for (i = 0; i < 10; i++) printf("i: %dn", i); } return 0;

Exercício: escreva o loop while que corresponde aos for’s abaixo (assuma que as vars. foram declaradas previamente) for (i = 100; i < 300; i++) { } for (i = 300; i > 100; i--) { } for (contador = 0; contador < 20; contador += 2) { } for (i = 0; i < 10; i++) for (j = 0; j < 10; j++) printf(“%d x %d = %dn”, i, j, i * j);

Exemplo: Faça um algoritmo usando for que leia um número e mostre na tela seus divisores.

Exemplo: Modifique o programa anterior para ler um número e mostrar na tela se ele é primo ou não.

Exemplo: Modifique o programa anterior para mostrar todos os números primos em um intervalo.

#include <stdio. h> int main (void) { char opcao; do { printf("Escolha sua opcao: "); scanf("n%c", &opcao); Outros comandos de repetição: DO. . . WHILE Útil em situações do tipo: • Leia até encontrar o número 0. • Leia até encontrar um caractere ‘q’ // <instrucoes> } while (opcao != 'q'); return 0; } ATENÇÃO: ao ler caracteres em loops, use scanf(“n%c”, &var); para evitar que o “n” seja lido como um caractere na próxima iteração!!!!

Comandos Adicionais • Break: interrompe imediatamente o loop. • Continue: volta imediatamente a avaliar a condição de repetição e, se ela for verdadeira, continua a repetição. • Ambos podem ser usados em todos os comandos vistos: while, for e do. . . while.

#include <stdio. h> #include <float. h> int main (void) { char opcao; do { O que vai aparecer na tela se o usuário escolher as opções: d, e, a? E se ele escolher ‘f’, ‘g’, ‘q’? printf("Escolha sua opcao: "); scanf("n%c", &opcao); if (opcao == 'a' || opcao == 'b') break; else if (opcao == ‘c’ || opcao == ‘d’ || opcao == ‘q’) continue; printf(“trabalhando. . . n”); } while (opcao != 'q'); printf(“fimn”); return 0; }

Faça um programa que leia uma opção repetidamente e execute as ações abaixo de acordo com a opção escolhida: • Opção ‘a’: ler um número e mostrar o quadrado do número. • Opção ‘b’: ler um número e mostrar a raiz do número. • Opção ‘q’: terminar o programa. • Qualquer outra opção: mostrar na tela a mensagem “opção inválida”.

Ler uma opção Opção é q? Opção é a ou b? Outra opção. Ler um número Opção é a? Mostre na tela o quadrado do número Opção é b? Mostre na tela a raiz do número Mostre na tela: “Opção Inválida”

#include <stdio. h> #include <math. h> int main (void) { int numero; char opcao; while (1 == 1) { printf("digite 'a' para mostrar o quadrado, 'b' a raíz, e 'q' para terminar: "); scanf("n%c", &opcao); if (opcao == 'q') break; else if (opcao == 'a' || opcao == 'b') { printf("digite um numero: "); scanf("%d", &numero); . . .

. . . if (opcao == 'a') printf("O numero ao quadrado eh: %fn", pow(numero, 2)); else printf("A raiz do numero eh: %fn", sqrt(numero)); } else printf("Opcao invalida!n"); } return (0); }

Revisão: Como resolver problemas de Repetição 1. 2. 3. 4. 5. 6. Busque instruções que são executadas várias vezes. Identifique em que condições acontece a repetição. Identifique o que muda a cada iteração. Encontre uma forma de calcular os valores que mudam! Identifique qual é o resultado esperado ao final da repetição. * Atualize a cada iteração o resultado. * * Nem toda repetição possui um resultado final esperado.

Exercícios: Faça um algoritmo que peça ao usuário para digitar um número e mostre seu fatorial na tela. Repita este procedimento até que o usuário digite 0 ou um valor negativo.

Exercícios: Faça um algoritmo que aproxime a área abaixo da curva de uma função usando a soma da área de retângulos. Entrada do algoritmo: • • • Limite inferior: a Limite superior: b Número de divisões: n A função deve ser escrita no próprio programa. a dx b Dica: para calcular a altura dos retângulos, calcule o valor da função nos pontos esquerdo e direito do retângulo e tire a média.