By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
444,018 Members | 1,204 Online
Bytes IT Community
Submit an Article
Got Smarts?
Share your bits of IT knowledge by writing an article on Bytes.

Thinking Outside the Box with Python

Motoma
Expert 2.5K+
P: 3,235
This article is cross posted from my personal blog. You can find the original article, in all its splendor, at http://motomastyle.com/thinking-outs...x-with-python/ .

Introduction:
I recently came across this job posting in the 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:


Expand|Select|Wrap|Line Numbers
  1. def BaseSeven(num):
  2.     powersOfSeven = 1;
  3.     res = 0;
  4.     while num / powersOfSeven > 6: powersOfSeven = powersOfSeven * 7
  5.     while powersOfSeven != 1:
  6.         res = res * 10 + int(num / powersOfSeven)
  7.         num = num - int(num / powersOfSeven) * powersOfSeven
  8.         powersOfSeven = powersOfSeven / 7
  9.     res = res * 10 + num
  10.     return res
  11.  
  12. def HasThreeZeros(num):
  13.     return str(num).find("000") != -1
  14.  
  15. def FindWithoutZeros(power):
  16.     lastWithoutThreeZeros = power
  17.     failures = -1
  18.     num = pow(2, power)
  19.     while failures <= lastWithoutThreeZeros:
  20.         if HasThreeZeros(BaseSeven(num)):
  21.            failures = failures + 1
  22.         else:
  23.             failures = 0
  24.             lastWithoutThreeZeros = power
  25.             print power
  26.         power = power + 1
  27.         num = num * 2
  28.         if (float(power) / 100) == int(power / 100): print "CheckPoint:", power
  29.     return lastWithoutThreeZeros
  30.  
  31. 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.

Expand|Select|Wrap|Line Numbers
  1. class BaseSevenNumber:
  2.  
  3.     def __init__(self):
  4.         self.digits = [1]
  5.  
  6.     def Double(self):
  7.         for i in range(0, len(self.digits)):
  8.             self.digits[i] = self.digits[i] * 2
  9.         for i in range(len(self.digits) - 1, -1, -1):
  10.             if self.digits[i] > 6:
  11.                 self.digits[i] = self.digits[i] - 7
  12.                 if i == 0: self.digits.insert(0,1)
  13.                 else: self.digits[i - 1] = self.digits[i - 1] + 1
  14.  
  15.     def HasThreeZeros(self):
  16.         for i in range(0, len(self.digits) - 2):
  17.             if self.digits[i] == 0 and self.digits[i + 1] == 0 and self.digits[i + 2] == 0: return True
  18.         return False
  19.  
  20. def SolveRiddle(maxFailuresAssumeFound):
  21.     bsn = BaseSevenNumber()
  22.     failures = 0
  23.     power = 1
  24.     while failures < maxFailuresAssumeFound:
  25.         bsn.Double()
  26.         if bsn.HasThreeZeros(): failures = failures + 1
  27.         else:
  28.             failures = 0
  29.             print power
  30.         power = power + 1
  31.  
  32. 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.
May 18 '07 #1
Share this Article
Share on Google+
3 Comments


bvdet
Expert Mod 2.5K+
P: 2,851
Motoma - Excellent solution! I need to be producing but could not get this problem off my mind. Here's a top down approach:
Expand|Select|Wrap|Line Numbers
  1. def ConvDecToBaseVar(num, base):
  2.     if base > 10 or base < 2:
  3.         raise ValueError, 'The base number must be between 2 and 10.'
  4.     if num == 0: return '0'
  5.     ans = ''
  6.     while num != 0:
  7.         num, rem = divmod(num, base)
  8.         ans =  str(rem)+ans
  9.     return ans
  10.  
  11. def solve_test1(max):
  12.     for i in xrange(max, 0, -1):
  13.         if '000' not in ConvDecToBaseVar(2**i, 7):
  14.             return i
  15.         else:
  16.             print 'Checked power %s, FAILED TEST' % (i)
It took a while, but found that the highest number below 20000 is 8833. It's not nearly as efficient as yours. Now I can get back to work.
May 18 '07 #2

P: 75
so, did you get the job? :D
Dec 12 '07 #3

Motoma
Expert 2.5K+
P: 3,235
so, did you get the job? :D
Pffftt...I never applied. I have no Python experience :D
Dec 12 '07 #4