(5 pontos) Faça o fluxograma e a codificação de um programa em Linguagem C , que receba o preço de 10 produtos e armazene os valores em um vetor. Ao final, mostre o valores inseridos no vetor, quantos preços são menores que R$ 280,00 e o valor total dos preços inseridos no vetor.
Passo 1
O enunciado pede duas coisas: (1) um fluxograma e (2) a codificação em Linguagem C de um programa que execute as operações abaixo. As informações dadas são:
- Receber o preço de
produtos; aqui o enunciado especifica como 10 . - Armazenar esses valores em um vetor.
- Ao final, mostrar:
- os valores inseridos no vetor;
- quantos preços são menores que R$
280{,}00 ; - o valor total (soma) dos preços inseridos no vetor.
O que o problema exige explicitamente: fluxograma + programa em C que leia
10
preços, guarde em vetor, conte quantos < R$
280{,}00
e calcule a soma total, e então mostre tudo isso.
Passo 2
Escolhendo a estrutura de dados e as variáveis (sem entrar ainda no código): precisamos representar na memória:
- Um vetor para guardar os
10 preços. Vou chamar de preços[]. - Um índice (contador de laço) para percorrer as posições do vetor. Vou chamar de i.
- Um acumulador para somar os preços. Vou chamar de soma.
- Um contador para contar quantos preços são menores que R$
280{,}00 . Vou chamar de contadorMenores.
Explicação didática (bem calma):
- Vetor (array): é uma sequência de posições de memória numeradas de
0 até n-1 . Aqui usamos um vetor de tamanho 10 , então os índices válidos são 0 a 9 . Cada posição guarda um preço (número real). - Índice do laço (i): variáve l inteira que controla em que posição do vetor estamos lendo/gravando.
- Acumulador (soma): variável que começa em
0{,}0 e vai somando cada preço lido. Ao final, terá a soma total. - Contador (contadorMenores): variável inteira que começa em
0 e incrementa cada vez que um preço lido é menor que R$ 280{,}00 .
Passo 3
Descrever o algoritmo passo a passo (esse é o esqueleto que será transformado em fluxograma):
- Começa (Start).
- Inicializa i =
0 , soma = 0{,}0 , contadorMenores = 0 . - Repetir enquanto i <
10 :
a. Pedir ao usuário o preço do produto número i+1.
b. Ler o preço e armazenar em preços[i].
c. Adicionar preços[i] em soma (soma = soma + preços[i]).
d. Se preços[i] < R$280{,}00 então contadorMenores = contadorMenores + 1 .
e. Incrementar i (i = i +1 ). - Depois do laço, mostrar todos os elementos do vetor preços (do índice
0 ao 9 ). - Mostrar o valor de contadorMenores.
- Mostrar o valor de soma.
- Fim.
Observação didática:
- Usei a condição i <
10 porque vetores em C são indexados a partir de 0 . - A comparação “menor que R$
280{,}00 ” é feita com o operador relacional “<”.
Passo 4
Fluxograma (descrição textual/linha a linha — você pode desenhar isso no papel usando retângulos e losangos conforme a descrição):
- Início (oval).
- Bloco de inicialização (retângulo): i ←
0 ; soma ← 0{,}0 ; contadorMenores ← 0 . - Losango (decisão): i <
10 ? - Se NÃO → vai para o bloco de saída (retângulos) e depois para Fim.
- Se SIM → Bloco de entrada (retângulo) que pede e lê preço: leia preço e armazene em preços[i].
- Em seguida Bloco (retângulo): soma ← soma + preços[i].
- Losango (decisão): preços[i] < R$
280{,}00 ? - Se SIM → Bloco (retângulo): contadorMenores ← contadorMenores +
1 . - Se NÃO → seguir.
- Se SIM → Bloco (retângulo): contadorMenores ← contadorMenores +
- Bloco (retângulo): i ← i +
1 . - Volta para o losango i <
10 .
- Quando sair do laço: Bloco (retângulo): para j =
0 até 9 imprimir preços[j]. - Bloco (retângulo): imprimir "Quantidade de preços < R$
280{,}00 : " e o valor de contadorMenores. - Bloco (retângulo): imprimir "Soma total: " e o valor de soma.
- Fim (oval).
Dica para desenhar no papel: use setas do losango/retângulos conforme o fluxo acima. Esse texto é o “mapa” do seu fluxograma.
Passo 5
Agora vamos mapear cada construção do fluxograma para uma construção em C (aula prática curta):
- Declaração do vetor:
- Em C, usamos algo como: double precos[10];
- Aqui “double” significa número real (com casas decimais). O nome “precos” é o identificador do vetor. O
10 entre colchetes é o tamanho.
- Inicialização de variáveis:
- int i = 0; int contadorMenores = 0; double soma = 0.0;
- “int” é inteiro; “double” é real.
- Laço:
- Podemos usar “for (i = 0; i < 10; i++)” ou usar “while”. O “for” é conciso e muito usado para percorrer vetores.
- Explicando “for”: for(inicialização; condição; atualização) { corpo }
- inicialização executa uma vez no começo,
- condição é testada antes de cada iteração,
- atualização executa ao final de cada iteração.
- Leitura (input):
- Em C, usamos scanf para ler do teclado. Para double usamos “%lf”. Ex.: scanf("%lf", &precos[i]);
- Importante: sempre colocar o & antes da variável (endereço).
- Escrita (output):
- Em C, usamos printf. Para imprimir double com duas casas decimais usamos “%.2f”.
- Para imprimir a unidade monetária escrevemos “R$ %.2f”.
- Condicional:
- if (precos[i] < 280.00) { contadorMenores++; }
- Aqui usamos o literal
280{,}00 no texto do enunciado; no C usamos ponto decimal 280.00 — isso não altera a lógica; apenas o formato de escrita no código é com ponto.
- Exibir todos os elementos do vetor:
- Um segundo laço “for (i = 0; i < 10; i++) printf(“Produto %d: R$ %.2f\n”, i+1, precos[i]);”
Passo 6
Exemplo prático (simulação passo a passo) — para você ver como o contador e a soma evoluem:
Suponha que os 10 preços lidos foram (apenas exemplo): R$ 100{,}00
, R$
300{,}00
, R$
250{,}50
, R$
400{,}00
, R$
150{,}75
, R$
280{,}00
, R$
279{,}99
, R$
50{,}00
, R$
1000{,}00
, R$
10{,}00
.
Vamos simular rapidamente:
Suponha que os 10 preços lidos foram (apenas exemplo): R$
Vamos simular rapidamente:
- Começa com soma =
0{,}0 , contadorMenores = 0 . - Ler R$
100{,}00 : soma = 100{,}00 , preço < 280{,}00 → contadorMenores = 1 . - Ler R$
300{,}00 : soma = 400{,}00 , não é < 280{,}00 . - Ler R$
250{,}50 : soma = 650{,}50 , é < 280{,}00 → contadorMenores = 2 . - … e assim por diante até os 10. Ao final você terá a lista completa (reimprima), o contador com o total de itens menores que R$
280{,}00 e a soma total.
Esse exemplo serve para você conferir que, linha a linha, o algoritmo faz sentido e que os incrementos e a soma estão corretos.
Passo 7
Observações práticas para a prova:
- Prefira usar “for” para percorrer um vetor quando o número de iterações é conhecido (
10 aqui). É mais direto e evita erros de off-by-one. - Em leitura com scanf, cuidado ao testar entradas inválidas — em prova simples geralmente assumimos que o usuário digita números válidos.
- Lembre-se que, no enunciado, os valores monetários aparecem com vírgula (R$
280{,}00 ), mas no código C usamos ponto decimal ( 280.00 ). Isso é apenas convenção de escrita do código.
Passo 8
Pronto — agora que você entendeu passo a passo o algoritmo, o fluxograma e como cada peça vira código em C, abaixo está a resposta final (fluxograma em forma textual compacta + código em C). Copie o código para seu editor C, compile e execute. Boa sorte na prova — você consegue!
Resposta
Fluxograma (forma compacta, adequada para desenhar):
Start → [i=0; soma=0.0; contadorMenores=0] → (i < 10?)
Se Sim: → [ler preco → armazenar em precos[i]] → [soma = soma + precos[i]] → (precos[i] < 280.00?)
Se Sim: → [contadorMenores = contadorMenores + 1] → fim do if → [i = i + 1] → voltar ao (i < 10?)
Se Não (i >= 10): → [para j = 0 até 9 imprimir precos[j]] → [imprimir contadorMenores] → [imprimir soma] → End
Start → [i=0; soma=0.0; contadorMenores=0] → (i < 10?)
Se Sim: → [ler preco → armazenar em precos[i]] → [soma = soma + precos[i]] → (precos[i] < 280.00?)
Se Sim: → [contadorMenores = contadorMenores + 1] → fim do if → [i = i + 1] → voltar ao (i < 10?)
Se Não (i >= 10): → [para j = 0 até 9 imprimir precos[j]] → [imprimir contadorMenores] → [imprimir soma] → End
Código em Linguagem C:
#include <stdio.h>
int main(void) {
double precos[10];
int i;
int contadorMenores = 0;
double soma = 0.0;
for (i = 0; i < 10; i++) {
printf("Informe o preco do produto %d: R$ ", i + 1);
if (scanf("%lf", &precos[i]) != 1) {
// Se houver erro de leitura, aborta para evitar loop infinito
printf("Entrada invalida. Encerrando.\n");
return 1;
}
soma += precos[i];
if (precos[i] < 280.00) {
contadorMenores++;
}
}
printf("\nValores inseridos no vetor:\n");
for (i = 0; i < 10; i++) {
printf("Produto %d: R$ %.2f\n", i + 1, precos[i]);
}
printf("\nQuantidade de precos menores que R$ 280.00: %d\n", contadorMenores);
printf("Soma total dos precos: R$ %.2f\n", soma);
return 0;
}