Objetivo: ler, somar e calcular média.
Descrição: leia \mathrm{N}=5 inteiros em um vetor. Calcule soma e média aritmética e exiba ambos.
Critérios:
  • Usar dois for: um para leitura, outro para soma.
  • Mostrar “Soma = …, Média = …”.
Extensão: permita N informado pelo usuário (máx. 100).

Passo 1

O enunciado pede que eu leia um vetor com \mathrm{N}=5 inteiros, calcule a soma e a média aritmética desses valores e mostre na tela a mensagem exatamente no formato “Soma = …, Média = …”.
Informações e restrições fornecidas:
  • Ler \mathrm{N}=5 inteiros inicialmente (extensão: permitir \mathrm{N} informado pelo usuário até no máximo 100).
  • Usar exatamente dois laços for: um para leitura dos números para o vetor e outro para calcular a soma.
  • Exibir a saída no formato: “Soma = X, Média = Y”.
  • Deve aceitar a extensão: permitir que o usuário informe \mathrm{N} com 1 \le \mathrm{N} \le 100.

Passo 2

Entendimento do que é pedido (sem resolver ainda):
  • “Ler um vetor” significa criar um espaço (vetor/array) para guardar os \mathrm{N} inteiros lidos.
  • “Calcular soma” significa somar todos os elementos do vetor, produzindo um inteiro \text{soma}.
  • “Calcular média aritmética” significa usar a fórmula
\text{média} = \frac{\text{soma}}{\mathrm{N}},é
onde \text{soma} é a soma dos elementos e \mathrm{N} é o número de elementos.
  • Atenção: se eu fizer divisão inteira (quando ambos os operandos são inteiros) posso perder a parte fracionária. Para obter a média correta com casas decimais preciso fazer uma divisão em ponto flutuante (por exemplo, converter a soma para double antes de dividir).

Passo 3

Estratégia geral (passos concretos que farei na implementação):
  1. Pedir ao usuário o valor de \mathrm{N}. Validar que 1 \le \mathrm{N} \le 100. (Se a versão fixa \mathrm{N}=5 for exigida, pulo este passo e uso \mathrm{N}=5.)
  2. Declarar um vetor de tamanho 100 (capacidade máxima), por exemplo \text{vet}[100]. Vou usar apenas os \mathrm{N} primeiros elementos.
  3. Usar o primeiro for para ler os \mathrm{N} inteiros e armazená-los em \text{vet}[0] até \text{vet}[\mathrm{N}-1].
  4. Usar o segundo for para percorrer o vetor e somar os valores em uma variável inteira \text{soma}.
  5. Calcular a média com conversão para ponto flutuante:
\text{média} = \frac{(\text{double})\\ \text{soma}}{\mathrm{N}}.é
  1. Imprimir exatamente a string: “Soma = …, Média = …” onde os “…” são os valores calculados (por exemplo, soma inteira e média com duas casas decimais).

Passo 4

Explicando arrays e índices (para você saber fazer isso na prova):
  • Um vetor (array) é uma sequência de posições: \text{vet}[0], \text{vet}[1], \dots, \text{vet}[\mathrm{N}-1]. O índice começa em 0.
  • Para ler \mathrm{N} valores usamos um for que vai de i=0 até i<\mathrm{N}. Em cada iteração lemos um inteiro e atribuímos a \text{vet}[i].
  • Exemplo curto: se \mathrm{N}=3 e o usuário digita 4, 7, -1, então teremos \text{vet}[0]=4, \text{vet}[1]=7, \text{vet}[2]=-1.

Passo 5

Explicando os dois for exigidos (por que dois e não um só):
  • O enunciado exige especificamente dois for: um só para leitura e outro só para soma. Isso serve para treinar separação de responsabilidades.
  • Primeiro for (leitura): não realiza soma, só preenche o vetor. Isso garante que a leitura e a soma sejam etapas distintas.
  • Segundo for (soma): percorre o vetor já preenchido e acumula em \text{soma}.
  • Sintaxe típica (pseudocódigo):
    for i = 0 até N-1: ler vet[i]
    for i = 0 até N-1: soma = soma + vet[i]

Passo 6

Atenção à média (explicando problema da divisão inteira):
  • Se \text{soma} e \mathrm{N} forem inteiros e eu fizer \text{soma} / \mathrm{N}, em muitas linguagens (C, Java, etc.) o resultado será truncado para inteiro. Exemplo: se \text{soma}=7 e \mathrm{N}=2, a divisão inteira dá 3 (perdendo o 0{,}5).
  • Solução: converter pelo menos um dos operandos para ponto flutuante (double/float). Em C fazemos:
\text{média} = \frac{(\text{double})\\ \text{soma}}{\mathrm{N}}.é
  • Assim a divisão é feita em ponto flutuante e obtemos a média correta, por exemplo 3{,}5.

Passo 7

Exemplo passo a passo com números (para fixar):
Suponha \mathrm{N}=5 e os valores lidos forem 2, 4, 1, 3, 5.
  • Leitura (primeiro for) vai preencher o vetor: \text{vet} = [2,4,1,3,5].
  • Soma (segundo for): começa com \text{soma}=0, acumula: 0+2=2, 2+4=6, 6+1=7, 7+3=10, 10+5=15. Então \text{soma}=15.
  • Média:
\text{média} = \frac{(\text{double})\\\ 15}{5} = 3{,}0.é
  • Saída: “Soma = 15, Média = 3.00” (ou com outra formatação das casas decimais).

Passo 8

Código completo em C (atende a todas as restrições: dois for, permite \mathrm{N} informado até 100, imprime no formato pedido). Vou comentar linha a linha para você entender e conseguir fazer na prova.
#include <stdio.h>

int main(void) {
    int N;
    int vet[100];      /* vetor com capacidade para 100 inteiros */
    int i;
    int soma = 0;
    double media;

    /* pedir N ao usuário e validar (extensão) */
    printf("Digite N (1 a 100): ");
    if (scanf("%d", &N) != 1 || N < 1 || N > 100) {
        printf("Valor de N invalido\n");
        return 1;
    }

    /* PRIMEIRO for: leitura dos N inteiros no vetor */
    for (i = 0; i < N; i++) {
        printf("Elemento %d: ", i + 1);
        scanf("%d", &vet[i]);
    }

    /* SEGUNDO for: soma dos elementos do vetor */
    for (i = 0; i < N; i++) {
        soma += vet[i];
    }

    /* cálculo da média em ponto flutuante para evitar divisão inteira */
    media = (double) soma / N;

    /* saída no formato exigido */
    printf("Soma = %d, Média = %.2f\n", soma, media);

    return 0;
}
Comentários rápidos sobre o código:
  • A linha int vet[100]; reserva espaço para até 100 inteiros. Usamos somente os primeiros \mathrm{N}.
  • O primeiro for apenas faz leitura e armazena em vet[i].
  • O segundo for apenas soma os elementos e atualiza soma.
  • media = (double) soma / N; garante que a divisão resulte em número com casas decimais.
  • printf("Soma = %d, Média = %.2f\n", soma, media); imprime a mensagem no formato pedido, com a média com duas casas decimais. Se quiser mais ou menos casas, mude %.2f.

Passo 9

Verificação e casos de teste (como você testa na prova mentalmente):
  • Caso simples: se \mathrm{N}=5 e entrada 1 2 3 4 5 então soma =15, média =3{,}00. Saída: “Soma = 15, Média = 3.00”.
  • Caso com média não inteira: \mathrm{N}=2 e entrada 3 4 então soma =7, média =3{,}50. Sem o cast para double daria 3 (errado).
  • Caso inválido: se o usuário digitar \mathrm{N}=150, o programa mostra “Valor de N invalido” (proteger para não estourar o array).

Passo 10

Dicas para prova (motivação e pequenos macetes):
  • Sempre pense se a divisão deve ser inteira ou ponto flutuante. Quando for média, geralmente precisa ser float/double.
  • Lembre-se do índice do vetor ir de 0 até \mathrm{N}-1.
  • Se o enunciado pedir dois for, cumpra isso explicitamente — às vezes as questões cobram a forma, não só o resultado.
  • Se estiver sem tempo, implemente primeiro a versão fixa com \mathrm{N}=5, depois faça a extensão para ler \mathrm{N} e validar.

Resposta

#include <stdio.h>
int main(void) {
int N;
int vet[100];
int i;
int soma = 0;
double media;
printf("Digite N (1 a 100): ");
if (scanf("%d", &N) != 1 || N < 1 || N > 100) {
    printf("Valor de N invalido\n");
    return 1;
}

for (i = 0; i < N; i++) {
    printf("Elemento %d: ", i + 1);
    scanf("%d", &vet[i]);
}

for (i = 0; i < N; i++) {
    soma += vet[i];
}

media = (double) soma / N;

printf("Soma = %d, Média = %.2f\n", soma, media);

return 0;
}

Exercícios relacionados