Escreva um algoritmo que calcule a soma dos números de 1 a 15.

Passo 1

O enunciado pede que eu escreva um algoritmo que calcule a soma dos números de 1 a 15.\n
Informações dadas:
  • Queremos somar todos os inteiros consecutivos começando em 1 e terminando em 15.
  • Ou seja, precisamos obter o valor de \sum_{k=1}^{15} k.
  • O objetivo é apresentar um algoritmo — procedimento claro que, ao ser executado, produz essa soma.

Passo 2

Opções naturais para resolver isso (sem decidir ainda qual usar):
  1. Somar um a um usando um laço (loop) acumulador — método direto e muito usado em programação.
  2. Usar a fórmula fechada para a soma dos primeiros n inteiros \sum_{k=1}^{n} k, que dá o resultado em tempo constante.
    Vou explicar os dois, porque ambos são úteis em prova e em programação; depois mostro qual é mais simples para este caso.

Passo 3

Método 1 — algoritmo por laço (ideia e construção):
  • Ideia: percorremos os números de 1 até 15 e vamos acumulando em uma variável chamada soma.
  • Variáveis:
    • n = número final da sequência (aqui n = 15).
    • soma = acumulador, começa em 0.
    • i = variável de controle do laço que vai de 1 até n.
  • Pseudocódigo (linha a linha, explicando cada passo):
    1. Atribuir n := 15. Isso define até onde somamos. ( n=15.)
    2. Atribuir soma := 0. Começamos sem nada somado. ( \text{soma}=0.)
    3. Para i variando de 1 até n faça:
      • soma := soma + i. Aqui pegamos o valor atual de soma e somamos i.
    4. No fim do laço, soma contém a soma desejada.
  • Observação didática: a cada iteração o acumulador cresce; após a primeira iteração soma = 0 + 1 = 1, depois soma = 1 + 2 = 3, e assim por diante.

Passo 4

Simulação rápida do laço para entender (mostrar algumas iterações):
  • Inicial: \text{soma}=0.
  • Iteração i=1: \text{soma} \leftarrow 0 + 1 = 1.
  • Iteração i=2: \text{soma} \leftarrow 1 + 2 = 3.
  • Iteração i=3: \text{soma} \leftarrow 3 + 3 = 6.
  • Iteração i=15: soma final será o valor acumulado após somar o 15-ésimo termo.
    Fazer o laço manualmente até 15 dá trabalho à mão, mas o computador faz isso em 15 passos. Ainda vou calcular o resultado exato no Passo 6.

Passo 5

Método 2 — usar a fórmula fechada (ideia e demonstração curta):
  • Existe uma fórmula muito conhecida para somar os primeiros n inteiros:
\sum_{k=1}^{n} k = \frac{n(n+1)}{2}.
  • Demonstração por pareamento (argumento clássico de Gauss):
    1. Escreva a soma na ordem crescente e na decrescente e some termo a termo:
    S = 1 + 2 + 3 + \dots + (n-1) + n,
S = n + (n-1) + (n-2) + \dots + 2 + 1.
  1. Somando as duas linhas termo a termo, cada coluna soma n+1, e há n colunas:
2S = n(n+1).
  1. Dividindo por 2 obtemos a fórmula:
S = \frac{n(n+1)}{2}.
  • Explicação das variáveis na fórmula: n é o número de termos (aqui n=15), e S é a soma buscada.

Passo 6

Aplicando a fórmula para n=15:
S = \frac{n(n+1)}{2} = \frac{15\cdot 16}{2}.
Calcule passo a passo:
  • Primeiro calcule 15\cdot 16. Podemos fazer 15\cdot 16 = 15\cdot (10+6) = 150 + 90 = 240.
  • Depois divida por 2: \dfrac{240}{2} = 120.
    Logo a soma dos números de 1 a 15 é \,120.

Passo 7

Pseudocódigos finais (práticos, prontos para usar). Vou apresentar os dois algoritmos: o por laço (mais geral) e o por fórmula (mais eficiente para inteiros consecutivos).
Algoritmo A — laço (acumulador):
  1. n := 15
  2. soma := 0
  3. for i := 1 to n do
    soma := soma + i
  4. output soma
Algoritmo B — fórmula (tempo constante):
  1. n := 15
  2. soma := n*(n+1)/2
  3. output soma

Passo 8

Comparação rápida e motivação de escolha:
  • Complexidade:
    • Algoritmo A: faz n adições (aqui 15 adições). Complexidade O(n).
    • Algoritmo B: faz um número constante de operações (multiplicação e divisão). Complexidade O(1).
  • Para provas e entrevistas: explicar ambos é bom. Para executar na prática, se você conhece a fórmula, use-a — é mais rápida e elegante.
  • Se precisar somar uma sequência que não começa em 1 (por exemplo de a a b), dá para adaptar a fórmula: \sum_{k=a}^{b} k = \sum_{k=1}^{b} k - \sum_{k=1}^{a-1} k.

Resposta

Algoritmo (laço): n := 15; soma := 0; for i := 1 to n do soma := soma + i; output soma
Algoritmo (fórmula): n := 15; soma := n*(n+1)/2; output soma
Soma final: 120

Exercícios relacionados