Estruturas de Repetição
Estruturas de Repetição
Estruturas de Repetição
PROPÓSITO
Aplicar três diferentes estruturas (comandos) de repetição, disponíveis na maioria das linguagens de
programação, permitindo que o programa possa repetir um bloco ou sequência de instruções, fundamental
nas soluções algorítmicas para processar um conjunto repetido de dados.
PREPARAÇÃO
Antes de iniciar seu estudo, instale os programas Portugol Studio e Dev-C++, pois são fundamentais
para o acompanhamento do tema.
OBJETIVOS
MÓDULO 1
Validar linhas de código a partir de uma solicitação de comando FOR em Portugol e na linguagem C
MÓDULO 2
Identificar conceitos e assertivas relacionados aos comandos de repetição com teste no início
MÓDULO 3
Identificar conceitos e assertivas relacionados aos comandos de repetição com teste no final
MÓDULO 1
1º Exemplo: ler 3 notas de um aluno, calcular e exibir a média aritmética dessas notas.
// Código em Portugol
funcao inicio ()
{
Real nota1, nota2, nota3, media
escreva (" nota 1 = ")
leia (nota1)
escreva (" nota 2 = ")
leia (nota2)
escreva (" nota 3 = ")
leia (nota3)
media = (nota1+nota2+nota3)/3
escreva (" media = ",media)
}
// Código em Linguagem C
int main ()
{
float nota1, nota2, nota3, media
printf (" nota 1 = ");
scanf ("%f", ¬a1);
printf (" nota 2 = ");
scanf ("%f", ¬a2);
printf (" nota 3 = ");
scanf ("%f", ¬a3);
media = (nota1+nota2+nota3)/3;
printf ("media = %f",media);
}
2º Exemplo: ler 3 notas de um aluno, calcular e mostrar a média aritmética e exibir se o aluno foi
aprovado ou não (média igual ou acima de 7 aprova o aluno).
Observe que a única diferença desta solução e a do exemplo anterior são as duas últimas linhas:
// Código em Portugol
funcao inicio ()
{
Real nota1, nota2, nota3, media
escreva (" nota 1 = ")
leia (nota1)
escreva (" nota 2 = ")
leia (nota2)
escreva (" nota 3 = ")
leia (nota3)
media = (nota1+nota2+nota3)/3
escreva (" media = ",media)
se (media>=7) escreva (" , Aluno Aprovado")
senao escreva (" , Aluno Reprovado")
}
// Código em Linguagem C
int main ()
{
float nota1, nota2, nota3, media
printf (" nota 1 = ");
scanf ("%f", ¬a1);
printf (" nota 2 = ");
scanf ("%f", ¬a2);
printf (" nota 3 = ");
scanf ("%f", ¬a3);
media = (nota1+nota2+nota3)/3;
printf ("media = %f",media);
if (media>=7) printf (" , Aluno Aprovado");
elseprintf (" , Aluno Reprovado");
}
Vimos dois exemplos que processam três notas de um único aluno. Mas e se quiséssemos calcular e
mostrar a média e a situação de aprovação de 40 alunos de uma turma? Temos duas soluções de acordo
com o que sabemos até o momento:
Usar 120 variáveis: 3 variáveis para as notas de cada um dos 40 alunos (3 x 40 = 120).
A sequência de comandos para ler, calcular e mostrar a média e situação de um aluno é a mesma para 100
ou qualquer outra quantidade de alunos, concorda? Como devemos proceder então?
COMENTÁRIO
Os comandos de repetição nos permitem repetir, quantas vezes desejarmos, uma sequência ou bloco de
comandos.
DEMONSTRAÇÃO
Vamos ver um exemplo da utilização dos comandos de repetição.
Objetivo: ler 3 notas de 40 alunos, calcular e mostrar a média aritmética e a situação de aprovação de
cada aluno (média igual ou acima de 7 aprova o aluno).
LÓGICA:
Para resolver esse problema, precisamos aprender as estruturas de repetição, também chamadas de
comandos de repetição ou de iteração. Dessa forma, somos capazes de repetir uma sequência ou bloco de
comandos a quantidade de vezes que precisamos.
Neste exemplo, precisamos repetir 40 vezes a mesma sequência de comandos do programa do exemplo
anterior, pois o procedimento de cálculo da média de um aluno é o mesmo para cada um dos 40 alunos.
Uma das possíveis soluções para a repetição de uma sequência de comandos, em um programa, é o uso
do comando classificado como estrutura de repetição com variável de controle, que possibilita a repetição
de uma sequência ou bloco de comandos um número fixo e conhecido de vezes.
É o mais indicado quando sabemos previamente, pelo enunciado do problema, o número de vezes que a
repetição vai acontecer. Neste exemplo a premissa é que devemos processar notas de uma turma com 40
alunos. Sabemos, portanto, que vamos repetir o procedimento (sequência ou bloco de comandos) para
calcular a média, mostrá-la e exibir a situação do aluno 40 vezes: uma vez para cada um dos 40 alunos
que fazem parte da turma.
A seguir, apresentamos a sintaxe geral do comando de repetição com variável de controle em Portugol e
em C:
// Código em Portugol
// Código em Linguagem C
INICIALIZAÇÃO
Valor inicial da variável de controle. Essa ação é executada, uma única vez, ao iniciar o comando.
CONDIÇÃO
Expressão relacional (retorna um valor verdadeiro ou falso) associada à variável de controle. A condição
é avaliada antes repetição: se for verdade, a repetição ocorre; se for falsa, a repetição não ocorre e o fluxo
do programa vai para o comando após a repetição.
INCREMENTO_DECREMENTO
Aumento ou diminuição do valor da variável de controle ao fim da sequência de comandos a ser
repetida. O incremento ou decremento pode ser de qualquer valor, conforme a solução desejada.
O valor da variável de controle é comparado com a condição, que define o fim da repetição.
3
Se a condição for falsa, a sequência de comandos a ser repetida é interrompida e o controle do código é
passado ao comando após repetição.
// Código em Portugol
PARA (cont=1;cont<=10;cont=cont+1)
{
Sequência de comandos a ser repetida
}
ONDE:
Inicialização: cont=1
Condição: cont<=10
Incremento_decremento: cont=cont+1
// Código em Linguagem C
FOR (cont=1;cont<=10;cont=cont+1)
{
Sequência de comandos a ser repetida
}
ONDE:
Inicialização: cont=1
Condição: cont<=10
Incremento_decremento: cont=cont+1
PARA (cont=1;cont<=10;cont=cont+1)
{
escreva (cont, "\n")
}
// Código em Linguagem C
FOR (cont=1;cont<=10;cont=cont+1)
{
printf ("%d\n",cont)
}
PARA (cont=10;cont>=1;cont=cont-1)
{
escreva (cont, "\n")
}
// Código em Linguagem C
FOR (cont=10;cont>=1;cont=cont-1)
{
printf ("%d\n",cont)
}
PARA (cont=2;cont<=10;cont=cont+2)
{
escreva (cont, "\n")
}
// Código em Linguagem C
FOR (cont=2;cont<=10;cont=cont+2)
{
printf ("%d\n",cont)
}
PARA (cont=10;cont<=100;cont=cont+10)
{
escreva (cont, "\n")
}
// Código em Linguagem C
FOR (cont=10;cont<=100;cont=cont+10)
{
printf ("%d\n",cont)
}
PARA (cont=1000;cont>=100;cont=cont-100)
{
escreva (cont, "\n")
}
// Código em Linguagem C
FOR (cont=1000;cont>=100;cont=cont-100)
{
printf ("%d\n",cont)
}
Soma=0
PARA (cont=1;cont<=10;cont=cont+1)
{
Soma=soma+cont
}
escreva (cont, "\n")
// Código em Linguagem C
Soma=0;
FOR (cont=1;cont<=10;cont=cont+1)
{
Soma=soma+cont;
}
printf ("A soma dos números entre 1 e 10 =%d\n",soma);
Soma=0
PARA (cont=1;cont<=10;cont++)
{
Soma=soma+cont
}
Média=soma/10
escreva (media, "\n")
// Código em Linguagem C
Soma=0;
FOR (cont=1;cont<=10;cont++)
{
soma=soma+cont;
}
media=soma/10;
printf ("A média dos números entre 1 e 10= %f\n", media);
TEORIA NA PRÁTICA
Selecionamos alguns problemas para você resolver usando algoritmos em Portugol e na linguagem C.
Vamos ver?
Neste vídeo, iremos resolver o primeiro problema juntos e teremos a ajuda de Marcelo Vasques, mestre
em Computação Aplicada e Automação:
AGORA TENTE RESOLVER OS PROBLEMAS ABAIXO
NO AMBIENTE DEV-C++.
VOCÊ PODERÁ COMPARAR A SUA RESPOSTA NO
BOTÃO DE SOLUÇÃO.
2º problema: desenvolva um programa que leia 15 números inteiros e positivos e mostre o maior deles.
LÓGICA:
Precisamos de 3 variáveis do tipo inteiro (int) para armazenar cada número a ser lido, o maior dos
números e controlar a repetição.
Se o número for superior à variável maior, ela recebe o conteúdo do número lido.
SOLUÇÃO
// Código em Portugol
programa
{
funcao inicio()
{
inteiro num,cont,maior;
maior=0
para (cont=1;cont<=15;cont=cont+1)
{
escreva ("Digite um número: ")
leia (num)
se num> maior
{
maior=num
}
{
escreva ("O maior dos números lidos = ",maior)
}
}
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int main()
{
int cont,num,maior;
maior=0;
for (cont=1;cont<=15;cont++)
{
printf ("Digite um número: ");
scanf("%d",&num);
if (num > maior)
{
maior=num;
{
}
printf ("O maior dos números lidos = %d\n",maior); return 0;
}
LÓGICA:
Precisamos de 4 variáveis do tipo real (float), para armazenar cada salário a ser lido, o maior salário, a
soma salarial — para calcular a média — e média salarial, além de uma variável inteira (int) para
controlar a repetição.
Se o salário for superior à variável maior, ela recebe o conteúdo do salário lido;
Calcular a média salarial, dividindo a soma dos salários por 10 (total de funcionários).
SOLUÇÃO
// Código em Portugol
programa
{
funcao inicio()
{
inteiro cont
real salario,media,soma,maior;
maior=0 soma=0;
para (cont=1;cont<=10;cont++)
{
escreva ("Digite o salário do funcionário: ");
leia (salario);
soma=soma+salario;
se (salario > maior)
{
maior=salario;
}
}
media=soma/10;
escreva ("O maior salário da empresa e = ",maior);
escreva ("A média salarial da empresa e = ",media);
}
}
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int main()
{
int cont;
float salario,media,soma,maior;
maior=0; soma=0;
for (cont=1;cont<=10;cont++)
{
printf ("Digite o salário do funcionário: ");
scanf("%f",&salario);
soma=soma+salario;
if (salario > maior)
{
maior=salario;
}
}
media=soma/10;
printf ("O maior salário da empresa e = %.2f \n",maior);
printf ("A média salarial da empresa e = %.2f \n",media);
return 0;
}
}
4º problema: desenvolva um programa que leia 3 notas de 40 alunos, calcule e mostre a média aritmética
e a situação de aprovação de cada um deles. Lembre-se que apenas a média igual ou acima de 7 aprova o
aluno.
LÓGICA:
Precisamos de 3 variáveis do tipo real (float) para armazenar as notas de cada aluno, uma variável real
para armazenar a média das notas e uma variável inteira (int) para controlar a repetição.
SOLUÇÃO
// Código em Portugol
programa
{
funcao inicio()
{
real nota1,nota2,nota3,media
inteiro contalunos
para (contalunos=1;contalunos<=40;contalunos++)
{
escreva("Entre com a nota 1 do aluno: ")
leia (nota1)
escreva("Entre com a nota 2 do aluno: ")
leia (nota2)
escreva("Entre com a nota 3 do aluno: ")
leia (nota3)
media=(nota1+nota2+nota3)/3
se (media>=7)
{
escreva("Aluno APROVADO com média :",media)
}
senao
{
printf("Aluno REPROVADO com média : ",media)
}
}
}
}
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int main()
{
float nota1,nota2,nota3,media;
int contalunos;
for (contalunos=1;contalunos<=40;contalunos++)
{
printf("Entre com a nota 1 do aluno: ");
scanf("%f",¬a1);
printf("Entre com a nota 2 do aluno: ");
scanf("%f",¬a2);
printf("Entre com a nota 3 do aluno: ");
scanf("%f",¬a3);
media=(nota1+nota2+nota3)/3;
if (media>=7)
{
printf("Aluno APROVADO com média : %.2f",media);
}
else
{
printf("Aluno REPROVADO com média : %.2f",media);
}
}
return 0;
}
5º problema: desenvolva um programa que leia, inicialmente, a porcentagem de reajuste dos salários dos
funcionários de uma empresa. Na sequência, deve ler o salário de cada um dos 50 funcionários, calcular e
mostrar o novo salário reajustado, aplicando a porcentagem de ajuste sobre os respectivos salários atuais.
Ao final, o maior salário reajustado da empresa deve ser apresentado na tela.
LÓGICA:
Precisamos de 4 variáveis do tipo real (float) para armazenar a porcentagem de reajuste, cada salário a ser
lido, cada salário a ser reajustado e o maior salário reajustado, além de uma variável inteira (int) para
controlar a repetição.
1
SOLUÇÃO
// Código em Portugol
programa
{
funcao inicio()
{
real percreaj, salario, salarioreaj, maiorsal
inteiro cont
maiorsal=0
escreva("Percentual de reajuste salarial: ")
leia (percreaj);
para (cont=1;cont<=50;cont++)
{
escreva("Informe o salário do funcionário: ");
leia (salario)
salarioreaj = salario+ (salario*percreaj/100)
escreva("O salário reajustado e : ",salarioreaj)
se (salarioreaj>maiorsal)
maiorsal=salarioreaj
}
escreva("O maior salário reajustado e : ",maiorsal);
}
}
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int main()
{
float percreaj,salario,salarioreaj,maiorsal;
int cont;
maiorsal=0;
printf("Percentual de reajuste salarial:");
scanf ("%f",&percreaj);
for (cont=1;cont<=50;cont++)
{
printf("Informe o salário do funcionário:");
scanf("%f",&salario);
salarioreaj=salario+(salario*percreaj/100);
printf("O salário reajustado e : %.2f \n\n",salarioreaj);
if (salarioreaj>maiorsal)
maiorsal=salarioreaj;
}
printf("O maior salário reajustado e : %.2f",maiorsal);
return 0;
}
6º problema: desenvolva um programa que leia um número N e, em seguida, uma lista de N números
inteiros. Este programa também deve calcular e mostrar a soma dos números pares e dos números
ímpares da lista.
LÓGICA:
Precisamos de 4 variáveis inteiras (int) para armazenar o número N, cada número da lista de N números,
a soma dos pares e a soma dos ímpares, além da variável para controle da repetição da leitura e
processamento dos N números.
Repetir N vezes:
SOLUÇÃO
// Código em Portugol
programa
{
funcao inicio()
{
inteiro cont, n, num, somapar, somaimpar
somapar=0
somaimpar=0
escreva("Digite a quantidade de números da lista: "); leia(n);
para (cont=1; cont<=n; cont++)
{
escreva ("Digite um número: ");
leia(num);
se (num%2==0)
somapar=somapar+num;
senao
somaimpar=somaimpar+num;
}
escreva ("A soma dos números pares =",somapar);
escreva ("A soma dos números ímpares =",somaimpar);
}
}
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int main()
{
int cont,n,num,somapar,somaimpar;
somapar=0;
somaimpar=0;
printf ("Digite a quantidade de números da lista: ");
scanf("%d",&n);
for (cont=1;cont<=n;cont++)
{
printf ("Digite um número: ");
scanf("%d",&num);
if (num%2==0)
somapar=somapar+num;
else
somaimpar=somaimpar+num;
}
printf ("A soma dos números pares = %d\n",somapar);
printf ("A soma dos números ímpares = %d\n",somaimpar);
return 0;
}
E, para finalizarmos este problema:
Na sequência, os 5 números: 1 2 3 4 5
VERIFICANDO O APRENDIZADO
A) soma=0
para (cont=1; cont<=121; cont++)
{
soma = soma + cont
{
mostre(soma)
D) soma=0
para (cont=1; cont<=121; cont--)
{
soma = soma + cont
{
mostre(soma)
GABARITO
1. Assinale a opção que apresenta corretamente a estrutura do comando FOR, para mostrar os
números pares de 2 a 2002 (inclusive), em ordem decrescente:
Como é em ordem decrescente, o valor inicial da variável que controla a repetição é 2002;(cont=2002). A
condição é (cont>=2) enquanto cont for maior ou igual a 2, vai processar. O decremento, já que vamos
começar com valor maior que a condição, será de 2, pois estamos processando números pares. Assim o
correto é: for (cont=2002;cont>=2;cont=cont-2).
2. Assinale a opção que apresenta o trecho de código correto em Portugol para mostrar a soma dos
números compreendidos entre 1 e 121 (inclusive):
A alternativa B está errada, pois não inicializa a variável soma e decrementa a variável de controle que
foi iniciada com 1; a alternativa C está errada, pois não inicializa a variável soma e incrementa a
variável de controle que foi iniciada com 121; já a alternativa D está errada, pois decrementa a variável
de controle que foi inicializada com 1.
MÓDULO 2
Identificar conceitos e assertivas relacionados aos comandos de repetição com teste no início
1º Exemplo: desenvolver um programa que leia uma sequência de números inteiros terminada em 0 e
mostre cada número lido (exceto o 0).
LÓGICA:
O comando FOR do C não é indicado para resolver esse tipo de problema, posto que não sabemos
quantos números serão lidos antes do 0. Pode até ser que a sequência tenha apenas o 0 e nada precise ser
feito.
Não temos como precisar a quantidade exata de números que virão antes do 0, o que sinaliza o fim da
sequência de números, diferentemente de todos os problemas de repetição vistos até aqui.
Sem saber a quantidade exata de números a serem processados, o uso do comando FOR não é adequado.
Uma das soluções é usar o comando de repetição com teste no início, ou seja, o comando testa a condição
antes de iniciar a sequência de comandos a ser repetida.
DEMONSTRAÇÃO
Vejamos a sintaxe em Portugol e em Linguagem C:
// Código em Portugol
// Código em Linguagem C
Vejamos o funcionamento do comando WHILE (acompanhe pela sintaxe geral demonstrada acima):
A condição é testada;
O fluxograma representa a lógica a ser seguida pelo comando de repetição com teste no início:
A condição é avaliada (como verdadeira ou falsa) antes que a sequência de comandos a ser repetida seja
executada. O que significa dizer que essa sequência pode não ser executada nenhuma vez.
Uma vez que a condição seja verdadeira, a sequência de comandos a ser repetida é executada.
A sequência de comandos deixa de ser executada tão logo a condição seja falsa. A condição terá que ser
FALSA, em algum momento, pois caso contrário a sequência de comandos será executada infinitamente,
situação que chamamos de loop.
inteiro num
// Código em Linguagem C
int num;
enquanto (num!=0)
// Código em Linguagem C
while (num!=0)
// Código em Portugol
inteiro num
leia(num)
enquanto (num!=0)
// Código em Linguagem C
int num;
scanf("%d",&num);
while (num!=0)
inteiro num
leia(num)
enquanto (num!=0)
{
escreva (num)
}
// Código em Linguagem C
int num;
scanf("%d",&num);
while (num!=0)
{
printf ("O número lido foi = %d\n\n",num);
}
Solução seria, então, inserir um comando de leitura de conteúdo para a variável num , dentro da
repetição, após o comando de exibir o número lido (mesmo comando scanf escrito antes do WHILE).
// Código em Portugol
inteiro num
leia(num)
enquanto (num!=0)
{
escreva (num)
leia (num)
}
// Código em Linguagem C
int num;
scanf("%d",&num);
while (num!=0)
{
printf ("O número lido foi = %d\n\n",num);
scanf("%d",&num);
}
// Código em Portugol
inteiro num
leia(num)
escreva ("Digite um número: ")
enquanto (num!=0)
{
escreva (num)
escreva ("Digite um número: ")
leia (num)
}
// Código em Linguagem C
int num;
printf ("Digite um número: ");
scanf("%d",&num);
while (num!=0)
{
printf ("O número lido foi = %d\n\n",num);
printf ("Digite um número: ");
scanf("%d",&num);
}
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int num;
int main()
{
printf ("Digite um número: ");
scanf("%d",&num);
while (num!=0)
{
printf ("O número lido foi = %d\n\n ",num);
printf ("Digite um número: ");
scanf("%d",&num);
}
return 0;
}
SUGESTÃO
Sugerimos que você abra um novo projeto no Dev-C++, copie e cole o programa em C acima e execute-o
com esta sequência de dados:
99
199
2999
-4
0
Veja como ficará a execução dessa sequência no respectivo código.
TEORIA NA PRÁTICA
O comando WHILE permite que resolvamos problemas com repetições com número fixo e conhecido de
vezes, assim como fizemos com o comado FOR?
RESOLUÇÃO
COMENTÁRIO
Vejamos um exemplo de um dos programas vistos quando estudamos o comando FOR (PARA).
1º problema: desenvolva um programa que leia 15 números inteiros e positivos e mostre o maior deles.
Neste vídeo, iremos resolver o primeiro problema juntos e teremos a ajuda de Marcelo Vasques, mestre
em Computação Aplicada e Automação:
SOLUÇÃO
// Código em Linguagem C - Com o comando FOR
int main()
{
float nota1,nota2,nota3,media;
int contalunos;
for (contalunos=1;contalunos<=40;contalunos++)
{
printf("Entre com a nota 1 do aluno: ");
scanf("%f",¬a1);
printf("Entre com a nota 2 do aluno: ");
scanf("%f",¬a2);
printf("Entre com a nota 3 do aluno: ");
scanf("%f",¬a3);
media=(nota1+nota2+nota3)/3;
if (media>=7)
printf("APROVADO com média %.2f \n\n",media);
else
printf("REPROVADO com média %.2f \n\n",media);
}
return 0;
}
int main()
{
float nota1,nota2,nota3,media;
int contalunos=1;
while (contalunos<=40)
{
printf("Entre com a nota 1 do aluno: ");
scanf("%f",¬a1);
printf("Entre com a nota 2 do aluno: ");
scanf("%f",¬a2);
printf("Entre com a nota 3 do aluno: ");
scanf("%f",¬a3);
media=(nota1+nota2+nota3)/3;
if (media>=7)
printf("APROVADO com média %.2f \n\n",media);
else
printf("REPROVADO com média %.2f \n\n",media);
contalunos++;
}
return 0;
}
3º problema: desenvolver um programa que leia uma sequência de letras (a... z) terminada em ponto (.) e
que mostre quantas vezes cada vogal (a, e, i, o, u) apareceu na lista.
LÓGICA:
Vamos precisar de uma variável do tipo caracter (char em C) para armazenar cada letra lida; de uma
variável para acumular cada vogal (conta, conte, conti, conto, contu) e inicializar cada uma com zero.
// Código em Portugol
caracter letra
inteiro conta=0, conte=0, conti=0, conto=0, contu=0
// Código em Linguagem C
char letra;
int conta=0, conte=0, conti=0, conto=0, contu=0;
Como a condição está expressa em termos da variável de nome letra, precisamos garantir que nela haja
conteúdo lido, o que nos leva a fazer uma leitura antes da repetição.
// Código em Portugol
caracter letra
inteiro conta=0, conte=0, conti=0, conto=0, contu=0
{
}
// Código em Linguagem C
char letra;
int conta=0, conte=0, conti=0, conto=0, contu=0;
{
}
O processamento desse programa é contabilizar cada vogal, então temos que usar um comando de decisão
(seleção) para que saibamos quando a letra for uma das vogais. Como temos que contabilizar cada vogal,
o comando mais adequado é o de seleção múltipla : SWITCH (ESCOLHA). Nosso interesse é apenas
quando letra for igual a uma das vogais, pois incrementaremos cada uma das variáveis contadoras de
vogal.
// Código em Portugol
escolha (letra)
{
caso 'a':
conta++; pare;
caso 'e':
conte++;pare;
caso 'i':
conti++;pare;
caso 'o':
conto++;pare;
caso 'u':
contu++;pare;
}
// Código em Linguagem C
switch (letra)
{
case 'a':
conta++; break;
case 'e':
conte++;break;
case 'i':
conti++;break;
case 'o':
conto++;break;
case 'u':
contu++;break;
}
Agora temos que acrescentar a leitura de novo conteúdo para a variável letra dentro da repetição, pois,
caso contrário, o valor lido antes da repetição será processado indefinidamente e mostrará cada contador
de variável quando for lido o “.” (ponto) que determina o fim da sequência de letras, o final da repetição.
// Código em Portugol
caracter letra
inteiro conta=0, conte=0,contei=0,conto=0,contu=0
leia (letra)
enquanto (letra!= '.')
{
escolha (letra)
{
caso 'a':
conta++;pare;
caso 'e':
conte++;pare;
caso 'i':
conti++;pare;
caso 'o':
conto++;pare;
caso 'u':
contu++;pare;
}
leia (letra)
}
escreva (conta)
escreva (conte)
escreva (conti)
escreva (conto)
escreva (contu)
// Código em Linguagem C
char letra;
int conta=0, conte=0, conti=0, conto=0, contu=0;
scanf("%c",&letra);
while (letra!='.')
{
switch (letra)
{
case 'a':
conta++;break;
case 'e':
conte++;break;
case 'i':
conti++;break;
case 'o':
conto++;break;
case 'u':
contu++;break;
}
scanf("%c",&letra);
}
printf("Total de a: %d \n",conta);
printf("Total de a: %d \n",conte);
printf("Total de a: %d \n",conti);
printf("Total de a: %d \n",conto);
printf("Total de a: %d \n",contu);
SOLUÇÃO
Agora veja o programa completo, escrito na linguagem C, acrescido do comando printf de interação
com o usuário:
#include <stdio.h>
#include <stdlib.h>
int main()
{
char letra;
int conta=0, conte=0, conti=0, conto=0, contu=0;
printf("Digite uma letra minúscula (a..z) a cada linha e tecle ENTER : \n");
scanf("%c",&letra);
while (letra!='.')
{
switch (letra)
{
case 'a':
conta++;break;
case 'e':
conte++;break;
case 'i':
conti++;break;
case 'o':
conto++;break;
case 'u':
contu++;break;
}
scanf("%c",&letra);
}
printf("Total de a: %d \n",conta);
printf("Total de a: %d \n",conte);
printf("Total de a: %d \n",conti);
printf("Total de a: %d \n",conto);
printf("Total de a: %d \n",contu);
return 0;
}
VERIFICANDO O APRENDIZADO
B) O comando WHILE e FOR podem ser aplicados exatamente aos mesmos problemas, não havendo
distinção entre eles.
C) Sendo o teste da condição no início da repetição, a sequência de comandos a ser repetida sempre será
executada.
D) Para problemas onde a quantidade de vezes é conhecida, não podemos usar o comando WHILE,
apenas o FOR.
2. CONSIDERE FAZER UM PROGRAMA EM C QUE LEIA UMA
SEQUÊNCIA DE NÚMEROS INTEIROS TERMINADA EM 9 OU 99.
ASSINALE A OPÇÃO QUE MOSTRA CORRETAMENTE A EXPRESSÃO DA
CONDIÇÃO DO COMANDO ENQUANTO PARA RESOLVER O PROBLEMA.
GABARITO
1. Avalie cada assertiva a seguir, referentes aos comandos WHILE e FOR, da Linguagem C e
assinale a única correta:
A alternativa B está incorreta porque existem problemas aplicáveis ao ENQUANTO para os quais o
FOR não é adequado; a alternativa C é incorreta pois basta que a condição seja falsa já no primeiro laço
da repetição para que ela não seja executada; já a alternativa D é incorreta porque nesse tipo de
problema, ambos os comandos podem ser usados.
2. Considere fazer um programa em C que leia uma sequência de números inteiros terminada em 9
ou 99. Assinale a opção que mostra corretamente a expressão da condição do comando
ENQUANTO para resolver o problema.
Identificar conceitos e assertivas relacionados aos comandos de repetição com teste no final
DEMONSTRAÇÃO
Veja, a seguir, a sintaxe do comando de repetição com teste de condição no final em Portugol e em
linguagem C:
// Código em Portugol
FUNCIONAMENTO DO COMANDO
DO...WHILE
O comando DO... WHILE repete um bloco ou sequência de instruções, enquanto uma condição for
verdadeira. No momento em que a condição é falsa, o controle do programa passa ao comando após a
repetição (ao bloco que está sendo executado repetidas vezes).
Vejamos o funcionamento do comando DO... WHILE (acompanhe pela sintaxe geral demonstrada
anteriormente):
A condição é avaliada (como verdadeira ou falsa) depois que a sequência de comandos a ser repetida é
executada. O que significa que essa sequência será repetida pelo menos uma vez.
A sequência de comandos deixa de ser executada, tão logo a condição seja falsa. A condição terá que ser
falsa em algum momento, pois caso contrário a sequência de comandos será executada infinitamente,
situação essa que chamamos de loop.
TEORIA NA PRÁTICA
1º problema: leia cinco números inteiros e positivos e mostre o maior deles.
Neste vídeo, iremos resolver o primeiro problema juntos e teremos a ajuda de Marcelo Vasques, mestre
em Computação Aplicada e Automação:
SAIBA MAIS
Qualquer que seja o problema, sempre poderemos optar pela solução com WHILE ou DO... WHILE e
teremos apenas essas duas diferenças citadas? Leia a nossa resposta completa.
2º problema: desenvolva um programa que leia uma sequência de números, podendo terminar com o
número 0 ou 9. Para cada número lido (diferente de 0 ou 9), mostre seu sucessor caso o número seja par,
ou seu antecessor se o número for ímpar.
LÓGICA:
Veja aqui alguns exemplos de entrada com a lista terminando, no primeiro exemplo com 0 (zero) e no
segundo exemplo com 9 (nove), e respectivos exemplos de saída. Optamos por usar o comando DO...
WHILE, ou seja, precisamos de uma variável num, para ler cada número da sequência.
Determinamos a condição do comando DO... WHILE. A sequência pode ser encerrada com a leitura dos
números 0 ou 9, logo, a repetição deve acontecer enquanto num for diferente de 0 e de 9, pois basta que
uma das condições seja falsa para invalidar toda a condição e a sequência de repetição seja interrompida,
uma vez que estamos usando o operador lógico E (&& em C ).
// Código em Portugol
inteiro num
faca
{
}
enquanto(num!=0 && num!=9)
// Código em Linguagem C
int num
do
{
}
enquanto(num!=0 && num!=9)
2
A leitura de valor para a variável num é realizada dentro da repetição, juntamente com o teste: se num
é par (resto da divisão por 2 é igual a 0) ou se é ímpar (resto por 2 é diferente de 0). Esse teste é
mutuamente exclusivo, de forma que podemos testar se num é par, aplicando a regra do par, ou se é
ímpar, aplicando a regra do ímpar na cláusula senão, conforme mostrado a seguir. Devemos considerar
ainda que o processamento de exibição do sucessor ou antecessor não deve acontecer quando for lido o
conteúdo 0 ou 9 para a variável num .
// Código em Portugol
inteiro num
faca
{
escreva ("Digite um número: ")
leia (num)
se (num!=0 && num!=9)
{
se (num%2 ==0)
escreva ("Sucessor",num+1)
senao
escreva ("Antecessor",num-1)
}
}
enquanto (num!=0 && num!=9);
// Código em Linguagem C
int num
do
{
printf ("Digite um número: ");
scanf("%d",&num);
if (num!=0 && num!=9)
{
if (num%2 ==0)
printf ("Sucessor = %d\n\n ",num+1);
else
printf ("Antecessor = %d\n\n ",num-1);
}
}
while (num!=0 && num!=9);
SOLUÇÃO
Agora, observe ao lado o código completo da solução usando o DO... WHILE na linguagem C:
// Código em Linguagem C
#include <stdio.h>
#include <stdlib.h>
int main()
{
int num
do
{
printf ("Digite um número: ");
scanf("%d",&num);
if (num!=0 && num!=9)
{
if (num%2 ==0)
printf ("Sucessor = %d\n\n ",num+1)
else
printf ("Antecessor = %d\n\n ",num-1);
}
}
while (num!=0 && num!=9);
return 0;
}
TABELA DE IMPOSTO
LÓGICA:
Esse é um problema, que será resolvido usando os 3 comandos de repetição. Vamos iniciar com o
comando FOR (PARA). Variáveis reais (float ) necessárias: salbruto , salliquido , imposto , totbruto ,
totliquido e totimposto , além da variável inteira para controlar a repetição.
SOLUÇÃO
Veja os códigos completos da solução, na linguagem C, usando, respectivamente os comandos FOR,
WHILE e DO... WHILE:
#include <stdio.h>
#include <stdlib.h>
int main()
{
float salbruto, salliquido, imposto, totbruto=0, totliquido=0,totimposto=0;
int contfunc;
for (contfunc=1;contfunc<=15;contfunc++)
{
printf ("Digite o salário bruto: ");
scanf("%f",&salbruto);
if (salbruto >999)
imposto = salbruto*0.10;
else
if (salbruto >1999)
imposto = salbruto*0.15;
else
if (salbruto >9999)
imposto = salbruto*0.20;
else
if (salbruto >99999)
imposto = salbruto*0.25;
else
imposto = salbruto*0.30;
salliquido = salbruto - imposto;
printf ("Salário Liquido: %.2f \n",salliquido);
totbruto = totbruto + salbruto;
totliquido = totliquido + salliquido;
totimposto = totimposto + imposto;
}
printf ("TOT salário bruto : %.2f \n",totbruto);
printf ("TOT salário líquido : %.2f \n",totliquido);
printf ("TOT salário líquido : %.2f \n",totimposto);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main()
{
float salbruto, salliquido, imposto, totbruto=0, totliquido=0,totimposto=0;
int contfunc=1;
while (contfunc<=15)
{
printf ("Digite o salário bruto: ");
scanf("%f",&salbruto);
if (salbruto >999)
imposto = salbruto*0.10;
else
if (salbruto >1999)
imposto = salbruto*0.15;
else
if (salbruto >9999)
imposto = salbruto*0.20;
else
if (salbruto >99999)
imposto = salbruto*0.25;
else
imposto = salbruto*0.30;
salliquido = salbruto - imposto;
printf ("Salário Liquido: %.2f \n",salliquido);
totbruto = totbruto + salbruto;
totliquido = totliquido + salliquido;
totimposto = totimposto + imposto;
contfunc++;
}
printf ("TOT salário bruto : %.2f \n",totbruto);
printf ("TOT salário líquido : %.2f \n",totliquido);
printf ("TOT salário líquido : %.2f \n",totimposto);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main()
{
float salbruto, salliquido, imposto, totbruto=0, totliquido=0,totimposto=0;
int contfunc=1;
do
{
printf ("Digite o salário bruto: ");
scanf("%f",&salbruto);
if (salbruto >999)
imposto = salbruto*0.10;
else
if (salbruto >1999)
imposto = salbruto*0.15;
else
if (salbruto >9999)
imposto = salbruto*0.20;
else
if (salbruto >99999)
imposto = salbruto*0.25;
else
imposto = salbruto*0.30;
salliquido = salbruto - imposto;
printf ("Salário Liquido: %.2f \n",salliquido);
totbruto = totbruto + salbruto;
totliquido = totliquido + salliquido;
totimposto = totimposto + imposto;
contfunc++;
}
printf ("TOT salário bruto : %.2f \n",totbruto);
printf ("TOT salário líquido : %.2f \n",totliquido);
printf ("TOT salário líquido : %.2f \n",totimposto);
return 0;
}
VERIFICANDO O APRENDIZADO
A) O comando DO... WHILE repete a sequência de comandos até que a condição seja verdadeira.
B) O comando DO... WHILE, por fazer o teste da condição no final do laço que se repete, sempre vai
executar ao menos uma vez a sequência de comandos a ser repetida.
C) No comando DO... WHILE, o teste da condição é feito ao final do laço da repetição e no comando
WHILE, o teste é feito no início do laço.
D) Para problemas nos quais conhecemos o número de vezes que a sequência de comandos será repetida,
os 3 comandos (FOR, WHILE, DO... WHILE) podem ser usados, sendo o comando FOR o mais
adequado.
A) cont=100;
do
{
printf (“contador=”, cont);
cont--;
}
while (cont>=1);
B) cont=100;
do
{
printf (“contador=”, cont);
cont--;
}
while (cont>1);
C) cont=100;
do
{
printf (“contador=”, cont);
}
while (cont>1);
D) cont=100;
do
{
printf (“contador=”, cont);
cont--;
}
while (cont<=1);
GABARITO
1. Avalie as afirmativas a seguir com relação aos comandos DO... WHILE, WHILE e FOR da
Linguagem C e assinale a alternativa incorreta:
O comando DO... WHILE repete enquanto a condição for verdadeira, ou até que ela seja falsa.
2. Considerando o trecho de código abaixo com o comando FOR, assinale o seu equivalente usando
o comando DO... WHILE:
for (cont=100; cont>=1; cont--)
printf(“contador=”,cont);
CONCLUSÃO
CONSIDERAÇÕES FINAIS
As três estruturas de repetição podem ser usadas, indiscriminadamente, em todo problema que demandar
repetições de instruções no processamento dos dados, ou seja, sempre que for exigido que um bloco de
comandos seja repetido. Todavia, existirá sempre a estrutura mais adequada, conforme a especificidade
do problema.
AVALIAÇÃO DO TEMA:
REFERÊNCIAS
ANDRADE, M. C. Algoritmos. Rio de Janeiro: SESES, 2014. 128 p.
EXPLORE+
Busque o Online C++ Compiler do editor GDB para compilar um programa em C, caso não tenha
o Dev-C++ instalado
CONTEUDISTA
Marcelo Vasques de Oliveira
CURRÍCULO LATTES