algprog2sem7

(1)

RESUMO DA AULA 18

Relembrando o final da aula 17, todos os nossos exercícios podem ser feitos indistintamente por:

 for ( ; ; ) { }  while ( ) { }  do { } while ( );

Podemos esboçar uma tabela, conforme a figura 18.1, para mostrar algumas características destes comandos para controle de repetições.

Propriedade 1 Propriedade 2 Propriedade 3

Comando “ pergunte primeiro e faça o bloco depois”

“faça o bloco primeiro e pergunte depois”. Funciona sabendo, a priori, imax For ********************** ************** while ********************** ************** do-while ********************** **************

Figura 18.1 comparação entre comandos As propriedades 1 e 2 já foram extensivamente exploradas.

A propriedade 3 sintetiza que estes comandos de repetição são controlados, até agora, por perguntas do tipo ( ivc <= imax ), (ivc < imax ) ,etc.

Isto significa que, a priori, o usuário informe imax.

O programa já deve possuir o valor de imax antes de executar alguma repetição.

Não é possível responder à pergunta se não possuirmos imax para os problemas que estamos resolvendo.

Até agora, parece que o comando do-while não gera vantagem alguma.

Até agora, é indiferente o uso de qualquer um dos 3 comandos em problemas nos quais o usuário informa, a priori, a quantidade de iterações imax a ser usada.

Quando tivermos problemas em que o usuário define antecipadamente imax, qualquer um dos 3 comandos para controle de repetição pode ser usado.

Isto significa que o bloco repetitivo é controlado por uma variável, imax, conhecida a priori. Na aula 18 veremos que nem sempre isso é verdade.

Há uma classe de problemas, conhecida como ALGORITMO DO SENTINELA OU “ FLAG” , em que temos atividades repetitivas mas não sabemos, a priori, a quantidade de repetições.

Há uma classe de problemas para os quais temos repetições mas não sabemos, a priori, a quantidade das mesmas.

Vejamos alguns exemplos de atividades repetitivas em que o usuário não define, a priori, a quantidade de vezes em que executa o programa.

(2)

Exemplo 1 : Sistema de preenchimento de formulários de cadastramento: Veja a figura 18.2 Imagine que o sistema sirva para cadastro de funcionários em uma empresa.

A cada rodada o sistema cadastra um funcionário.

Devemos criar uma variável que permita ao usuário escolher iterativamente se deseja fazer um novo cadastramento ou não.

O usuário escolhe iterativamente, não a priori, a execução da repetição.

A cada cadastramento é feita uma pergunta que permite a escolha ou não pela continuidade da repetição.

Há uma variável que serve para parar o bloco de repetição. Esta variável é chamada variável sentinela ou “ flag”. A variável sentinela ou “ flag” é testada para verificarmos se o usuário deseja novo cadastro ou não. Deve haver um critério de parada.

A variável sentinela ou “ flag” é a variável usada iterativamente para permitir ou não a repetição do bloco.

SENTINELA OU “ FLAG” É UMA VARIÁVEL USADA PARA, ITERATIVAMENTE, FREIAR OU NÃO A EXECUÇÃO DO BLOCO DE REPETIÇÃO.

figura 18.2: Sistema de controle de cadastramento Exemplo 2: Sistema de controle para restaurante por quilo: Veja a figura 18.3 Imagine que o sistema sirva como controle de caixa para um restaurante por quilo.

A cada rodada o sistema opera com um cliente; o prato é colocado na balança e é gerado um total a ser pago.

Devemos criar uma variável que permita ao dono do restaurante escolher ,iterativamente, se deseja fazer uma nova pesagem e cobrança pelo prato.

O sistema calcula iterativamente o total contido no caixa.

O usuário escolhe iterativamente, não a priori, a execução da repetição.

BLOCO1

Rotinas para cadastramento de funcionários Há outro cadastro?

(3)

figura 18.3: Sistema de controle para restaurante por quilo

Exemplo 3 : Sistema de controle para votação eletrônica.: Veja a figura 18.4. Imagine que o sistema sirva para controle de votação eletrônica.

A cada rodada o sistema executa os procedimentos de votação para um único eleitor.

Devemos criar uma variável que permita ao usuário, chefe da seção, escolher iterativamente se deseja permitir ou não que um novo eleitor se cadastre.

O chefe da seção escolhe iterativamente, não a priori, a execução da repetição.

A cada procedimento de votação é feita uma pergunta que permite a escolha ou não pela continuidade da repetição.

BLOCO1

Rotinas para pesagem e controle de caixa Há outro prato?

(4)

figura 18.4: Sistema de controle para votação Exemplo 4 : Sistema monitor de segurança : Veja a figura 18.5.

Imagine que o sistema sirva para controle de segurança de uma empresa.

A cada rodada o sistema executa os procedimentos de verificação de segurança na empresa. Devemos criar uma variável que permita ao sistema operar iterativamente se deseja continuar ou não a vistoria da segurança na empresa.

O sistema executa iterativamente, não a priori, a repetição.

A cada teste do sistema monitor é feita uma pergunta que permite a escolha ou não pela continuidade da repetição.

Há uma variável que serve para parar o bloco de repetição. Esta variável é chamada variável sentinela ou “ flag”. A variável sentinela ou “ flag” é testada para continuarmos a monitor a segurança do sistema. Deve haver um critério para a parada do sistema.

SENTINELA OU “FLAG” É UMA VARIÁVEL USADA PARA, ITERATIVAMENTE, FREIAR OU NÃO A EXECUÇÃO DO BLOCO DE REPETIÇÃO.

BLOCO1

Rotinas para cadastramento de funcionários Há outro eleitor?

(5)

figura 18.5: Sistema monitor

O procedimento padrão para a montagem do algoritmo do sentinela ou “ flag” é mostrada na figura 18.6.

do {

...

leia ou manipule a variável sentinela

if (a variável sentinela não satisfaz critério de parada) {

}

} while (a variável sentinela não satisfaz critério de parada);

figura 18.6 Formato padrão para montagem do algoritmo do sentinela ou “ flag” Para o algoritmo do sentinela ou “ flag”, é sempre importante definir:

 A variável que serve como sentinela ou “ flag”.

 O critério de parada que envolve a variável sentinela ou “ flag”.

BLOCO1

Rotinas para monitorar segurança Continua a monitorar?

(6)

O uso de sentinela ou “ flag” é feito em programas que envolvem :  Contagem  Acumulador  Percentagem  Média  Busca do maior

 Busca da posição do maior  Busca do menor

 Busca da posição do menor

Note que os cálculos feitos com atividades repetitivas são os mesmos, quer tenhamos imax , usemos sentinela ou “ flag”.

São similares :

 Problemas que envolvem uma quantidade pré-definida ( definida a priori ) de dados. No nosso caso, problemas em que definimos antecipadamente imax.

 Problemas iterativos em que há uma variável sentinela ou “flag” que controla a quantidade de repetições.

Vamos resolver um exemplo que envolva o problema do sentinela ou “ flag”. Exercício3224 - Proposto - Repetições

Objetivo: algoritmo do sentinela ou “ flag” (número de repetições definido durante execução). Uso de contadores.

Enunciado: faça um programa que leia um número inteiro positivo entre 0 e 100, escolhido por um aluno e que opere, lendo números digitados por outro aluno, até que o segundo aluno acerte o número digitado pelo mesmo.

Note que o problema funciona da seguinte maneira:  O aluno1 escolhe um valor entre 0 e 100.

 O aluno2 “chuta” números até que acerte o número escolhido pelo aluno1. Caso o aluno2 chute um valor maior que o escolhido pelo aluno1, mostre a mensagem “chute um valor menor”. Caso o aluno2 chute um valor menos que o escolhido pelo aluno1, mostre a mensagem “ chute um valor maior”. Caso o número seja acertado, devemos parar a repetição.

Devemos imprimir:

 Qual o número escolhido pelo aluno1

 O número de tentativas do aluno2. Este item envolve contagem.

Vamos exemplificar como funcionaria nosso problema a partir da figura 18.7 Este problema envolve contagem do número de vezes que o aluno2 chutou.

rodada 0 1 2 3 4 5 6

aluno1 37

aluno2 80 30 50 40 35 37

sout “menos” “mais” “menos” “menos” “mais” “certo”

Figura 18.7 Simulação do exercício3224

Note que o programa deve ser iterativo, a cada chute no mesmo deve haver uma avaliação de continuidade ou não na repetição.

A cada vez que temos continuidade na repetição, temos de somar 1 ao valor da variável rodada. O algoritmo para este problema é mostrado na figura 18.8

(7)

rodada = 0 leia ( aluno1 ) faça leia (aluno2 ) rodada = rodada + 1 se ( aluno 1 != aluno 2) se ( aluno1 < aluno2 )

imprima ( “chute mais baixo, é menor”) fim-se

senão

imprima (“chute mais alto, é maior”) fim-senão

fim-se

enquanto ( aluno1 != aluno2) imprima (rodada)

imprima ( aluno1)

Figura 18.8 Descrição algorítmica para o exercício3224 A descrição C para o mesmo é mostrada na figura 18.9.

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main ( )

{

int ialuno1 , ialuno2 , irodada ; irodada = 0;

printf("\n dar o valor secreto \n"); scanf("%d",&ialuno1);

do {

irodada = irodada + 1; printf("\n dar chute \n"); scanf("%d",&ialuno2); if ( ialuno1 != ialuno2 ) {

if ( ialuno1 < ialuno2 ) {

printf("\n chute um valor menor \n"); }

else {

printf("\n chute um valor maior \n"); }

}

} while ( ialuno1 != ialuno2 );

printf("\n valor %d tentativas %d \n", ialuno1 , irodada ); system ("pause");

return 0; }

(8)

Exercício3226 - Proposto - Repetições

Objetivo: algoritmo do sentinela ou “ flag” (número de repetições definido durante execução). Uso de contadores.

Enunciado: Um reservatório tem, em seu interior, 100 litros de produtos químicos no instante t = 0 minuto. A partir deste instante, simultaneamente são ligadas uma bomba que coloca produtos no reservatório e um torneira que drena (tira) produtos químicos deste reservatório. É feito controle minuto a minuto da quantidade contida dentro deste reservatório. Se no seu interior houver valor maior ou igual a 50 litros e valor igual ou menor a 200 litros o sistema deve continuar funcionando e procedendo com as leituras de vazão na bomba e na torneira cada minuto. Se o volume do reservatório tiver valor inferior a 50 litros ou superior a 200 litros o sistema deve parar a leitura de dados e imprimir em que instante isto ocorreu.

Faça um programa que leia pares, de volume colocado pela bomba e de volume retirado pela torneira, digitados via teclado, até que o volume do reservatório seja menor que 50 litros ou maior que 200 litros.

Exemplo: se as entradas fossem 50, 20; 70, 30 e 80, 25 deve ser impresso 3 pois,

no instante 1 houve saldo de 30 litros no reservatório (que passa a ter 130 litros), no instante 2 houve saldo de 40 litros no reservatório (que passa a ter 170 litros) e no instante 3 houve saldo de 55 litros no reservatório (que passa a ter 225 litros). Este exercício envolve acumuladores e contadores.

(9)

Uma descrição pictórica é dada na figura 18.10.

Figura 18.10 Descrição pictórica para o problema 3226 Vamos simular o sistema para as entradas mostradas na figura 18.11

rodada 0 1 2 3

entrada 50 70 80

saída 20 30 25

tanque 100 130 170 225

sout “ligado” “ligado” “desligado”

Figura 18.11 Simulação do exercício 3226

Note que a cada instante monitoramos o volume no tanque. O tanque possui limites máximo e mínimo.

A cada rodada, devemos calcular o volume do tanque após a entrada de líquidos por uma torneira e saída de líquidos por outra.

A descrição algorítmica para este problema é mostrada na figura 18.12 tanque = 100 rodada = 0 faça leia ( entrada ) leia ( saida ) rodada = rodada + 1

tanque = tanque + entrada - saida se ( tanque >= 50 e tanque <= 200 )

imprima ( “deixe sistema ligado”) fim-se

enquanto ( tanque >= 50 e tanque <= 200 ) imprima (irodada)

imprima ( tanque)

figura 18.12 descrição algorítmica para o problema 3226 A descrição C para o mesmo é mostrada na figura 18.13

Posição para 100 litros saída

(10)

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main ( ) {

float dentrada , dsaida , dtanque ; int irodada ;

dtanque = 100; irodada = 0; do

{

printf("\n dar entrada \n "); scanf("%f",&dentrada); printf("\n dar saida \n"); scanf("%f",&dsaida); irodada = irodada + 1;

dtanque = dtanque + dentrada - dsaida ; } while ( ( dtanque >= 50 ) && ( dtanque <= 200 ) );

printf(" volume %.2f no instante %d \n", dtanque , irodada ); system ("pause");

return 0; }

Figura 18.13 Descrição C para o problema 3226

O exercício 3227 envolve contagem, percentagem e comparações na busca do maior entre 2 números.

Exercício3227 - Proposto - Repetições

Objetivo: algoritmo do sentinela ou “ flag” (número de repetições definido durante execução). Uso de contadores. Cálculo de percentagem e busca de maior.

Enunciado: na eleição de um pais distante, estão concorrendo 2 candidatos à presidência: PapoFurado e SóGarganta.

Cada um dos eleitores deste país, ao votar, deve escolher 1 entre 3 possibilidades citadas a seguir:

 71 = SóGarganta;  86 = PapoFurado;  99 = anular o voto.

Cada um dos eleitores digita o seu voto e, ao final, o presidente da sessão digita 0 encerrando a votação.

Faça um programa que leia uma quantidade indeterminada de votos (terminada por 0), calcule e imprima:

 A quantidade de votos na seção;  O percentual de votos válidos;

 O ganhador da eleição ( PapoFurado, SóGarganta ou houve empate);

Exemplo: se as entradas fossem 71, 86, 86, 71, 99, 71, 86, 99, 86, 71, 71, 99, 86, 99, 71, 99, 86, 86, 86, 71, e 0; as respostas seriam: 20 votos, 75% dos votos válidos e ganhador PapoFurado

(11)

O programa continuamente lê votos. A parada na votação ocorre quando é digitado voto com valor 0. Somente o presidente da mesa possui autorização para digitar 0.

Vamos simular este exemplo. A simulação é mostrada na figura 18.14

Voto 71 86 86 71 99 71 86 99 86 71 71 99 86 99 71

Eleitores 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Votovalido 0 1 2 3 4 4 5 6 6 7 8 9 10 11 11 12

Sogarganta 0 1 1 1 2 2 3 3 3 3 4 5 5 5 5 6

Papofurado 0 0 1 2 2 2 2 3 3 4 4 4 4 5 5 5

Figura 18.14 Simulação para o exercício3227 A descrição algorítmica é mostrada na figura 18.15.

Figura 18.15 descrição algorítmica para o problema 3227 A descrição C é mostrada na figura 18.16

eleitores = 0 votosvalidos = 0 sogarganta = 0 papofurado = 0 faça { leia (voto) se ( voto != 0 ) { eleitores = eleitores + 1 se ( ( voto == 71 ) ou ( voto == 86 ) ) { votosvalidos = votosvalidos + 1; se ( voto == 86 ) { papofurado = papofurado + 1 } senão { sogarganta = sogarganta + 1; } } } }enquanto ( voto != 0 ); percentualvalido = (votosvalidos/eleitores) * 100 imprima (eleitores) imprima (percentualvalido) se ( sogarganta > papofurado ) { imprima (“sogarganta”) } senão { se ( sogarganta < papofurado ) { imprima (“papofurado”) } senão { imprima (“empate”) } }

(12)

#include <conio.h> #include <stdio.h> #include <stdlib.h> int main ( )

{

float dvotosvalidos , dpercentualvalido ;

int ieleitores , isogarganta , ipapofurado , ivoto ;

ieleitores = 0 ; dvotosvalidos = 0 ; isogarganta = 0 ; ipapofurado = 0 ; do{

printf("\n dar o voto \n"); scanf("%d",&ivoto); if ( ivoto != 0 ) { ieleitores = ieleitores + 1; if ( ( ivoto == 71 ) || ( ivoto == 86 ) ) { dvotosvalidos = dvotosvalidos + 1; if ( ivoto == 86 ) { ipapofurado = ipapofurado + 1; } else { isogarganta = isogarganta + 1; }; }; }; }while ( ivoto != 0 ); dpercentualvalido = (dvotosvalidos/ieleitores) * 100; if ( isogarganta > ipapofurado ) {

printf("\n ganhador sogarganta \n"); }

else {

if ( isogarganta < ipapofurado ) {

printf("\n ganhado papofurado \n"); } else { printf("\n empate \n"); }; };

printf("\n eleitores %d \n perc valido %.2f \n", ieleitores ,dpercentualvalido) ; system("pause");

return 0; }

(13)

Podemos esboçar uma tabela, conforme a figura 18.17, para mostrar algumas características destes comandos para controle de repetições.

Propriedade 1 Propriedade 2 Propriedade 3 Propriedade 4

Comando “ pergunte primeiro e faça o bloco depois” “faça o bloco primeiro e pergunte depois”. Funciona sabendo, a priori, imax Funciona não sabendo imax for ************* ************** while ************* ************** ************** do-while ************** ************** **************