Escribo esta respuesta porque dijiste que estabas intentando un método de adivinar y comprobar. Los ordenadores son buenos en esto. Un algoritmo decente es tener dos números enteros $n_x$ y $n_y$ que empiezan en 1. Entonces, calcula x haciendo $2n_x^2$ y y haciendo $5n_y^5$ . Comprueba si son iguales; si lo son, has encontrado tu respuesta. Si no, cualquiera de $x$ y $y$ son más bajos, incrementan que $n$ (es decir, si $x < y$ y luego incrementar $n_x$ ). Recalcular $x$ y $y$ y repetir hasta que sean iguales.
He aquí un ejemplo de implementación en Python utilizando generadores:
class SpecialSquareGenerator:
def __init__(self, n=0):
self.n = n
def __iter__(self):
return self
def __next__(self):
self.n += 1
return self.n, 2*(self.n**2)
class SpecialFifthGenerator:
def __init__(self, n=0):
self.n = n
def __iter__(self):
return self
def __next__(self):
self.n += 1
return self.n, 5*(self.n**5)
def special_square():
n = 0;
ss = SpecialSquareGenerator()
sf = SpecialFifthGenerator()
nx, x = next(ss)
ny, y = next(sf)
print("{0}: {1}\t{2}: {3}".format(nx, x, ny, y))
while True:
if (x == y): return x
if x < y:
nx, x = next(ss)
else:
ny, y = next(sf)
print("{0}: {1}\t{2}: {3}".format(nx, x, ny, y))
if __name__ == "__main__":
print(special_square())
Ejecutarlo devuelve la respuesta correcta:
gns-mac1:sandbox gns$ python3 special_square.py
1: 2 1: 5
2: 8 1: 5
2: 8 2: 160
3: 18 2: 160
...(output omitted)
494: 488072 10: 500000
495: 490050 10: 500000
496: 492032 10: 500000
497: 494018 10: 500000
498: 496008 10: 500000
499: 498002 10: 500000
500: 500000 10: 500000
500000
Por supuesto, el enfoque matemático es mejor para entender el problema. Pero si necesitas adivinar y comprobar, entonces los ordenadores son la herramienta para ello.
P.D.
Hay otra manera de buscar exhaustivamente la solución. Puedes tomar números secuenciales y tratar de dividirlos por 2 (o 5) y luego tomar la raíz cuadrada (o quinta raíz) y luego comprobar si el resultado es un número entero para ambas operaciones. Este enfoque tiene dos desventajas:
- Tienes que decidir si un número en coma flotante se supone que representa un número entero. Esto es difícil de hacer para las computadoras y las implementaciones de lenguaje porque las computadoras sólo tienen un conjunto fijo de dígitos para representar los números de punto flotante.
- El espacio de búsqueda es mayor (por orden de $n^2$ ). Así que eso significa que debería esperar más tiempo para llegar a la misma respuesta, dado el mismo hardware.
P.S.S.
Hay formas más rápidas de implementar tanto mi algoritmo, como el otro que mencioné en la posdata. Por ejemplo, puedes duplicar $n$ cada vez y luego cuando te pases, usa la búsqueda binaria en el espacio entre la última $n$ y el que se pasó de la raya.