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
. Quando o usuário digitar
, 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
final como termo a somar — a menos que queira contar o
, o que não altera a soma).\n
Informações relevantes dadas:
Informações relevantes dadas:
- O laço termina quando o usuário digita
. - 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
- Mantemos uma variável acumuladora chamada, por exemplo,
, que guarda a soma parcial dos números digitados.\n - Inicializamos
com , pois antes de qualquer entrada a soma é zero.\n - Repetidamente pedimos ao usuário um número inteiro
.\n - Se
for igual a ( ), paramos o laço e mostramos .\n - Se
for diferente de , adicionamos a (ou seja, fazemos ) 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.
Passo 3
Escolhendo variáveis e inicialização (detalhe didático):\n
-
será a variável acumuladora que guarda a soma atual. Inicializamos com .\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" 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:
Existem duas formas comuns de implementar esse tipo de repetição:
- Repetir enquanto a condição "último número lido diferente de
" for verdadeira ( com teste antes da iteração), ou - Repetir indefinidamente e interromper quando encontrar o terminador (
+ ).\n
Vou usar a segunda forma porque é simples de escrever e de entender na prova/prática: repetimos pedindo números até encontrar; quando aparece, usamos uma instrução que interrompe o laço imediatamente. A cada número diferente de atualizamos .
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. Aqui scorresponde à variávelque discutimos.\n while True:: inicia um laço que vai rodar indefinidamente até encontrar umbreak— isto permite testar a condição de parada dentro do laço após a leitura.\nn = int(input("...")):input(...)lê uma linha digitada pelo usuário como texto eint(...)converte esse texto para um número inteiro; atribuimos esse inteiro à variáveln(a nossa). É importante converter para inteiro porque o inputretorna uma string por padrão.\nif n == 0:: verifica se o usuário digitou. A comparação ==testa igualdade.\nbreak: senfor, interrompe o laço imediatamente; o programa segue para a próxima linha após o laço.\n s = s + n: sennão foi, acumulamos seu valor em s. Essa é a atualização da soma.\nprint("Soma:", s): após sair do laço, imprimimos o valor final desque é a soma de todos os números digitados (exceto oque causou a parada).\n
Dica: na prova, se pedir pseudocódigo, escreva essas etapas em linguagem natural ou algo como:
Passo 7
Exemplo prático (mostra como funciona com números concretos):\n
Suponha que o usuário digite, em sequência: ,
,
,
.\n
Suponha que o usuário digite, em sequência:
- Inicialmente
.\n - Lê
(não é ), faz .\n - Lê
(não é ), faz .\n - Lê
(não é ), faz .\n - Lê
, detecta o terminador e para o laço; imprime .\n
Resultado final mostrado ao usuário:Soma: 7.\n
Viu? Simples: oatua só como sinal para parar, não muda a soma (porque somar 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/excepte 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
.\n - Leia números numa repetição.\n
- Pare quando o número lido for
.\n - A cada leitura diferente de
, 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)
while True:
n = int(input("Digite um número inteiro (0 para terminar): "))
if n == 0:
break
s = s + n
print(“Soma:”, s)