Construa um código que lê n números e retorna a soma deles, o valor do maior e menor elemento.

Passo 1

O que o enunciado pede e o que ele fornece (pontos importantes):
  • Pedem para construir um programa que lê ... números e retorna três coisas: a soma deles, o valor do maior elemento e o valor do menor elemento.
  • Informações de entrada esperadas:
    • Um inteiro ... indicando quantos números serão lidos (chamarei isso de ...).
    • Em seguida, ... valores numéricos (podem ser inteiros ou reais), um por leitura ou separados por espaços/linhas.
  • Saídas desejadas:
    • A soma de todos os números lidos.
    • O maior número entre os lidos.
    • O menor número entre os lidos.
  • Observação sobre casos de borda: pode acontecer ... ser igual a ... (nenhum número). É bom tratar esse caso explicitamente.

Passo 2

Idéia geral do método (em palavras simples):
  • Percorrer os ... números uma vez, mantendo três variáveis:
    • uma acumuladora para a soma, vou chamar de ...;
    • uma variável para o maior valor até agora, vou chamar de ...;
    • uma variável para o menor valor até agora, vou chamar de ....
  • Cada vez que lemos um número novo ... fazemos:
    • somar ... em ...;
    • comparar ... com ... e atualizar ... se necessário;
    • comparar ... com ... e atualizar ... se necessário.
  • Esse método precisa de apenas uma passagem pelos dados e é simples de implementar na prova sem app complexo.

Passo 3

Por que inicializar usando o primeiro elemento lido é a melhor estratégia (explicação didática):
  • Se tentarmos inicializar ... com ... ou ... (valores muito grandes/pequenos), corremos risco de erro ou precisar explicar o uso de sentinelas. Em prova, ler o primeiro número e usar ele para inicializar ..., ... e ... é mais simples e seguro.
  • Procedimento:
    • Se ...\leq0: não há números a processar — tratar separadamente.
    • Senão (quando ...\geq1):
      • Ler o primeiro número ....
      • Fazer ...)=\(...)=\(...)=\(....
      • Em seguida, para cada um dos ...\!-\!1 números restantes, aplicar somar e comparar/atualizar.)

Passo 4

Passo a passo do loop e explicação das operações elementares (ou seja, o que você precisa saber para implementar):
  • Soma/Acumulação:
    • A operação de soma é apenas ... = ... + .... A cada número novo ... fazemos ... \leftarrow ... + ....
    • No final, ... contém a soma de todos os números.
  • Comparações para maior/menor:
    • Para verificar se ... é maior que o maior atual fazemos a comparação ... > .... Se verdadeira, atualizamos ... \leftarrow ....
    • Para verificar se ... é menor que o menor atual fazemos ... < .... Se verdadeira, atualizamos ... \leftarrow ....
  • Complexidade:
    • O algoritmo faz uma comparação e uma soma por elemento, logo é linear no número de elementos: tempo ... (lê-se "O de ..."), memória extra constante.

Passo 5

Pseudocódigo claro e curto (para você entender antes de olhar o código real)
  • Supondo que a entrada seja válida e ... seja inteiro:
\text{ler } n
Se ... \le 0 então
\text{tratar caso sem números (ex.: avisar ou retornar 0/None)}ú
senao
\text{ler } x_1
\text{total} \leftarrow x_1
\text{maior} \leftarrow x_1
\text{menor} \leftarrow x_1
Para i de 2 até n faça:
\text{ler } x_i
\text{total} \leftarrow \text{total} + x_i
Se x_i > \text{maior} então \text{maior} \leftarrow x_i
Se x_i < \text{menor} então \text{menor} \leftarrow x_i
No fim, imprimir \text{total}, \text{maior}, \text{menor}.

Passo 6

Exemplo numérico passo a passo (pratique na prova!):
  • Suponha ...)=5 e os números lidos na ordem são \(....
  • Leitura 1: ...)=3. Inicializa: (…)=3, (…)=3, (…)=3.
  • Leitura 2: ...)= -1. Atualiza: (…)=2 😭3 + (-1)), maior continua 3, menor passa a -1.
  • Leitura 3: ...)=7. Atualiza: (…)=9, maior passa a 7, menor fica -1.
  • Leitura 4: ...)=0. Atualiza: (…)=9, maior 7, menor -1.
  • Leitura 5: ...)=4. Atualiza: (…)=13, maior 7, menor -1.
  • Resultado final: soma ...)=13, maior \(=7, menor =-1.
  • Esse tipo de simulação rápida é ótima para verificar que seu raciocínio e código estão certos.)

Passo 7

Casos de borda e dicas práticas para a prova:
  • Se ...)=0: decida o que devolver (alguns programas devolvem soma \(=0 e maiores/menores como “não existe” ou None; em prova, declare explicitamente a convenção).
  • Se os números podem ser reais, use tipo com ponto flutuante; se forem inteiros use inteiro.
  • Sempre documente (comentário curto) no código qual é a convenção para ...)=0. - Teste com entradas pequenas à mão (como o exemplo do Passo 6) para garantir que não há erro de off-by-one.àããá

Passo 8

Pronto — vou te dar agora um código final em Python que implementa exatamente essa ideia. Ele:
  • Lê uma linha com ... (inteiro).
  • Se ...\leq0, imprime uma mensagem explicando que não há números.
  • Senão, lê ... números (um por linha) e no final imprime a soma, o maior e o menor com rótulos claros.
    Este código é fácil de entender e de adaptar para ambientes de prova ou para uma entrada diferente.

Resposta

# Leitura de n (quantidade de números)
try:
    n = int(input())
except Exception:
    print("Entrada inválida para n.")
    raise SystemExit(1)

if n <= 0:
    print("Nenhum número para processar.")
else:
    # Ler o primeiro número para inicializar soma, maior e menor
    try:
        x = float(input())
    except Exception:
        print("Entrada inválida para número.")
        raise SystemExit(1)

    total = x
    maior = x
    menor = x

    # Ler os n-1 números restantes
    for _ in range(n - 1):
        try:
            x = float(input())
        except Exception:
            print("Entrada inválida para número.")
            raise SystemExit(1)
        total += x
        if x > maior:
            maior = x
        if x < menor:
            menor = x

    # Saída: soma, maior e menor
    print("Soma =", total)
    print("Maior =", maior)
    print("Menor =", menor)

Exercícios relacionados