Escreva um algoritmo que leia 10 números do usuário e calcule a soma desses números.
Passo 1
O que o problema pede e o que temos de dado:
- Pede-se criar um algoritmo que leia exatamente
números fornecidos pelo usuário e calcule a soma desses números. - Informações relevantes que o enunciado dá:
- Quantidade de números a ler:
. - Cada entrada é um número (pode ser inteiro ou real); vou chamar cada entrada de
. - O objetivo final é produzir a soma de todas as entradas; vou chamar o acumulador da soma de
.
- Quantidade de números a ler:
- Resultado esperado: exibir o valor de
, que é a soma dos números lidos.
Passo 2
Ideia principal e por que ela funciona (explicação didática do raciocínio):
- Para somar uma sequência de números lidos um por um, o padrão mais simples e robusto é usar um acumulador. Um acumulador é uma variável que guarda, passo a passo, o total parcial da soma.
- Inicializamos o acumulador
com . Por que ? Porque é o elemento neutro da adição: somar a algo não altera o valor desse algo. - Em seguida repetimos a operação de ler um número
e atualizar fazendo . Repetimos exatamente vezes (uma vez para cada número). - No final das
repetições, conterá a soma de todos os números lidos.
Passo 3
Conceito do laço (loop) e como aplicamos aqui — explicação simples:
- Um laço do tipo “para” (for) permite repetir um bloco de ações um número conhecido de vezes.
- Vamos usar um contador
que vai de até . Em cada iteração: - pedimos ao usuário um número
, - atualizamos
com .
- pedimos ao usuário um número
- Quando
chega a e a iteração correspondente termina, o laço acaba e temos o resultado em .
Passo 4
Detalhando cada variável e comando que usaremos (aula curta sobre cada peça do algoritmo):
-
: acumulador da soma. Inicialmente . -
: contador do laço. Vai percorrer os valores . -
: variável que guarda temporariamente o número lido do usuário em cada iteração. - Comandos que usaremos:
- Inicialização: atribuir
a . - Laço “para”: repetir leitura e atualização
vezes. - Leitura: solicitar ao usuário que digite um número e armazená-lo em
. - Atualização do acumulador:
. - Saída: exibir o valor final de
.
- Inicialização: atribuir
- Observação sobre tipos: se quiser somar números com casas decimais, trate
e como números reais (pontos flutuantes). Em prova, normalmente não é preciso especificar mais se o enunciado não fala em tipo.
Passo 5
Algoritmo em pseudocódigo explicado linha a linha:
- Linha 1: inicializar
com . Isso prepara o acumulador. - Linha 2: iniciar o laço para
de até . O laço garante que façamos exatamente leituras. - Linha 3 (dentro do laço): ler o número e armazenar em
. - Linha 4 (dentro do laço): atualizar
com . - Linha 5: quando o laço terminar, escrever/mostrar
. - Assim cada linha tem uma função clara: preparar, repetir, ler, acumular e mostrar.
Passo 6
Exemplo prático passo a passo (para fixar):
- Suponha que o usuário digita, em ordem, os números
. - Inicialmente
. - Iteração
: lê → . - Iteração
: lê → . - Iteração
: lê → . - …
- Iteração
: lê → . - Resultado final mostrado:
. - Esse exemplo mostra claramente como o acumulador cresce a cada leitura.
Passo 7
Observações finais úteis para prova e para implementação:
- Em provas, escreva claramente a inicialização do acumulador (
) e o laço com o número exato de repetições ( até ). - Se for implementar em uma linguagem de programação real, preste atenção ao tipo numérico (inteiro vs real) e ao formato de leitura (função que lê do teclado).
- Não esqueça de exibir o resultado ao final; muitas vezes em provas a falta dessa linha faz perder pontos.
- Complexidade: o algoritmo faz
leituras e somas — tempo linear na quantidade de números (aqui fixo em ), memória constante (somamos usando poucas variáveis).
Resposta
Início\n
\npara
até
faça\n leia
\n
\nfim-para\nescreva