Desenvolva um programa que calcula a média aritmética de N números. Seu programa deverá perguntar ao usuário a quantidade ( N ) de números que serão digitados, em seguida o usuário deverá digitar os N números. Finalmente o programa imprimirá na tela o valor da média aritmética (com duas casas decimais). Obs: Não utilize array/vetor para resolver esse exercício.
\text { Média Aritmética: } \quad \bar{X}=\frac{1}{N} \sum_{i=1}^{N} x_{i}éé

Passo 1

O enunciado pede que você desenvolva um programa que:
  • Pergunte ao usuário a quantidade de números N que serão digitados.
  • Em seguida leia os N números (um a um).
  • Calcule a média aritmética desses N números e imprima o resultado com duas casas decimais.
  • Restrição importante: não é permitido usar array/vetor (ou seja, não armazenar todos os valores; deve-se processar conforme lê).
Informações relevantes dadas:
  • A fórmula da média aritmética é
\bar{X}=\frac{1}{N}\sum_{i=1}^{N} x_{i}
onde x_{i} são os números fornecidos e N é a quantidade total.

Passo 2

Entendimento do que precisamos fazer passo a passo (sem resolver ainda):
  • Precisamos de uma variável que conte quantos números foram lidos (essa é N, pedida ao usuário).
  • Precisamos de uma variável acumuladora para guardar a soma parcial dos números lidos (vou chamar de “soma”).
  • Para cada número lido x_{i} somamos em “soma”: isto é, após ler x_{i} fazemos \text{soma} \leftarrow \text{soma} + x_{i}.
  • Ao final dividimos a soma por N para obter a média: \bar{X} = \dfrac{\text{soma}}{N}.
  • Imprimir a média com exatamente duas casas decimais.

Passo 3

Explicando os conceitos usados (aula rápida e prática):
  • O que é a média aritmética? É o valor que representa o “centro” dos dados e é calculado somando todos os valores e dividindo pelo número total de valores. Na prática, você soma tudo e divide por quantos elementos tem.
  • Por que não precisamos de vetor/array? Porque podemos ir somando os números conforme são lidos, mantendo apenas a soma acumulada e o contador N. Isso economiza memória e atende à restrição do enunciado.
  • Variáveis que usaremos:
    • N: inteiro com a quantidade de números que o usuário informará.
    • \text{soma}: número (float) que armazena a soma acumulada dos x_i.
    • \bar{X}: resultado final (média), calculado por \bar{X}=\text{soma}/N.

Passo 4

Escolha do método e da linguagem:
  • O enunciado não exige linguagem específica. Vou usar Python porque é simples, direto e fácil de escrever/ler durante uma prova prática ou exercício.
  • O método é o mais direto e clássico: ler N, fazer um laço que repete N vezes, em cada iteração ler um número e somar em \text{soma}. Ao final dividir por N.
  • Justificativa: esse método usa apenas operações básicas (leitura, soma, divisão, laço), não precisa de estruturas complexas e é eficiente.

Passo 5

Pseudocódigo (para você entender a sequência antes do código real):
  • Ler N.
  • Se N \le 0, avisar que não dá para calcular a média (ou tratar como caso especial).
  • Inicializar \text{soma} \leftarrow 0.
  • Repetir i de 1 até N:
    • Ler x_i.
    • Fazer \text{soma} \leftarrow \text{soma} + x_i.
  • Calcular \bar{X} \leftarrow \text{soma} / N.
  • Imprimir \bar{X} com duas casas decimais.

Passo 6

Detalhando a implementação em Python linha a linha (explicação didática):
  • Leitura de N: em Python usamos input() e convertendo para inteiro com int(). Se o usuário digitar um número não inteiro, dará erro; em prova normalmente assume-se entrada correta.
  • Inicialização da soma: usar uma variável float, por exemplo \text{soma} = 0.0.
  • Laço: usar for _ in range(N): — o nome da variável de laço não importa, usamos o underscore quando não precisamos do índice.
  • Conversão do número lido: usar float(input()) para aceitar números reais.
  • Atualização da soma: \text{soma} += x (em texto: soma = soma + x).
  • Cálculo da média: \bar{X} = \text{soma} / N. Atenção a divisão por zero: se N==0 devemos evitar a divisão.
  • Formatação com duas casas decimais: em Python use f-strings: f"{media:.2f}" ou função format(media, “.2f”). Isso garante duas casas mesmo quando são zeros.

Passo 7

Exemplo numérico para fixar (faça na mão seguindo o código):
  • Suponha N=3 e os números sejam x_1=2, x_2=4, x_3=6.
  • Inicialmente \text{soma}=0.
  • Após ler x_1=2: \text{soma}=0+2=2.
  • Após ler x_2=4: \text{soma}=2+4=6.
  • Após ler x_3=6: \text{soma}=6+6=12.
  • Média: \bar{X}=\dfrac{\text{soma}}{N}=\dfrac{12}{3}=4. Imprimindo com duas casas: 4,00 (no programa aparecerá como 4.00, que é equivalente numérico).

Passo 8

Casos especiais e boas práticas (para a prova):
  • Se N\le 0: a média é indefinida. Em provas, normalmente N é um inteiro positivo; você pode checar e, se N\le 0, imprimir uma mensagem de erro ou tratar como 0 entradas (mas nunca dividir por zero).
  • Precisão: usar float para a soma para permitir números reais.
  • Entrada do usuário: assumir que o usuário fornecerá exatamente N números; em ambiente real, poderia validar entrada, mas isso foge do enunciado simples.

Passo 9

Código final (pronto para executar). Este é o programa que implementa tudo que expliquei acima.

Resposta

# Programa para calcular média aritmética de N números sem usar array/vetor

N = int(input("Digite a quantidade de números (N): "))

if N <= 0:
    print("Quantidade inválida. N deve ser maior que zero.")
else:
    soma = 0.0
    for _ in range(N):
        x = float(input())
        soma += x
    media = soma / N
    print(f"{media:.2f}")

Exercícios relacionados