Thinking Outside the Box with Python

Posted by Motoma

I recently came across this job posting in the The Scripts Developer Network forums. It has an interesting brain teaser as a requirement for applying. The brain teaser was stated as: "What is the exponent of the largest power of two whose base seven representation doesn't contain three zeros in a row?" The only stipulation was that the applicant use Python to solve the problem.

My Initial Approach: My inital approach to the problem is blunt and straight forward. I build three functions, BaseSeven which takes a number and convert it to base seven, HasThreeZeros which takes a number and checks if it has three zeros in it, and FindWithoutZeros which was the main loop of my program. The code for my problem is listed below:

def BaseSeven(num):
    powersOfSeven = 1;
    res = 0;
    while num / powersOfSeven &gt; 6: powersOfSeven = powersOfSeven * 7
    while powersOfSeven != 1:
        res = res * 10 + int(num / powersOfSeven)
        num = num - int(num / powersOfSeven) * powersOfSeven
        powersOfSeven = powersOfSeven / 7
    res = res * 10 + num
    return res
 
def HasThreeZeros(num):
    return str(num).find("000") != -1
 
def FindWithoutZeros(power):
    lastWithoutThreeZeros = power
    failures = -1
    num = pow(2, power)
    while failures &lt;= lastWithoutThreeZeros:
        if HasThreeZeros(BaseSeven(num)):
           failures = failures + 1
        else:
            failures = 0
            lastWithoutThreeZeros = power
            print power
        power = power + 1
        num = num * 2
        if (float(power) / 100) == int(power / 100): print "CheckPoint:", power
    return lastWithoutThreeZeros
 
print FindWithoutZeros(1)

The solution is quick and dirty, though severely lacking in elegance and speed. The biggest problem with this solution is that the program is constantly performing arithmetic operations on a huge number; when the exponent climbs into the upper thousands, it takes well over a minute to build, convert, and check a single number.

"There is no need for this," I say to myself, "There is a better way to do it."

Round 2: With a new cup of coffee in hand, I begin to further analyze the problem. Rereading the problem, I begin to think about the properties of powers of two: the most important property being that each successive power of two is double the previous. I know this is a pretty rudementary conclusion, however, realizing that the same will hold true for the base seven equivalent is the key to solving this problem efficiently.

I begin constructing a class, titled BaseSevenNumber. I give it a list, named digits, whose elements will contain a single base seven digit. I build a constructor to initialize this list to [1], and a member function titled Double which will handle my "exponentiation." I finish off the class by creating another member, aptly titled HasThreeZeros, to give me the current status of number.

The Double Function: BaseSevenNumber's Double function would hold the key to solving this problem in a timely manner. Rather than perform one arithmetic operation on a huge number, I design my second program to perform many arithmetic operations on a handful of tiny numbers. Iterating through the list, Double doubles each digit in the digits list, and in a second pass, performs all base seven carry operations. the HasThreeZeros function can now quickly traverse the digits list, and return the appropriate status for the current base seven number.

class BaseSevenNumber:
    
    def __init__(self):
        self.digits = [1]
        
    def Double(self):
        for i in range(0, len(self.digits)):
            self.digits = self.digits * 2
        for i in range(len(self.digits) - 1, -1, -1):
            if self.digits &gt; 6:
                self.digits = self.digits - 7
                if i == 0: self.digits.insert(0,1)
                else: self.digits[i - 1] = self.digits[i - 1] + 1
 
    def HasThreeZeros(self):
        for i in range(0, len(self.digits) - 2):
            if self.digits == 0 and self.digits[i + 1] == 0 and self.digits[i + 2] == 0:
                return True
        return False
  
def SolveRiddle(maxFailuresAssumeFound):
    bsn = BaseSevenNumber()
    failures = 0
    power = 1
    while failures &lt; maxFailuresAssumeFound:
        bsn.Double()
        if bsn.HasThreeZeros(): failures = failures + 1
        else:
            failures = 0
            print power
        power = power + 1
 
SolveRiddle(10000)

Thoroughly pleased with my ability to think my way around the problem, I put the code to the test. In a meager 16 seconds, it has given me the answer I am looking for. Talk about using the wrong tools for the job; just because the problem stated "power of two" and "base seven representation" does not mean one should restrict oneself to these methods. A careful and thorough analysis of a problem can give one an efficient, elegant, and fast solution to some of the trickiest of problems.

Post your comment

Comments

No one has commented on this page yet.

RSS feed for comments on this page

MotomaSTYLE