Questão 8: Crie uma função soma_multiplos_intervalo(a, b, k) que retorne a soma de todos os números no intervalo de a até b (inclusive) que são múltiplos de k .
Exemplo: soma_multiplos_intervalo(5, 20, 5) deve retornar 5+
.
Passo 1
O enunciado pede que a gente crie uma função chamada soma_multiplos_intervalo(a, b, k) que retorne a soma de todos os números no intervalo de
até
(inclusive) que são múltiplos de
.
Informações relevantes e pressupostos que vou usar (sem perguntar nada a você):
Informações relevantes e pressupostos que vou usar (sem perguntar nada a você):
- Os parâmetros
, e são inteiros. - O intervalo é fechado: inclui os extremos
e . - Vou tratar o caso
trocando os valores para garantir que sempre percorremos do menor para o maior. - O caso
é inválido (não faz sentido determinar múltiplos de zero), então vou indicar erro para isso.
Exemplo dado no enunciado: chamadadeve retornar .
Passo 2
Vamos escolher o método de resolução. Existem basicamente dois jeitos naturais:
- Método direto (mais básico): percorrer todos os inteiros de
até e somar os que satisfazem . É simples e intuitivo — bom para programar rápido e entender o que está acontecendo. - Método via progressão aritmética (mais eficiente): identificar o primeiro múltiplo de
dentro do intervalo e o último múltiplo, contar quantos termos há e usar a fórmula da soma de uma progressão aritmética. É matematicamente elegante e muito mais rápido quando o intervalo é grande.
Vou explicar ambos. Para a implementação final vou apresentar a versão eficiente (progressão), porque é curta, evita loops longos e é ótima para prova — mas antes eu ensino o método básico passo a passo (o que é mais fácil de memorizar e implementar se você só souber programação básica).
Passo 3
Conceito básico: como testar se um número
é múltiplo de
.
- Definição:
é múltiplo de se e somente se . - O operador “mod” (resto) dá o resto da divisão inteira de
por . Por exemplo, e , logo é múltiplo de .
Método simples (passo a passo):
- Inicializo uma variável soma com
. - Para cada inteiro
de até (incluindo ambos), verifico se . - Se sim, faço soma := soma +
. - No final, retorno soma.
Exemplo controlado com
: os
de
a
que satisfazem
são
. Somando:
,
,
,
. Resultado
.
Passo 4
Agora a versão rápida com progressão aritmética — aqui a matemática que você precisa saber e como aplicá-la na prova.
- Identificar o primeiro múltiplo de
dentro do intervalo . Denoto esse valor por . Fórmula:
Isso significa: pegue o menor inteiro múltiplo de
que seja maior ou igual a
.
- Identificar o último múltiplo de
dentro do intervalo . Denoto por . Fórmula:
Isto é: o maior múltiplo de
que seja menor ou igual a
.
- Contar quantos termos há na sequência
. Se , então não há múltiplos no intervalo e a soma é . Caso contrário, o número de termos é
Observe que
é inteiro por construção.
- Soma da progressão aritmética: a soma
dos termos é
Esse resultado vem da fórmula clássica da soma de progressão aritmética: soma = número de termos × (primeiro + último)/2.
Exemplo com
:
(na prática
é inteiro porque
é divisível por
).
Passo 5
Casos especiais e detalhes práticos que você precisa lembrar na prova:
-
: inválido; não existe “múltiplos de zero”. Deve-se tratar como erro. -
negativo: usar (múltiplos de ou de são os mesmos em valor absoluto). Vou usar . -
: troque e , isto é, trabalhe com o intervalo ordenado . - Se não houver múltiplos no intervalo (ou seja,
), retorne .
Passo 6
Vou dar a implementação final em Python (curta e eficiente) usando a abordagem da progressão aritmética. Essa função trata os casos especiais citados. Você pode implementar a versão por loop se preferir, mas essa é a que eu recomendo para prova por ser concisa e rápida.
Resposta
def soma_multiplos_intervalo(a, b, k):
import math
if k == 0:
raise ValueError(“k não pode ser zero”)
# normaliza k positivo e garante a <= b
k = abs(k)
if a > b:
a, b = b, a
# primeiro múltiplo >= a
m1 = math.ceil(a / k) * k
# último múltiplo <= b
mn = math.floor(b / k) * k
if m1 > mn:
return 0
n = (mn - m1) // k + 1
return n * (m1 + mn) // 2
import math
if k == 0:
raise ValueError(“k não pode ser zero”)
# normaliza k positivo e garante a <= b
k = abs(k)
if a > b:
a, b = b, a
# primeiro múltiplo >= a
m1 = math.ceil(a / k) * k
# último múltiplo <= b
mn = math.floor(b / k) * k
if m1 > mn:
return 0
n = (mn - m1) // k + 1
return n * (m1 + mn) // 2