Question

I need to find all monomials in the form A^X that when evaluated falls within a range from m to n. It is safe to say that the base A is greater than 1, the power X is greater than 2, and only integers need to be used. For example, in the range 50 to 100, the solutions would be:

2^6
3^4
4^3

My first attempt to solve this was to brute force all combinations of A and X that make “sense.” However this becomes too slow when used for very large numbers in a big range since these solutions are used in part of much more intensive processing. Here is the code:

def monoSearch(min, max):
    base = 2
    power = 3

    while 1:
        while base**power < max:
            if base**power > min:
                print "Found " + repr(base) + "^" + repr(power) + "   = " + repr(base**power)    
            power = power + 1
        base = base + 1
        power = 3
        if base**power > max:
            break

I could remove one base**power by saving the value in a temporary variable but I don’t think that would make a drastic effect. I also wondered if using logarithms would be better or if there was a closed form expression for this. I am open to any optimizations or alternatives to finding the solutions.

Answer 1

Don’t search; consider the endpoints.

For example, all the solutions with x == 3 are such that a is between the cube root of m and the cube root of n. So calculate those cube roots and use the range of integers in between. Since a is at least 2, the maximum x is log base 2 of n, so that’s how you know when to stop.

from math import log, ceil, floor

def monoSearch(low, high):
    max_power = int(floor(log(high) / log(2)))
    for power in range(3, max_power + 1):
        min_base = low ** (1.0 / power)
        max_base = high ** (1.0 / power)
        for base in range(int(ceil(min_base)), int(floor(max_base)) + 1):
            yield '%s ^ %s' % (base, power)

print '\n'.join(monoSearch(42, 1000000))

This may miss a couple of values due to floating-point imprecision, unfortunately.