3-) Desenvolva um algoritmo que realize a soma dos valores digitados pelo usuário. O algoritmo deverá solicitar que o usuário digite um valor e realizar a soma do mesmo com a somatória dos valores digitados, informar o valor total da soma e solicitar que o usuário digite um novo valor. Para informar que o usuário não deseja mais digitar números ele deverá digitar o número 0 (Utilizar a estrutura REPEAT).

Passo 1

O enunciado pede um algoritmo que:
  • Solicite repetidamente que o usuário digite um valor.
  • Some esse valor à somatória acumulada dos valores já digitados.
  • Informe ao usuário o valor total da soma após cada entrada.
  • Permita que o usuário encerre o processo digitando o número 0.
  • Use explicitamente a estrutura de repetição REPEAT (ou seja, um loop que executa o corpo antes de checar a condição de parada).
Informações dadas importantes:
  • Valor que indica fim da entrada: 0.
  • É necessário mostrar a soma acumulada a cada nova entrada.
  • Deve ser usado REPEAT (loop que verifica a condição no final).

Passo 2

O que é a estrutura REPEAT e por que ela serve aqui (aula rápida e direta):
  • REPEAT é um tipo de laço que executa o bloco de instruções pelo menos uma vez e, ao final do bloco, verifica uma condição. Se a condição for falsa, o bloco repete; se for verdadeira, o laço termina.
  • Sintaxe conceitual: execute (bloco) até que (condição seja verdadeira). Em pseudocódigo fica “REPEAT … UNTIL (condição)”.
  • No nosso problema isso é conveniente porque queremos primeiro pedir um valor ao usuário e só depois checar se ele digitou 0. Ou seja, precisamos que o corpo do loop execute pelo menos uma vez — exatamente o comportamento do REPEAT.

Passo 3

Quais variáveis usar e como inicializá-las (explicando conceitos):
  • Precisamos de uma variável acumuladora para guardar a soma parcial. Vou chamar essa variável de soma.
    • Conceito de acumulador: é uma variável que guarda o total parcial; começa em um valor neutro (para soma, o neutro é 0) e, a cada novo valor, atualiza-se somando o novo número.
  • Precisamos de uma variável para receber o número digitado pelo usuário. Vou chamar essa variável de valor.
  • Inicialização:
    • Antes de entrar no loop, definimos soma \leftarrow 0.
    • Não precisamos inicializar valor com um valor específico fora do loop, porque no REPEAT lemos valor dentro do corpo antes de usá-lo.

Passo 4

Lógica passo a passo do corpo do loop (o “como” — explicações didáticas para você aplicar na prova):
  • No início do corpo do REPEAT, pedimos que o usuário digite um número e lemos esse número em valor.
    • Em prova: escreva claramente "Leia valor".
  • Atualizamos a acumuladora: fazemos soma \leftarrow soma + valor.
    • Explicação: a expressão do lado direito calcula o novo total somando o que já tinha em soma com o valor lido; então atribuímos esse total de volta a soma.
    • Observação prática: se o usuário digitar 0, essa soma acrescenta 0 à acumuladora — não altera o total — e depois o laço verificará a condição de parada.
  • Informamos ao usuário a soma atual, isto é, exibimos o valor de soma.
  • No final do bloco, colocamos a condição de parada do REPEAT: repetir até que valor = 0.
    • Como o REPEAT verifica a condição após o corpo, o processo garante que sempre se leia ao menos um valor e que, ao digitar 0, o laço termine após aquela iteração.

Passo 5

Um exemplo concreto (simulação passo a passo) para solidificar a ideia:
  • Suponha as entradas do usuário na ordem: 5, 3, -2, 0.
  • Inicialmente: soma = 0.
  • 1ª iteração: lê valor = 5. Atualiza soma \leftarrow 0 + 5 = 5. Exibe soma = 5. Como valor \neq 0, repete.
  • 2ª iteração: lê valor = 3. Atualiza soma \leftarrow 5 + 3 = 8. Exibe soma = 8. Como valor \neq 0, repete.
  • 3ª iteração: lê valor = -2. Atualiza soma \leftarrow 8 + (-2) = 6. Exibe soma = 6. Como valor \neq 0, repete.
  • 4ª iteração: lê valor = 0. Atualiza soma \leftarrow 6 + 0 = 6. Exibe soma = 6. Agora valor = 0 então a condição do UNTIL é satisfeita e o loop termina.
  • Resultado final (soma acumulada): 6.

Passo 6

Observações, dicas práticas e cuidados para a prova:
  • Incluir 0 na soma não causa erro (somar 0 não altera o total), por isso a versão simples de fazer soma \leftarrow soma + valor dentro do REPEAT é aceitável e clara.
  • Se, por algum motivo, você quiser evitar somar o 0 (por exemplo, para não executar operações desnecessárias), pode testar valor e só somar se valor \neq 0. Mas não é necessário aqui; somar 0 é inofensivo.
  • Certifique-se de inicializar soma antes do REPEAT; esquecer a inicialização é erro clássico.
  • Na prova, escreva claramente:
    • a declaração das variáveis,
    • a inicialização de soma,
    • o bloco REPEAT com leitura, atualização e exibição,
    • e o UNTIL com a condição valor = 0.
  • Dica de redação: deixe explícito o que o programa mostra ao usuário (por exemplo: "Exibe 'Soma atual = ’ e o valor de soma").

Passo 7

Pequeno incentivo final
  • Você já tem a ideia completa: um acumulador, o REPEAT que lê e soma, e a condição valor = 0 para parar. Na prova, escreva isso com calma seguindo os itens do passo anterior — vai dar certo! Agora vou te entregar o pseudocódigo pronto e limpo para copiares/entregares.

Resposta

Algoritmo SomaComRepeat\nInicio\n soma \leftarrow 0\nREPEAT\n Escreva "Digite um valor (digite 0 para terminar): "\n Leia valor\n soma \leftarrow soma + valor\n Escreva "Soma atual = ", soma\nUNTIL valor = 0\nEscreva "Soma final = ", soma\nFim

Exercícios relacionados