Question

Can someone find a strategy for this problem that DOESN’T INVOLVE CONVERTING TO BASE 2? You don’t have to write the code, just give me a general strategy.

Round Numbers

The cows, as you know, have no fingers or thumbs and thus are unable to play Scissors, Paper, Stone’ (also known as ‘Rock, Paper, Scissors’, ‘Ro, Sham, Bo’, and a host of other names) in order to make arbitrary decisions such as who gets to be milked first. They can’t even flip a coin because it’s so hard to toss using hooves.

They have thus resorted to “round number” matching. The first cow picks an integer less than two billion. The second cow does the same. If the numbers are both “round numbers”, the first cow wins, otherwise the second cow wins.

A positive integer N is said to be a “round number” if the binary
representation of N has as many or more zeroes than it has ones. For example, the integer 9, when written in binary form, is 1001. 1001 has two zeroes and two ones; thus, 9 is a round number. The integer 26 is 11010 in binary; since it has two zeroes and three ones, it is not a round number.

Obviously, it takes cows a while to convert numbers to binary, so
the winner takes a while to determine. Bessie wants to cheat and thinks she can do that if she knows how many “round numbers” are in a given range.

Help her by writing a program that tells how many round numbers appear in the inclusive range given by the input (1 <= Start < Finish <= 2,000,000,000).

Input (rndnum.in)
Line 1: Two space-separated integers, respectively Start and Finish.

Output (rndnum.out)
Line 1: A single integer that is the count of round numbers in the
inclusive range Start..Finish

Sample Input

2 12

Sample Output

6

Answer 1

I don’t think you’re understanding your assignment. The requirements state that the cows cannot work out this stuff easily but it does not state that your program is not permitted to do so.

Your program is supposed to work out the “round” numbers in a given range and this is hard to do without converting to binary. I think that’s what your assignment is actually asking you to do.

If you must avoid converting to binary, there is another way. You can set up an array of size 16, containing the following values:

0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4

which represents the number of 1-bits in the numbers zero through fifteen inclusive.

Then, using division and modulo on a given number, you can quickly get the number of 1-bits in that number (and 0-bits).

In pseudo-code:

def getOneBits (num):
    lookup[] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
    oneBits = 0
    for i = 1 to 8:
        oneBits = oneBits + lookup[num % 16]
        num = num / 16
    return oneBits

xstart = 271828
xend   = 314159
xcount = 0
for i = start to end:
    if getOneBits (i) <= 16:
        xcount = count + 1
print "There are " xcount " round numbers between " xstart " and " xend

As an aside, coding this up in C using a lookup table of size 256 (bytes instead of nybbles), I can get the time down to about 6 seconds, with only a little optimisation effort.