(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):
  1. Começa (Start).
  2. Inicializa i = ...0 ..., soma = ...0{,}0 ..., contadorMenores = ...0 ....
  3. 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 ...).
  4. Depois do laço, mostrar todos os elementos do vetor preços (do índice ...0 ... ao ...9 ...).
  5. Mostrar o valor de contadorMenores.
  6. Mostrar o valor de soma.
  7. 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.
      • 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:
  • 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
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;
}

Exercícios relacionados