1. O número 135 satisfaz a propriedade 135=1^{\wedge} 1+3^{\wedge} 2+5^{\wedge} 3. As potências (em vermelho) na soma correspondem à posição do respectivo algarismo no número 135 (ex.: o 5 é o terceiro algarismo no número 135). Encontre todos os números menores do que 1000 que satisfazem a mesma propriedade, usando print() para mostrar cada número. A definição de sua rotina deve ser:
    def numeros():
  • Implemente uma solução usando for
  • Implemente uma solução usando while

Passo 1

O enunciado pede para encontrar todos os números menores do que 1000 que satisfazem a propriedade: o número é igual à soma de cada algarismo elevado à potência da sua posição no número (a posição conta a partir de 1 no algarismo mais à esquerda). Foi dado o exemplo 135 porque
135 = 1^{1} + 3^{2} + 5^{3}.
O exercício exige que você implemente uma rotina chamada def numeros(): e que dentro dela haja:
  • uma solução usando for que imprime (com print()) cada número encontrado,
  • uma solução usando while que também imprime (com print()) cada número encontrado.
    Não há outras restrições explícitas (por exemplo, se inclui o 0 — neste contexto vamos considerar os inteiros não-negativos menores que 1000, mas veremos que os números óbvios aparecem).

Passo 2

Entendendo bem a propriedade e como computá-la passo a passo:
  • Seja um número n com m algarismos. Podemos escrever seus algarismos, da esquerda para a direita, como \,d_1,d_2,\dots,d_m.
  • A condição que queremos testar é
n \overset{?}{=} \sum_{k=1}^{m} d_k^{\,k}.
Aqui d_k é o k-ésimo algarismo (esquerda para direita) e k é a posição (começando em 1).
  • Duas formas práticas de obter os algarismos e suas posições:
    1. Converter o número para string e iterar sobre os caracteres: fácil e direto, permitindo usar o índice (posição) naturalmente.
    2. Usar operações aritméticas (divisão inteira e resto) para extrair dígitos — mais “matemática”, porém precisa tomar cuidado para obter a ordem correta (esquerda para direita) ou inverter a ordem quando extraído de direita para esquerda.
Vou usar a forma por string porque é mais limpa e evita erros de ordem das posições; depois mostro a versão com while fazendo a mesma ideia também usando string (poderíamos usar aritmética, mas string é suficiente e segura na prova).

Passo 3

Vamos provar a ideia com o exemplo 135 para deixar claro como computar a soma:
  • Converter 135 em string: "135". Os caracteres são '1', '3', '5'.
  • Converter cada caractere para inteiro: d_1=1, d_2=3, d_3=5.
  • Calcular 1^{1} + 3^{2} + 5^{3} = 1 + 9 + 125 = 135.
    Isto mostra que o procedimento de iterar sobre os dígitos em ordem e elevar ao índice (posição) dá o resultado desejado.

Passo 4

Implementação usando for (explicação linha a linha):
  • Percorremos todos os inteiros n de 0 até 999 (ou de 1 a 999 se quisermos ignorar o 0; incluiremos 0 sem prejuízo).
  • Para cada n transformamos em string: s = str(n).
  • Criamos uma variável soma = 0.
  • Iteramos sobre os índices e caracteres da string com for i, ch in enumerate(s, start=1):
    • i é a posição k (começando em 1),
    • ch é o caractere do dígito que transformamos em inteiro com int(ch) para obter d_k.
  • Atualizamos soma += int(ch) ** i.
  • Após o laço, testamos if soma == n: e então print(n).
Exemplo de código (versão com for):
def numeros():
    # solução com for
    for n in range(1000):           # n vai de 0 a 999
        s = str(n)
        soma = 0
        for i, ch in enumerate(s, start=1):
            soma += int(ch) ** i
        if soma == n:
            print(n)
    # a seguir vem a versão com while...
Explicação adicional: usamos enumerate(..., start=1) para obter posições começando em 1 conforme exigido pela definição do problema.

Passo 5

Por que todos os algarismos de um só dígito funcionam? Seja d um dígito entre 0 e 9. Para m=1 (número com um algarismo), a soma pedida é d^{1} = d. Assim qualquer número de um dígito satisfaz a propriedade trivially. É por isso que 1,2,\dots,9 aparecem entre as soluções (e 0 também, caso seja considerado).

Passo 6

Implementação usando while (explicação linha a linha):
  • Vamos fazer a mesma lógica, mas usando while para percorrer n.
  • Inicializamos n = 0.
  • Enquanto n < 1000, fazemos:
    • s = str(n) e calculamos soma da mesma forma.
    • Se soma == n, print(n).
    • Incrementamos n += 1.
  • Isso é equivalente ao for acima, só que usando while.
Exemplo de código (completando a definição numeros()):
def numeros():
    # solução com for
    for n in range(1000):
        s = str(n)
        soma = 0
        for i, ch in enumerate(s, start=1):
            soma += int(ch) ** i
        if soma == n:
            print(n)
    # solução com while
    n = 0
    while n < 1000:
        s = str(n)
        soma = 0
        i = 1
        for ch in s:
            soma += int(ch) ** i
            i += 1
        if soma == n:
            print(n)
        n += 1
Observação didática: na versão while acima eu optei por iterar os caracteres com um for interno apenas para demonstrar como manter a posição i manualmente; poderíamos também usar enumerate dentro do while. O importante é que um dos laços externos seja while.

Passo 7

Complexidade e observações práticas:
  • Estamos testando 1000 números; para cada número fazemos um pequeno laço sobre seus 1 a 3 dígitos. O custo é muito baixo e executável instantaneamente.
  • Em prova, essa abordagem por conversão para string e iteração por índices é segura, legível e simples de implementar sem cálculo pesado.
  • Sempre verifique a indexação (começar em 1) — erro comum é começar em 0 e obter potências erradas.

Passo 8

Executando mentalmente (ou com o código), os números menores que 1000 que satisfazem a propriedade são todos os números de um dígito e alguns números de múltiplos dígitos. O conjunto completo (ordenado) é:
1,2,3,4,5,6,7,8,9,89,135,175,518,598.

Resposta

1
2
3
4
5
6
7
8
9
89
135
175
518
598

Exercícios relacionados