- Implemente uma função que calcule e retorne a somatória de
até
de forma iterativa, com uso do while:
Lembre-se de usar variáveis contadoras (i) e acumuladoras.
Passo 1
O enunciado pede que eu implemente uma função que calcule e retorne a somatória de
até
de forma iterativa, usando um laço do tipo
. Ou seja, a função deve computar
Informações fornecidas e condições assumidas:
- A entrada é um número inteiro
. - Vou assumir que
é um inteiro não-negativo ( ), porque somatória até valores negativos não faz sentido neste contexto (se necessário, poderia tratar esse caso separadamente). - A implementação pedida é iterativa, com uso de variáveis contadoras (por exemplo,
) e acumuladoras (por exemplo, ou ), e deve usar .
Passo 2
O que significa a notação
?
- Esse símbolo soma todos os valores de
começando em e indo até . - Ou seja, explicitamente é a soma
. - Na notação,
é o índice (variável que percorre os termos) e é o limite superior da soma.
Exemplo concreto para entender: se
, então
Passo 3
Ideia da solução iterativa (intuição):
- Vou manter uma variável acumuladora, que vou chamar de
(representa o valor parcial da soma). - Vou manter uma variável contadora, que vou chamar de
, que começa em e vai até . - Enquanto
for menor ou igual a (condição do ), eu adiciono o valor de à e incremento em . - Quando o laço terminar,
conterá .
Escrevendo em linguagem “quase natural”:
- Inicialize
. - Inicialize
. - Enquanto
: -
. -
.
-
- Retorne
.
Passo 4
Por que esse laço funciona? (invariante de laço — explicação simples)
- Defino a invariante: no começo de cada iteração (antes de executar o corpo),
contém a soma de todos os inteiros de até , isto é, - Inicialização: antes da primeira iteração temos
e . A soma vazia é , então a invariante vale. - Manutenção: suponha que antes de uma iteração a invariante valha. No corpo do laço fazemos
e depois . Assim, depois dessas duas operações temos e a nova é a antiga , então a invariante continua válida (agora com o novo valor de ). - Término: o laço pára quando
. Pela invariante, nesse ponto que é justamente o que queremos devolver.
Passo 5
Traço de execução (exemplo numérico) para
— isso te ajuda a sentir o laço funcionando:
- Inicialmente:
. - Iteração 1: adiciona
→ . - Iteração 2: adiciona
→ . - Iteração 3: adiciona
→ . - Iteração 4: adiciona
→ . - Iteração 5: adiciona
→ . - Iteração 6: adiciona
→ . - Agora
, o laço termina e retornamos , que é .
Passo 6
Detalhes de implementação práticos (boas práticas rápidas):
- Verificar se
é inteiro não-negativo pode evitar resultados inesperados. Em uma prova, se não pedirem tratamento de entrada, normalmente assume-se inteiro e . - Nomeie as variáveis de forma clara:
ou para acumulador; para contador. - Complexidade: esse método faz aproximadamente
iterações, então custo linear . Existe uma fórmula fechada que é , mas a questão pediu explicitamente um método iterativo com , então usamos o laço.
Passo 7
Implementação em código (linha a linha com explicação):
- Linha 1: defino a função que recebe
. - Linha 2: (opcional) checo se
é inteiro não-negativo. - Linha 3: inicializo
. - Linha 4: inicializo
. - Linhas seguintes: faço o laço
: acumulo e incremento. - Última linha: retorno
.
Resposta
def soma_ate(n):
if not isinstance(n, int) or n < 0:
raise ValueError(“n deve ser um inteiro não-negativo”)
total = 0
i = 0
while i <= n:
total += i
i += 1
return total
if not isinstance(n, int) or n < 0:
raise ValueError(“n deve ser um inteiro não-negativo”)
total = 0
i = 0
while i <= n:
total += i
i += 1
return total