Revisãoaulatomada de Decisaoerepetiçao Determinada

Tomada de Decisão
Em alguns problemas, o que deve ser feito depende do

contexto (armazenado nos valores das variáveis).,
isto é, a ação a ser executada depende de alguma
condição encontrada durante a execução.
Portanto deve-se construir um código que forneça a

habilidade necessária para tomar a decisão de qual
rumo seguir durante a execução
1
Formas de Tomada de decisão
 Faça um algoritmo que capture duas notas de um aluno exibindo

sua média ponderada e uma mensagem de parabenização caso
esteja aprovado
– Na solução deve ser permitido ao executor decidir se exibe a
mensagem de Parabéns!!!
– Decidir se uma ação deve ou não ser executada
(Filtro)
 Faça um algoritmo que capture as duas notas de um aluno
exibindo sua média ponderada e sua situação (“aprovado” ou
“reprovado”)
– Na solução deve ser permitido ao executor selecionar que
mensagem (“Aprovado” ou “Não Aprovado”) será exibida
– -Escolher a alternativa adequada entre diversas alternativas possíveis
(Categorização)
2
Comando if - Decidir se uma ação deve
ou não ser executada
if (condição) V condição
{
bloco
} F
bloco
SIM
Permite que o executor decida o que fazer

baseado em condições que são avaliadas de
acordo com o contexto ( valores das variáveis)
em tempo de execução
TOMADA DE DECISÃO
3
Comando if : Escolher a alternativa adequada
entre diversas alternativas possíveis
 Sintaxe completa
V condição F
if (condição)
{
bloco sim bloco bloco
} SIM NÃO
else
{
bloco não
}
4
Condição: Expressões booleanas
Paula
 Uma expressão booleana é construída através da

utilização de operadores relacionais.
– maior que (>),
– menor que (<),
– maior ou igual a (>=),
– menor ou igual a (<=),
– diferente de (!=),
– igual a (==).
 Todos estes operadores comparam dois operandos,
resultando no valor 0 (falso) ou diferente de 0
(verdadeiro).
5
Condição Expressões booleanas
 Expressões booleanas também podem ser formadas com conectivos lógicos.

– negação (!),
– conjunção (&&) e
– disjunção (||).
 Operadores lógicos combinam expressões ou valores booleanos, resultando num
valor booleano (0 ou 1).
Conjunção (E- &&) Disjunção (OU-||) Negação (Não-!)
Operando 1 Operando 2 Resultado Operando 1 Operando 2 Resultado Operando Resultado
Falso Falso Falso Falso Falso Falso Falso Verdadeiro
Falso Verdadeiro Falso Falso Verdadeiro Verdadeiro Verdadeiro Falso
Verdadeiro Falso Falso Verdadeiro Falso Verdadeiro
Verdadeiro Verdadeiro Verdadeiro Verdadeiro Verdadeiro Verdadeiro

6
Faça um programa em C que capture o código da disciplina e as 2 notas de um aluno na
disciplina, calculando e exibindo sua média e , caso sua média seja superior a 8.5 e pelo
menos uma das notas seja superior a 9, convide-o para a monitoria.
Há dois possíveis cálculos de médias.:
critério 1: média ponderada, onde a p1 tem peso 3, e a P2 tem peso 5.
As disciplinas de código ímpar, seguem o critério 1 e as de código par seguem o critério 2.
Faça funções para:

 o cálculo da média: esta função recebe o código da disciplina e as notas e retorna
a média calculada de acordo com o critério
 Cálculo de média ponderada: recebe 2 notas e 2 pesos e retorna a média
ponderada
Ent. dados :
código da disciplina, nota1, nota2
impar
Saídas:
Media calculada ( sempre, mas tem 2 formas distintas de cálculo  escolha pelo código
par
“Quer ser monitor”: ( às vezes, seleção, critério: media >=8.5 e pelo menos uma das notas
de prova >=9)
7
float calcula_media(int cod, float nota1, float nota2);
float media_ponderada( float n1, int peso1, float n2, int peso2);
int main(void)
{
int cod;
float media, nota1, nota2;
printf(“ Digite o codigo da disciplina e suas 2 notas:”);
scanf(“%d %f %f”, &cod,&nota1, &nota2);
media = calcula_media(cod, nota1,nota2);
printf( “Sua média: %.2f ”, media);
if ( media > 8.5 && ( nota1 >=9 || nota2 >=9)) Monitores :
média >= a 9
{
printf ( “Voce quer ser monitor?”);
}
return 0;
}
8
int main(void)
{
int cod;
printf(“Cod.da disciplina e suas 2 notas:”);
scanf(“%d %f %f”, &cod,&nota1, &nota2);
printf( “Sua média: %.2f ”, media);
if ( media > 9) {
printf ( “Você quer ser monitor?”);
}
return 0;
}
9
float calcula_media( int cod, float n1, float n2)
{
float media;
if (cod%2 == 1)
{
media = media_ponderada( n1, 3, n2,5 );
}
else
{
media = media_ponderada( n1,2 , n2, 8 );
}
return media;
}
float media_ponderada( float n1, int p1, float n2, int p2)
{
float media;
media = (n1*p1 + n2 * p2)/(p1+p2);
return media;
}
10
Faça um programa em C que capture o código da disciplina, as 2 notas de um aluno na disciplina e a
quantidade de faltas, calculando e exibindo sua média e situação ( AP, RF,RM). Caso esteja aprovado e
sua média seja superior a 9, convide-o para a monitoria.
Há dois possíveis cálculos de médias.:
Disciplinas do critério 1 são de 2 créditos (30 aulas) e as do critério 2 são de 4 créditos (60 aulas)
As disciplinas de código ímpar, seguem o critério 1 e as de código par seguem o critério 2.
Faça funções para:
 o cálculo da média: esta função recebe o código da disciplina e as notas e retorna a média
calculada de acordo com o critério
 Cálculo de média ponderada: recebe 2 notas e 2 pesos e retorna a média ponderada
 Mostra a media , % de faltas e a situação: esta função recebe o código da disciplina, a média
e a quantidade de faltas e exibe na tela o código e, se o aluno está reprovado por faltas,
apenas o percentual de faltas e sua situação ( RF). Caso contrário, deve exibir o percentual
de faltas, a média e a situação (AP: - de 25% de faltas e media >=5; RM: - de 25% de faltas e
media >=5)
 Percentual
Ent. dados : de Faltas: esta função recebe o código da disciplina e a quantidade de faltas,
retornando o % de faltas do aluno
código da disciplina, nota1, nota2, quantidade de faltas
impar
Saídas:
Media calculada ( sempre, mas tem 2 formas distintas de cálculo  escolha pelo código
par
Situação: RF OU AM ou RM
“Quer ser monitor”: ( às vezes, seleção, critério: media >9)
11
void mostra ( int cod, float media, int faltas);
int percentual_faltas(int cod, int faltas);
int main(void)
{
int cod,faltas;
printf(“Cod.da disciplina, suas 2 notas e faltas:”);
scanf(“%d %f %f”, &cod,&nota1, &nota2,&faltas);
mostra ( cod, media,faltas);
return 0;
}
12
float calcula_media( int cod, float n1, float n2)
{
float media;
if (cod%2 == 1)
{
media = media_ponderada( n1, 3, n2,5 );
}
else
{
media = media_ponderada( n1,2 , n2, 8 );
}
return media;
}
float media_ponderada( float n1, int p1, float n2, int p2)
{
float media;
media = (n1*p1 + n2 * p2)/(p1+p2);
return media;
}
13
void mostra( int cod, float media, int faltas)
{
int percent;
percent = percentual_faltas( cod ,faltas);
printf( “Disciplina: %d – Percentual de faltas: %d %%”, cod, percent);
if(percent > 25){
printf( “\t – RF”);
}
else
{
printf( “\t Media: %.2f ”,media);
If (media > = 5)
{
printf( “\t – AP”);
if ( media > 9) {
printf ( “Você quer ser monitor?”);
}
}
else
{
printf( “\t – RM”);
}
}
return;
}
14
int percentual_faltas( int cod, int faltas)
{
int percent,totaulas;
if (cod%2 == 1)
{
totaulas = 30;
}
else
{
totaulas = 60;
}
percent = faltas*100/totaulas;
return percent;
}
15
void mostra ( int cod, float media, int faltas); O QUE DEVE SER
int percentual_faltas(int cod, int faltas); FEITO PARA QUE ESTE
int main(void) PROGRAMA

PROCESSE 2 ALUNOS?
{
int cod,faltas;
printf(““Cod.da disciplina, suas 2 notas e faltas:”);
return 0;
}
16
----------------
int main(void) Solução para 2 alunos
{
int cod,faltas;


return 0;
}
return 0; } 17
Solução para várias pessoas
int main(void)
{
int cod,faltas;

}
NECESSIDADE DE REPETIR UMA SEQÜÊNCIA DE INSTRUÇÕES!
18
Comando while
 Sintaxe:
condição F
while (condição)
V
{
bloco
bloco
}
19
Solução para várias pessoas
int main(void)
{
int cod,faltas;
while( condição)
{
}
PROBLEMA: SE O
return 0 ; EXECUTOR RETORNA.
}
COMO PARAR!!!!!!
20
Controlando a repetição
– repetir um número conhecido de vezes (4 alunos)

» repetição determinada
Controle da repetição: contando o número de vezes que o processo já foi realizado
(até atingir a meta)
– repetir um número desconhecido de vezes (uma turma )

» repetição indeterminada
Controle da repetição: pode ser interrompido de duas formas:
Por determinação do usuário ( via entrada de dados)
Por determinado contexto (valores das variáveis)
21
Comando while
 Como controlar a repetição um número pré-determinado

de vezes?
CONTAR quantas vezes o bloco já foi executado
Contar envolve:
– Conhecer o número total de vezes a realizar :meta
– controlar quantas vezes já foi realizado
» necessidade de uma variável para controlar a quantidade de vezes que o
processo já foi feito
» qual o valor inicial dessa variável?
» como atualizar o valor dessa variável cada vez que o processo é realizado?
22
 Como controlar a repetição um nº pré-determinado de vezes? CONTANDO as repetiçoes do bloco
– saber o número total de vezes a realizar :meta
– controlar quantas vezes já foi realizado:
» uma variável para armazenar a quantidade de vezes que o processo já foi feito
» qual o valor inicial dessa variável?
» como atualizar o valor dessa variável cada vez que o processo é realizado?
int jafiz;
jafiz=0; Nº de repetiçoes=0
while( jafiz<meta
? < meta ) F
Nº de repetições < meta?
{
V
bloco
jafiz=jafiz+1; atualizar a variável que armazena o nº
de vezes que o bloco já foi executado
}
23
Solução para 30 alunos
int main(void)
{
int cod,faltas;
int jafiz;
jafiz = 0;
while( jafiz < 30)
{
mostra ( cod, media,faltas); Como todas as turmas não
têm a mesma quantidade de
jafiz = jafiz + 1; alunos, o que deveria ser
}
return 0 ; modificado neste programa?
}
24
Solução para n alunos com n informado pelo
int main(void)
usuário
{
int cod,faltas,n;
int jafiz,n;
jafiz = 0;
printf ( “Quantos alunos? “);
scanf( “%d”,&n);
while( jafiz < n)
{
jafiz = jafiz + 1;
}
return 0 ;
25
Comando while
 Exemplo
– faça um programa que leia 20 valores inteiros e, para cada um,
imprima o valor de seu quadrado
26
Comando while
 Exemplo
cont = 0;
// inicialização do contador
while (cont < 20)
{
// condição
printf(“\nDigite um valor inteiro”);
scanf (“%d”, &valor);
quad = valor * valor;
printf (“\nValor ao quadrado = %d”, quad);
cont = cont + 1;
// atualização do contador
}
27
Comando while
int cont, quad, valor;
cont = 0;
while ( cont
cont< <
2 2 )
{
printf(“\nDigite um valor inteiro”);
scanf (“%d”, &valor);
quad = valor * valor;
printf(“\nValor ao quadrado=%d”,quad);
cont = cont + 1;
}
printf(“FIM”); cont 012
4 4 8
valor
8 16 64
quad
28
Exercício
 Faça um programa que capture a matrícula, nota da 1ª prova, nota da 2ª prova, nota do 1º
trabalho e nota do 2º trabalho de n ( lido) alunos. Este programa deverá exibir para cada um, sua
matrícula, média de provas, média de trabalhos e média final. A 1ª prova tem peso 2 e a 2ª peso
5. O 1º trabalho tem peso 2 e o 2º peso 4. Na média final, a média das provas tem peso 7 e
média dos trabalhos tem peso 3.
» Entradas
• Prova1, Prova2, Trabalho 1, Trabalho2

n vezes
» Saídas
• Media provas, Média trabalhos, Média Final

Criar uma função que calcule e
retorne a média ponderada
entre dois valores reais. Os
Média de Provas: (2*Prova1 + 5*Prova2)/7 valores e os respectivos pesos
Média trabalhos::(2*Trabalho1 + 4*Trabalho2)/6 serão recebidos com parâmetros
Média Final: (7* MediaProvas + 3*Media trabs)/10 pela função.
29
float Calc_med_pond( float val1, float peso1, float val2, float peso2)
{
float med;
med=(peso1*val1 + peso2*val2)/(peso1+peso2);
return med;
}
int main(void)
{
float pr1, pr2,tr1,tr2,medTrab,medPr,medFinal;
int jafiz,n;
jafiz = 0;
printf ( “Quantos alunos? “);
scanf( “%d”,&n);
while( jafiz < n)
{
printf (“\nDigite a nota da prova1 e da prova2”); scanf (“%f%f”, &pr1,&pr2);
printf (“\nDigite a nota do trab1 e do trab2:”); scanf (“%f%f”, &tr1,&tr2);
medPr = Calc_med_pond(pr1,2,pr2,5);
medTrab = Calc_med_pond(tr1,2,tr2,4);
medFinal = Calc_med_pond(medPr,7,medTrab,3);
printf(“\n Média Trabalhos: %.1f”, medTrab);
printf(“\nMediaProvas: %.1f”,medPr);
printf(“\nMédia Final: %.1f”, medFinal);
jafiz = jafiz + 1;
}
return 0 ;
30
 1ª Questão (3.0 pontos): Um barman inventou 15 drinks,
compostos de 3 ingredientes líquidos. Faça um programa
para calcular e exibir o percentual de cada ingrediente em
suas composições. Para cada um dos drinks, deverá ler seu
código e as quantidades, em ml, (valores reais) dos 3
ingredientes utilizados em sua composição.
O seu programa deverá utilizar, obrigatoriamente, a função abaixo que deverá ser
desenvolvida por você.
 percentual: esta função recebe como parâmetros as

quantidades utilizadas de cada um dos 3 ingredientes na
composição de um drink, calcula e retorna o percentual do
primeiro ingrediente recebido como parâmetro na
composição do drink. Protótipo da função:
float percentual (float qtda, float qtdb, float qtdc);
31
float percentual(float qtda, float qtdb, float qtdc)
{
return qtda * 100 / (qtda + qtdb + qtdc);
}
int main(void)
{
int cod, int jafiz;
float qtd1, qtd2, qtd3, perc1, perc2, perc3;
jafiz = 0;
while (jafiz<15)
{
printf("Digite o codigo e as quantidades dos 3 ingredientes: ");
scanf(“%d %f %f %f", &cod, &qtd1,&qtd2,&qtd3);
perc1 = percentual(qtd1,qtd2,qtd3);
printf("\nPercentual do primeiro ingrediente: %.2f", perc1);
printf("\nPercentual do segundo ingrediente: %.2f", perc2);
printf("\nPercentual do terceiro ingrediente: %.2f", perc3);
jafiz++;
}
return 0;}
32
Repetição Determinada
 Exemplo
Faça um programa em C que receba para cada um dos n (fornecidos pelo
usuário) jogos desta rodada, o código e o número de gols feitos pelo 1º
time e o código e o número de gols feitos pelo 2º time, mostrando o
código do time vencedor do jogo ou a mensagem “empate”
Entrada: cod e gols do time1 cod e gols do time2

n vezes
Saída: cod do time1 OU cod do time2 OU “Empate”
escolher qual a resposta de acordo com o
resultado do jogo
Implemente...
33
void situacao( int gol1, int gol2,int cod1,int cod2)
{
if( gol1 == gol2) {
printf("Empate");
}
else {
if ( gol1 < gol2) {
printf("%d ganhou",cod2);
}
else {
}
}
return ;
}
int main(void)
{
int cod1,cod2,gol1,gol2, jafiz,meta;
printf("Jogos?"); scanf("%d”,&meta);
jafiz = 0;
while ( jafiz <meta)
{
printf ( "Resultado do jogo");
scanf("%d %d %d %d",&cod1,&gol1,&cod2,&gol2);
situacao(gol1,gol2,cod1,cod2);
jafiz = jafiz + 1;
}
return 0;
} 34
#include <stdio.h>
int main(void)
{ int cod1,cod2,gol1,gol2, jafiz,meta;
printf("Jogos?");
scanf("%d”,&meta);
jafiz = 0;
while ( jafiz <meta)
{
printf ( "Resultado do jogo"); scanf("%d %d %d %d",&cod1,&gol1,&cod2,&gol2);
if( gol1 == gol2)
{
printf("Empate");
}
else
{
if ( gol1 < gol2)
{
} Como informar quantos
else jogos terminaram
{ empatados ?
}
}
jafiz = jafiz + 1;
}
return 0; 35
 Como contar quantos jogos terminaram empatados?

Necessário uma variável para armazenar o número de vezes que
houve empate
qtEmp: inteiro
 Inicialmente qual o valor desta variável?
ZERO
qtEmp =0
 Como contabilizar as ocorrências de empate?
 A variável qtEmp deve ter seu valor atualizado em uma unidade
toda vez que os times empataram
if (gols1 == gols2)
qtEmp= qtEmp + 1
• Quando exibir?
Após processar TODOS os times
36
int decideVenc ( int g1, int g2,int t1,int t2)
{
if( g1 == g2) {
int main(void) return 0;

}
{ else {
int cod1,cod2,gol1,gol2, jafiz,meta,time,qtEmp,totgols; if ( g1 < g2) {
printf("Jogos?"); scanf("%d”,&meta); return t2;
jafiz = qtEmp= 0; }
else {
while ( jafiz <meta) return t1;
{ }
printf ( "Resultado do jogo"); }
scanf("%d %d %d %d",&cod1,&gol1,&cod2,&gol2); }
time = decideVenc(gol1,gol2,cod1,cod2);
if ( time == 0){
printf("Empate");
qtEmp=qtEmp+1;
}
else
{
printf( “%d ganhou”, time);
}
jafiz = jafiz + 1;
}
printf( “ %d jogos empatados ”, qtEmp);
return 0;}
37
#include <stdio.h>
int main(void){
int cod1,cod2,gol1,gol2, jafiz,meta, qtEmp;
jafiz = 0;
qtEmp = 0;
while ( cont <meta)
{
if( gol1 == gol2) {
printf("Empate");
qtEmp = qtEmp + 1;
}
else {
if ( gol1 < gol2) {
} Como saber a média de gols
else { na rodada?
}
}
jafiz = jafiz + 1; Média = ∑ gols / nº de partidas
}
printf( “Houve %d empates”, qtEmp);
Variável para armazenar o
return 0;
somatório de gols 38
#include <stdio.h>
int main(void)
{
int cod1,cod2,gol1,gol2, cont,meta, qtEmp, totGols;
cont = 0;
qtEmp = 0;
totGols = 0;
while ( cont <meta)
{
totGols = totGols + gol1+gol2;
if( gol1 == gol2) {
printf("Empate");
qtEmp = qtEmp + 1;
}
else{
if ( gol1 < gol2) {
}
else {
}
}
cont=cont+1;
}
printf( “\nHouve %d empates e a Media de Gols: %.2f”, qtEmp, totGols/meta);
return 0;}
39
int decideVenc ( int g1, int g2,int t1,int t2)
{
if( gol1 == gol2) {
int main(void)
return 0;
{ }
int cod1,cod2,gol1,gol2, jafiz,meta,qtEmp,totgols,timr; else {
printf("Jogos?"); scanf("%d”,&meta); if ( g1 < g2) {
jafiz = qtEmp= totgols = 0; return t2;
}
while ( jafiz <meta) else {
{ return t1;
printf ( "Resultado do jogo"); }
scanf("%d %d %d %d",&cod1,&gol1,&cod2,&gol2); }
}
time = situacao(gol1,gol2,cod1,cod2);
if ( time == 0){
printf("Empate");
qtEmp=qtEmp+1;
}
else
{
printf( “%d ganhou”, time);
}
totgols=totgols+gol1+gol2;
jafiz = jafiz + 1;
}
printf( “ %d jogos empatados e media de gols: %f”, qtEmp, totgols/(2*n));
return 0;}
40
Comando Enquanto
 Exemplo
– Seu Joaquim, um pequeno comerciante, deseja um lucro de 45% se o valor de
custo do produto for menor que R$ 20,00; caso contrário, o lucro será de 30%.
Faça um programa que capture a quantidade de produtos comercializados. A
seguir, para cada um dos produtos, o programa obtém do Seu Joaquim o valor
de custo e lhe mostra o valor de venda ( um por um). No final, seu programa
deve mostrar o preço médio de venda.
Entrada: n
n vezes Entrada: preço compra
Saída: preço de venda
(escolher 30% ou 45% a mais)
Saída: preço médio de venda
Implemente
41
#include <stdio.h> int main(void)
float preco_venda( float custo ) {
{ float custo, venda, totvenda,media;
float perc; int n, jafiz;
if( custo < 20) printf(“Produtos?"); scanf("%d”,&n);
{ jafiz = 0;
perc = 1.45; totvenda = 0;
} while ( jafiz <n)
else {
{ printf ( “Custo do Produto? “);
perc = 1.3; scanf("%f",&custo);
} venda = preco_venda(custo);
return custo *perc; printf( “ Vender a R$ %.2f”, venda);
} totvenda = totvenda+venda;
jafiz=jafiz+1;
}
media = totVenda/n;
printf( “\nMédia dePreco: %.2f”, media);
return 0;
}
42
Construa um programa que apresente o peso total que será carregado por um
caminhão. Sabe-se que esse caminhão carrega n(lido) caixas, com pesos
diferentes. Será entrada do programa o peso de cada uma das caixas.
Entrada Caminhao: qt de caixas ( n)

Entradacaixa: peso
nx
Saidacaixa: ----
Saída Caminhao : peso total
Implemente...
43
int main(void)
{
float totPeso, peso;
int n, jafiz;
printf(“Quantas caixas?"); scanf("%d”,&n);
jafiz = 0;
totPeso = 0;
while ( jafiz <n)
{
printf( “ Peso da caixa %d”, jafiz+1);
scanf(“%f”,&peso);
totPeso = totPeso+peso;
jafiz=jafiz+1;
}
printf( “\n Total no Caminhao: %.2f”, totPeso);
return 0;
}
44
Construa um programa que calcule e mostre a área total de uma residência (sala,
cozinha, quartos, etc., sendo todos eles retangulares) e de cada um dos cômodos. O
usuário deverá entrar com a largura (L) e o comprimento (C) de cada um dos n ( lido)
cômodos da casa. Faça uma função para calcular a área de um cômodo
Entrada Casa: qt de comodos ( n)

nx Entradacomodo: L,C
Saidacomodo: área
Saída Casa : área total ∑ áreas
Implemente...
45
float areaRet( float L, float C)
{
return L*C;
}
int main(void)
{
float totArea, areaComodo, L,C,com;
int n, jafiz;
printf(“Quantos cômodos?"); scanf("%d”,&n);
jafiz = 0;
totArea = 0;
com = 1;
while ( jafiz <n)
{
printf( “\n Dimensoes do Comodo %d”, com); scanf(“%f %f”,&L,&C);
areaComodo = areaRet(L,C);
printf( “\n Area do Comodo %d: %f” , com, areaComodo);
totArea = totArea+ areaComodo;
jafiz=jafiz+1;
com=com+1;
}
printf( “\n Area da Casa: %f”, totArea);
return 0;
} 46
 Construa um programa que leia o número de ligações atendidas em cada uma das
6 horas trabalhadas diariamente por um profissional de telemarketing por um
período de n(lido) dias. Apresente o total de ligações atendidas em cada dia, nos
n dias e a quantidade diária média de ligações atendidas por ele nesse período.
Entrada período: nº de dias( n)

Entrada dia: -----
nx Entrada hora: numero de ligações
6x
Saida hora: ----
Saidadia: total de ligações: ∑ nº de ligações do hora
Saída período : total de ligações: ∑ total de ligações diárias
47
int ContaLigDiaria(void) int main(void)
{ {
int nlig,totdia; int totPeriodo, totDia;
int jafizH; int n, jafizD;
jafizH = 0; printf(“Quantos dias?"); scanf("%d”,&n);
totdia = 0; jafizD = 0;
while ( jafizH <6) totPeriodo = 0;
{ while ( jafizD <n)
printf ( “Ligaçoes? “); {
scanf("%d",&nlig); totDia = ContaLigDiaria();
totdia = totdia+nlig; printf( “\n Ligacoes do Dia: %d”, totDia);
jafizH=jafizH+1; totPeriodo = totPeriodo+totDia;
} jafizD=jafizD+1;
return totdia; }
} printf( “\n Total no Periodo: %d”, totPeriodo);
return 0;
}
48
Ao inaugurar seu negócio (um pequeno mercado), o proprietário tem em estoque várias
mercadorias e quer estimar o seu lucro com a venda das mesmas.
O código da mercadoria é utilizado para determinar o preço de custo e tipo da
mercadoria conforme descrito a seguir:
 Cálculo do preço de custo:
• os produtos de código par devem ter seu código multiplicado por R$ 0.15 e
• os produtos de código ímpar devem ser multiplicados por R$ 0.04.
 Classificação da mercadoria:
• códigos entre 1000 e 1999 são do tipo 1 perecíveis;
• códigos entre 2000 e 2999 são do tipo 2 não perecíveis
Para as mercadorias não perecíveis ( tipo = 2), o proprietário pretende obter um lucro de
30%, isto é, o preço de venda terá um acréscimo de 30% sobre o preço de custo. Para
as mercadorias perecíveis ( tipo = 1), ele vai usar uma subdivisão:
1. Carnes: o preço de venda será o preço de custo mais 10%
2. Lacticínios: o acréscimo será de 20%
3. Verduras:o acréscimo será de 8%
Independente do tipo da mercadoria, caso haja mais de 100 unidades em estoque, a
mercadoria participará da promoção e deverá receber um desconto de 5% no preço de
venda.
Faça um programa em C que capture o código de uma mercadoria e a quantidade em
estoque, calculando e mostrando o preço de venda de acordo com os critérios acima .
Caso esta mercadoria participe da promoção, o programa deverá mostrar, também, o
valor do desconto e o preço de venda na promoção.
Para as mercadorias perecíveis ( E APENAS PARA ELAS) deve ser capturado
seu subtipo( 1 para carnes, 2 para lacticínios, 3 para verduras).
MODULARIZAR A SOLUÇÃO!!!
49
float calc_preco_custo (int cod);
int classificacao (int cod);
float calc_preco_venda (float valor, int cod);
int main (void) SOLUÇÃO PARA 1 PRODUTO
{
float desconto, precofinal, preco, valor;
int cod, quantidade, tipo;
printf("\n Diga o codigo e a quantidade da mercadoria\n");
scanf("%d %d", &cod, &quantidade);
valor=calc_preco_custo(cod);
preco=calc_preco_venda( valor, cod);
printf("\nO preco do produto eh: R$ %.2f\n", preco);
if (quantidade>100)
{
desconto=0.05*preco;
printf("\nTem desconto de:R$ %.2f\n", desconto);
printf("\nO preco final em reais eh: %.2f \n", preco-desconto);
}
return 0;
}
50
float calc_preco_venda (float valor, int cod)
float calc_preco_custo (int cod) {
{ float preco;
float valor; int subdivisao,tipo;
if (cod%2==0) tipo = classificacao(cod);
{ if (tipo==2)
{
valor=cod*0.15;
preco=1.3*valor;
} }
else else
{ {
valor=cod*0.04; printf("1-Carne; 2-Lacticinios ou 3-Verduras?");
} scanf("%d", &subdivisao);
return valor; if (subdivisao==1)
{
}
preco=1.1*valor;
int classificacao (int cod) }
{ else
int tipo; {
if (cod>=1000 && cod<=1999) if(subdivisao==2)
{ {
tipo=1; preco=1.2*valor;
}
}
else
else {
{ preco=1.08*valor;
tipo=2; }
} }
return tipo; }
return preco;
} 51
int main (void) SOLUÇÃO PARA n PRODUTOS
{
int cod, quantidade, tipo, jafiz, n;
jafiz = 0;
printf( “Quantos produtos????”);
scanf( “ %d”, &n);
while ( jafiz < n)
{
printf("\n Diga o codigo da quantidade da mercadoria\n");
if (quantidade>100)
{
}
jafiz=jafiz+1;
}
return 0;
}
52
int main (void) SOLUÇÃO PARA n (lido) PRODUTOS
{
int cod, quantidade, tipo;
printf("\n Diga o codigo e a quantidade da mercadoria\n");
if (quantidade>100)
{
return 0;
}
53
Faça um programa para calcular o valor total das compras pelo cliente em uma loja e quanto
deverá pagar de acordo com a tabela abaixo. É fornecido ao programa o preço da etiqueta de cada
um dos n ( inicialmente lido) produtos comprados e, com a compra encerrada, a condição de
pagamento escolhida pelo cliente
Código da condição de pagamento Condição de pagamento

1 À vista em dinheiro ou cheque, com 20% de desconto
2 À vista com cartão de crédito, com 15% de desconto
3 Em 2 vezes, preço normal de etiqueta sem juros
4 Em 3 vezes, preço de etiqueta com acréscimo de 10%
54
int main (void) SOLUÇÃO PARA n PRODUTOS
{
int cod, quantidade, tipo, jafiz, n;
jafiz = 0;
printf( “Quantos produtos????”);
scanf( “ %d”, &n);
while ( jafiz < n)
{
printf("\n Diga o preço da mercadoria\n");
scanf("%f", &valor);
totvalor = totvalor + valor;
jafiz=jafiz+1;
}
printf( “Qual a forma de pagamento?”);
scanf( “ %d”, &tipo);
forma_pagamento( totvalor, tipo);
return 0;
}
55
void forma_pagamento (float valor, int tipo)
{
float vpg;
int qtparc;
if (tipo==1)
{
vpg=0.8*valor;
qtparc = 1;
}
else {
if (tipo==2) {
vpg=0.75*valor;
qtparc = 1;
}
else {
if (tipo==3) {
qtparc = 2;
vpg= valor/qtparc;
}
else {
qtparc = 3;
vpg= valor*1.1/qtparc;
}
}
}
printf( “ %d x %.2f”, qtparc, vpg);
return;
}
56
MÉDIAS ACUMULADORES e
CONTADORES
acumulador = valor inicial (na maioria das vezes0) // inicialização das

contador = valor inicial (na maioria das vezes0) variáveis p/armazenar os
valores cumulativos
Para cada entrada de dados
{
// atualização da variável que
acumulador = acumulador + dado armazena o valor total até o momento
contador = contador + constante(1)
// atualização da variável que
armazena a quantidade de valores
processados até o momento
}
calcula e exibe a média dos valores, utilizando
Media = acumulador/contador o valor da variável acumuladora que agora
Exibe media armazena o somatório de todos os valores
processados
E da variável contadora que agora armazena a
quantidade de valores processados
57
 Exemplo
Implemente o jogo par ou ímpar com n( informado pelo usuário) partidas . O jogador
1 sempre será par e o vencedor será o jogador com maior número de vitórias
Entrada: n
Entrada: palpite jog1 palpite jog2
n vezes
Saída: vencedor da partida
Saída: vencedor do jogo ( escolher o jogador com maior nº de vit.)
QUESTÕES
Como saber o vencedor do jogo?
Contar as vitórias de cada Jogador
Sempre será necessário jogar n partidas?
Se algum jogador acertar mais da metade das partidas já é o vencedor!!!
58
 Como contar as vitórias?

Necessário uma variável para armazenar as vitórias do Jog1 e as
vitórias do Jog2
vitJog1, vitJog2: inteiro
 Inicialmente qual o valor destas variáveis?
ZERO
vitJog1 =0
vitJog2 = 0
 Como contabilizar as vitórias?
 A variável responsável pelo número de vitórias do jogador que
venceu a rodada deve ter seu valor atualizado em uma unidade
vitJog1= vitJog1 + 1 OU vitJog2 = vitJog2 + 1
59
CONTANDO as VITÓRIAS
int vitJog1,vitJog2, n, partida, palJog1,palJog2,soma;
int jafiz,meta;
printf (“Quantas rodadas?”);
scanf(“%d”,&meta );
vitJog1= 0; vitJog2 = 0; jafiz = 0;
while ( jafiz < meta)
{ soma= palpitesdosjogadoresesoma();
if (soma%2 ==0) {
vitJog1= vitJog1+1; }
else {
vitJog2= vitJog2 + 1; }
jafiz=jafiz+1;
}
if(vitJog1 > vitJog2){
printf(“Jogador 1 é o vencedor”);}
else {
printf(“Jogador 2 é o vencedor”);}
60
Parando o Jogo antes das n partidas
Total de Repetições: no máximo N mas NÃO EXATAMENTE N
ENQUANTO não há um vencedor ( nenhum dos

jogadores venceu metade+1 das partidas
61

Revisãoaulatomada de Decisaoerepetiçao Determinada

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Revisãoaulatomada de Decisaoerepetiçao Determinada

Enviado por

Direitos autorais:

Formatos disponíveis

Tomada de Decisão

Em alguns problemas, o que deve ser feito depende do

Portanto deve-se construir um código que forneça a

 Faça um algoritmo que capture duas notas de um aluno exibindo

Permite que o executor decida o que fazer

 Uma expressão booleana é construída através da

 Expressões booleanas também podem ser formadas com conectivos lógicos.

Conjunção (E- &&) Disjunção (OU-||) Negação (Não-!)

Operando 1 Operando 2 Resultado Operando 1 Operando 2 Resultado Operando Resultado

Falso Falso Falso Falso Falso Falso Falso Verdadeiro

Falso Verdadeiro Falso Falso Verdadeiro Verdadeiro Verdadeiro Falso

Verdadeiro Falso Falso Verdadeiro Falso Verdadeiro

Verdadeiro Verdadeiro Verdadeiro Verdadeiro Verdadeiro Verdadeiro

As disciplinas de código ímpar, seguem o critério 1 e as de código par seguem o critério 2.

Faça funções para:

int main(void) PROGRAMA

printf(“Cod.da disciplina, suas 2 notas e faltas:”);

printf(“Cod.da disciplina, suas 2 notas e faltas:”);

printf(“Cod.da disciplina, suas 2 notas e faltas:”);

NECESSIDADE DE REPETIR UMA SEQÜÊNCIA DE INSTRUÇÕES!

– repetir um número conhecido de vezes (4 alunos)

– repetir um número desconhecido de vezes (uma turma )

 Como controlar a repetição um número pré-determinado

int cont, quad, valor;

• Prova1, Prova2, Trabalho 1, Trabalho2

• Media provas, Média trabalhos, Média Final

 percentual: esta função recebe como parâmetros as

Entrada: cod e gols do time1 cod e gols do time2

 Como contar quantos jogos terminaram empatados?

int main(void) return 0;

Entrada Caminhao: qt de caixas ( n)

Entrada Casa: qt de comodos ( n)

Entrada período: nº de dias( n)

Código da condição de pagamento Condição de pagamento

acumulador = valor inicial (na maioria das vezes0) // inicialização das

 Como contar as vitórias?

Total de Repetições: no máximo N mas NÃO EXATAMENTE N

ENQUANTO não há um vencedor ( nenhum dos

Você também pode gostar