Solicite ao usuário que ele digite um número inteiro. Caso esse número seja diferente de 0 (zero), continue a solicitar outro número até que o usuário digite 0 . Ao final (quando o usuário digitar 0 ), imprima na tela a soma dos valores digitados pelo usuário.

Passo 1

O enunciado pede que você solicite ao usuário que digite um número inteiro e que você continue pedindo novos números enquanto o número digitado for diferente de 0. Quando o usuário digitar 0, o programa deve parar e imprimir a soma de todos os valores digitados pelo usuário (incluindo números negativos, se houver, mas não incluindo o 0 final como termo a somar — a menos que queira contar o 0, o que não altera a soma).\n
Informações relevantes dadas:
  • O laço termina quando o usuário digita 0.
  • Os valores são números inteiros.
  • Você deve mostrar na tela a soma dos valores digitados ao final.\n

Passo 2

Ideia geral do algoritmo (explicada passo a passo, sem código ainda):\n
  1. Mantemos uma variável acumuladora chamada, por exemplo, s, que guarda a soma parcial dos números digitados.\n
  2. Inicializamos s com 0, pois antes de qualquer entrada a soma é zero.\n
  3. Repetidamente pedimos ao usuário um número inteiro n.\n
  4. Se n for igual a 0 ( n=0), paramos o laço e mostramos s.\n
  5. Se n for diferente de 0, adicionamos n a s (ou seja, fazemos s \leftarrow s + n) e voltamos a pedir outro número.\n
    Essa estrutura é chamada de laço de repetição com condição de parada e uma variável acumuladora. É a forma clássica de somar uma sequência de valores quando não sabemos quantos valores virão antes do terminador 0.

Passo 3

Escolhendo variáveis e inicialização (detalhe didático):\n
  • s será a variável acumuladora que guarda a soma atual. Inicializamos com s=0.\n
  • n será a variável onde guardamos o número lido do usuário a cada iteração.\n
    Inicialização para a prova: escreva claramente "inicializar s \leftarrow 0" antes de começar o laço. Isso evita que você some sobre lixo ou deixa a variável sem valor.

Passo 4

Estrutura de repetição (conceito e por que funciona):\n
Existem duas formas comuns de implementar esse tipo de repetição:
  • Repetir enquanto a condição "último número lido diferente de 0" for verdadeira ( while com teste antes da iteração), ou
  • Repetir indefinidamente e interromper quando encontrar o terminador ( while\\ True + break).\n
    Vou usar a segunda forma porque é simples de escrever e de entender na prova/prática: repetimos pedindo números até encontrar 0; quando 0 aparece, usamos uma instrução que interrompe o laço imediatamente. A cada número diferente de 0 atualizamos s \leftarrow s + n.

Passo 5

Código completo e direto (implementação em Python, que é uma linguagem comum e curta — serve bem para a prova prática):\n
s = 0
while True:
    n = int(input("Digite um número inteiro (0 para terminar): "))
    if n == 0:
        break
    s = s + n
print("Soma:", s)
```\n
Esse código faz exatamente o que o enunciado pede: pede números, soma enquanto são diferentes de \(0\) e imprime a soma quando o usuário digita \(0\).

Passo 6

Explicação linha a linha do código (para você entender e repetir na prova):\n
  • s = 0 : inicializa a soma parcial com 0. Aqui s corresponde à variável s que discutimos.\n
  • while True: : inicia um laço que vai rodar indefinidamente até encontrar um break — isto permite testar a condição de parada dentro do laço após a leitura.\n
  • n = int(input("...")) : input(...) lê uma linha digitada pelo usuário como texto e int(...) converte esse texto para um número inteiro; atribuimos esse inteiro à variável n (a nossa n). É importante converter para inteiro porque o input retorna uma string por padrão.\n
  • if n == 0: : verifica se o usuário digitou 0. A comparação == testa igualdade.\n
  • break : se n for 0, interrompe o laço imediatamente; o programa segue para a próxima linha após o laço.\n
  • s = s + n : se n não foi 0, acumulamos seu valor em s. Essa é a atualização da soma.\n
  • print("Soma:", s) : após sair do laço, imprimimos o valor final de s que é a soma de todos os números digitados (exceto o 0 que causou a parada).\n
    Dica: na prova, se pedir pseudocódigo, escreva essas etapas em linguagem natural ou algo como:
\text{inicializar } s \leftarrow 0
\text{enquanto True:}
\quad n \leftarrow \text{ler inteiro}
\quad \text{se } n = 0 \text{ então parar}ã
\quad s \leftarrow s + n
\text{imprimir } s

Passo 7

Exemplo prático (mostra como funciona com números concretos):\n
Suponha que o usuário digite, em sequência: 3, -1, 5, 0.\n
  • Inicialmente s=0.\n
  • n=3 (não é 0), faz s \leftarrow 0+3 = 3.\n
  • n=-1 (não é 0), faz s \leftarrow 3+(-1) = 2.\n
  • n=5 (não é 0), faz s \leftarrow 2+5 = 7.\n
  • n=0, detecta o terminador e para o laço; imprime s=7.\n
    Resultado final mostrado ao usuário: Soma: 7.\n
    Viu? Simples: o 0 atua só como sinal para parar, não muda a soma (porque somar 0 não altera).

Passo 8

Validações e variação (o que fazer se quiser ser mais robusto):\n
  • Se quiser garantir que o usuário só digite inteiros e tratar entradas inválidas, envolva a conversão em um bloco try/except e peça para digitar novamente quando acontecer erro. Exemplo rápido:\n
s = 0
while True:
    try:
        n = int(input("Digite um número inteiro (0 para terminar): "))
    except ValueError:
        print("Entrada inválida. Digite um inteiro.")
        continue
    if n == 0:
        break
    s = s + n
print("Soma:", s)
```\n
- Complexidade: o algoritmo usa memória constante (apenas algumas variáveis) e tempo proporcional ao número de entradas feitas — é ótimo para prova.\n

Passo 9

Resumo final e incentivo (curto e direto):\n
  • Inicialize a soma com 0.\n
  • Leia números numa repetição.\n
  • Pare quando o número lido for 0.\n
  • A cada leitura diferente de 0, some ao acumulador.\n
    Você consegue fazer isso na prova rapidinho; se travar, escreva o passo a passo em pseudo-linguagem como mostrei e depois traduza para a linguagem pedida. Vai dar bom — respira e faz um por vez!

Resposta

s = 0
while True:
n = int(input("Digite um número inteiro (0 para terminar): "))
if n == 0:
break
s = s + n
print(“Soma:”, s)

Exercícios relacionados