Questão 3: Crie uma função listar_potencias_de_cinco(n) que retorne uma lista com todas as potências de 5\left(5^{0}, 5^{1}, 5^{2}, \ldots\right) que sejam menores que n .
Exemplo: listar_potencias_de_cinco(130) deve retornar [1, 5, 25, 125].

Passo 1

O enunciado pede: criar uma função chamada listar_potencias_de_cinco(n) que retorne uma lista com todas as potências de 5 — isto é, 5^{0}, 5^{1}, 5^{2}, \ldots — que sejam menores que n. Exemplo dado: listar_potencias_de_cinco(130) deve retornar [1, 5, 25, 125]. Informações relevantes fornecidas:
  • A sequência considerada é \{5^{k}\}_{k\ge 0}.
  • Devemos incluir 5^{0}.
  • Devemos incluir apenas os valores estritamente menores que n.
  • O resultado deve ser retornado como uma lista (no estilo de listas do Python).

Passo 2

Entendendo o que são potências de 5. Uma potência de 5 com expoente inteiro não negativo k é
5^{k} = \underbrace{5\cdot 5\cdot\ldots\cdot 5}_{k\\ \text{vezes}},
com a convenção especial de que
5^{0} = 1.
As potências crescem rápido: 5^{0}=1, 5^{1}=5, 5^{2}=25, 5^{3}=125, 5^{4}=625, e assim por diante. Nosso objetivo é listar todas essas potências enquanto elas forem menores que n.

Passo 3

Escolhendo um método prático para a prova. Duas ideias principais:
  1. Usar logaritmo: calcular o maior k tal que 5^{k}<n via k<\log_{5}(n) e então gerar 5^{0},\dots,5^{\lfloor\log_{5}(n)\rfloor}. Isso funciona, mas envolve função log e conversões.
  2. Fazer iteração multiplicando por 5 enquanto o valor atual for menor que n. Começamos em 1 (que é 5^{0}), adicionamos à lista se for menor que n, depois multiplicamos por 5 para obter a próxima potência, e repetimos.
Vou usar a segunda abordagem porque é simples, robusta e fácil de implementar sem funções matemáticas extras — ideal para prova.

Passo 4

Pensando em casos de borda (coisas que podem dar errado na hora da prova):
  • Se n \le 1, então nenhuma potência de 5 é estritamente menor que n, porque 5^{0}=1 e 1 \not< n. Resultado: lista vazia.
  • Se n for um número real (float), a lógica funciona do mesmo jeito: comparamos numericamente 5^{k} < n.
  • Se n for muito grande, o laço termina rápido porque as potências crescem exponencialmente.
  • Garantimos que começamos por 5^{0}=1 e só adicionamos à lista enquanto a condição 5^{k} < n estiver satisfeita.

Passo 5

Pseudocódigo simples (linguagem natural / passo a passo):
  • Criar lista vazia resultado.
  • Inicializar pot = 1 (que é 5^{0}).
  • Enquanto pot < n:
    • adicionar pot à resultado;
    • atualizar pot = pot * 5 (passar para a próxima potência).
  • Retornar resultado.
Esse pseudocódigo corresponde exatamente à ideia de “gerar potências de 5 por multiplicação sucessiva”.

Passo 6

Implementação em Python da função pedida:
def listar_potencias_de_cinco(n):
    resultado = []
    pot = 1
    while pot < n:
        resultado.append(pot)
        pot *= 5
    return resultado

Passo 7

Explicação detalhada linha a linha (para você entender e conseguir repetir na prova):
  • def listar_potencias_de_cinco(n): — define a função com parâmetro n.
  • resultado = [] — cria uma lista vazia para guardar as potências que satisfazem a condição 5^{k} < n.
  • pot = 1 — inicializa a variável pot com 1, que representa 5^{0}.
  • while pot < n: — este laço repete enquanto a potência atual for estritamente menor que n.
  • resultado.append(pot) — adiciona a potência atual à lista de resultados.
  • pot *= 5 — atualiza pot multiplicando por 5; assim pot passa por 5^{0}, 5^{1}, 5^{2}, \dots.
  • return resultado — retorna a lista completa ao final.
É exatamente a tradução direta do raciocínio matemático para código: gerar potências sucessivas e checar a condição < n.

Passo 8

Verificando com o exemplo do enunciado: para n=130 fazemos as iterações
  • pot = 1, 1 < 130 → adiciona 1.
  • pot = 1*5 = 5, 5 < 130 → adiciona 5.
  • pot = 5*5 = 25, 25 < 130 → adiciona 25.
  • pot = 25*5 = 125, 125 < 130 → adiciona 125.
  • pot = 125*5 = 625, 625 \not< 130 → para o laço.
    Resultado obtido: [1, 5, 25, 125], exatamente como pedido.

Passo 9

Complexidade e observações finais didáticas:
  • Cada iteração multiplica por 5, então o número de iterações até ultrapassar n é aproximadamente \log_{5}(n). Logo a complexidade é O(\log n) (em base 5 — constantes de base de log não importam na notação).
  • A função é simples, eficiente e não usa operações de ponto flutuante complicadas. Em prova, essa implementação é a mais prática.
  • Testes rápidos: listar_potencias_de_cinco(1)[] (porque 5^{0}=1 não é menor que 1); listar_potencias_de_cinco(2)[1]; listar_potencias_de_cinco(5)[1] (já que 5 não é estritamente menor que 5).

Resposta

def listar_potencias_de_cinco(n):
    resultado = []
    pot = 1
    while pot < n:
        resultado.append(pot)
        pot *= 5
    return resultado

Exercícios relacionados