Vejo que muitas pessoas responderam à pergunta sobre estouro, mas eu queria resolver o problema original. Ele disse que o problema era encontrar um b = c de modo que todos os dígitos sejam usados sem repetição. Ok, não foi isso que ele pediu neste post, mas ainda acho que era necessário estudar o limite superior do problema e concluir que ele nunca precisaria calcular ou detectar um estouro (nota: não sou proficiente em matemática, eu fiz isso passo a passo, mas o resultado final foi tão simples que isso pode ter uma fórmula simples).
O ponto principal é que o limite superior exigido pelo problema para a, b ou c é 98.765.432. De qualquer forma, começando dividindo o problema nas partes trivial e não trivial:
- x 0 == 1 (todas as permutações de 9, 8, 7, 6, 5, 4, 3, 2 são soluções)
- x 1 == x (nenhuma solução é possível)
- 0 b == 0 (nenhuma solução é possível)
- 1 b == 1 (nenhuma solução é possível)
- a b , a> 1, b> 1 (não trivial)
Agora, apenas precisamos mostrar que nenhuma outra solução é possível e apenas as permutações são válidas (e o código para imprimi-las é trivial). Voltamos ao limite superior. Na verdade, o limite superior é c ≤ 98.765.432. É o limite superior porque é o maior número com 8 dígitos (total de 10 dígitos menos 1 para cada aeb). Esse limite superior é apenas para c porque os limites de aeb devem ser muito mais baixos devido ao crescimento exponencial, como podemos calcular, variando de b de 2 ao limite superior:
9938.08^2 == 98765432
462.241^3 == 98765432
99.6899^4 == 98765432
39.7119^5 == 98765432
21.4998^6 == 98765432
13.8703^7 == 98765432
9.98448^8 == 98765432
7.73196^9 == 98765432
6.30174^10 == 98765432
5.33068^11 == 98765432
4.63679^12 == 98765432
4.12069^13 == 98765432
3.72429^14 == 98765432
3.41172^15 == 98765432
3.15982^16 == 98765432
2.95305^17 == 98765432
2.78064^18 == 98765432
2.63493^19 == 98765432
2.51033^20 == 98765432
2.40268^21 == 98765432
2.30883^22 == 98765432
2.22634^23 == 98765432
2.15332^24 == 98765432
2.08826^25 == 98765432
2.02995^26 == 98765432
1.97741^27 == 98765432
Observe, por exemplo, a última linha: diz que 1,97 ^ 27 ~ 98M. Assim, por exemplo, 1 ^ 27 == 1 e 2 ^ 27 == 134.217.728 e essa não é uma solução, pois possui 9 dígitos (2> 1,97; portanto, é realmente maior do que deveria ser testado). Como pode ser visto, as combinações disponíveis para testar aeb são realmente pequenas. Para b == 14, precisamos tentar 2 e 3. Para b == 3, começamos em 2 e paramos em 462. Todos os resultados são concedidos como inferiores a ~ 98M.
Agora basta testar todas as combinações acima e procurar as que não repetem nenhum dígito:
['0', '2', '4', '5', '6', '7', '8'] 84^2 = 7056
['1', '2', '3', '4', '5', '8', '9'] 59^2 = 3481
['0', '1', '2', '3', '4', '5', '8', '9'] 59^2 = 3481 (+leading zero)
['1', '2', '3', '5', '8'] 8^3 = 512
['0', '1', '2', '3', '5', '8'] 8^3 = 512 (+leading zero)
['1', '2', '4', '6'] 4^2 = 16
['0', '1', '2', '4', '6'] 4^2 = 16 (+leading zero)
['1', '2', '4', '6'] 2^4 = 16
['0', '1', '2', '4', '6'] 2^4 = 16 (+leading zero)
['1', '2', '8', '9'] 9^2 = 81
['0', '1', '2', '8', '9'] 9^2 = 81 (+leading zero)
['1', '3', '4', '8'] 3^4 = 81
['0', '1', '3', '4', '8'] 3^4 = 81 (+leading zero)
['2', '3', '6', '7', '9'] 3^6 = 729
['0', '2', '3', '6', '7', '9'] 3^6 = 729 (+leading zero)
['2', '3', '8'] 2^3 = 8
['0', '2', '3', '8'] 2^3 = 8 (+leading zero)
['2', '3', '9'] 3^2 = 9
['0', '2', '3', '9'] 3^2 = 9 (+leading zero)
['2', '4', '6', '8'] 8^2 = 64
['0', '2', '4', '6', '8'] 8^2 = 64 (+leading zero)
['2', '4', '7', '9'] 7^2 = 49
['0', '2', '4', '7', '9'] 7^2 = 49 (+leading zero)
Nenhum deles corresponde ao problema (que também pode ser visto pela ausência de '0', '1', ..., '9').
O código de exemplo que resolve ele segue. Observe também que está escrito em Python, não porque ele precisa de números inteiros de precisão arbitrários (o código não calcula nada maior que 98 milhões), mas porque descobrimos que a quantidade de testes é tão pequena que devemos usar uma linguagem de alto nível para faça uso de seus contêineres e bibliotecas integrados (observe também: o código possui 28 linhas).
import math
m = 98765432
l = []
for i in xrange(2, 98765432):
inv = 1.0/i
r = m**inv
if (r < 2.0): break
top = int(math.floor(r))
assert(top <= m)
for j in xrange(2, top+1):
s = str(i) + str(j) + str(j**i)
l.append((sorted(s), i, j, j**i))
assert(j**i <= m)
l.sort()
for s, i, j, ji in l:
assert(ji <= m)
ss = sorted(set(s))
if s == ss:
print '%s %d^%d = %d' % (s, i, j, ji)
# Try with non significant zero somewhere
s = ['0'] + s
ss = sorted(set(s))
if s == ss:
print '%s %d^%d = %d (+leading zero)' % (s, i, j, ji)