How do you count in another base?

Question

Say I want to count in binary until I have the highest number a set number of bytes will hold, how could I do that? It feels like there should be a pretty simple way, I just don't know it. I googled but was surprised to not find any examples.

For example, if I wanted to count to 1 byte I'd start with 00000001 add 1 and get 00000010, add 1 to get 00000011, etc until I get to 11111111.

Additionally, how could you do the same in hex? you start with 0x00, add one and output 0x01, the 0x02, 0x03, etc until you get to 0xFF?

Also, how can I output the values as a string (like my examples)?

Some psuedo-code:

byteSize = 3
counter = 0
    while counter.size <= byteSize
      print counter /* prints 00000001, 00000010, etc. 
      count += 1
    loop

Update:

I'm not only concerned with displaying a number in another base, that was only part of it. I see my error in that the displaying function is what determines how the number is displayed (as Jeremy pointed out). So, that's parts not a problem.

Update 2:

I promise I'm not a complete moron. Here is the context:

It started today when I read this on reddit: http://www.elliottkember.com/kember_identity.html

Then, this: http://www.reddit.com/r/programming/comments/8iguu/md5_gamechallenge_for_you_reddit/

which led to this: http://www.olegkikin.com/md5game/

So, I figured you could just count in bits starting at different intervals and just let 'er run.

Answer 1

Binary

for (int i = 0; i <= byte.MaxValue; i++)
{
    Console.WriteLine(Convert.ToString(i, 2).PadLeft(8, '0'));
}

Hexadecimal

for (int i = 0; i <= byte.MaxValue; i++)
{
    Console.WriteLine("0x" + i.ToString("X").PadLeft(2, '0'));
}

or

for (int i = 0; i <= byte.MaxValue; i++)
{
    Console.WriteLine(Convert.ToString(i, 16).PadLeft(2, '0'));
}

Multiple bytes

int numBytes = 3;
for (int i = 0; i < Math.Pow(2, numBytes * 8); i++)
{
    Console.WriteLine(Convert.ToString(i, 2).PadLeft(numBytes * 8, '0'));
}

I wouldn't do more than 3, or you're going to be waiting a very long time...

Response to Update:

I hope you were kidding about "counting to 20 bytes in binary". That's 160 bits. That creates a list of numbers with a count somewhere in the realm of the number of atoms in the entire universe. I hope you have plenty of time (i.e. googols of millenia) to wait for that to finish :)

Answer 2

The base that you're "counting" in is all up to the function that outputs the number to the screen (or converts it to a string before doing so). Different bases are just different ways of visually representing the same numbers. So to "count" in binary, you would simply tell your number-to-string function to use base 2 instead of the default base 10.

Answer 3

For arbitrary depth.

You could switch this to 64-bit easily if that makes sense to do so (e.g., 64-bit processor).

Note: this is entirely free-hand and I have not compiled it nor, obviously, tested it. I can't even begin to guess how long it would take to print out 2^160 values (that's 1.46e48 values) or more if you do more than 5 32-bit counters.

This is grossly inefficient but what the heck.

// A word is 32-bits
void CountBytes(int numberOfWords)
{
    uint[] numbers = new uint[numberOfWords];

    while(true)
    {
        // Show most-significant first
        for (int i=numbers.Length-1; i>=0; i--)
        {
            Console.Write(Convert.ToString(numbers[i], 2).PadLeft(32, '0'));
        }

        // Hit max on all uint's, bail
        bool done = true;
        for (int i=numbers.Length-1; i >= 0; i--)
        {
            if (numbers[i] != uint.MaxValue)
            {
                done = false;
                break;
            }
        }
        if (done)
        {
            break;
        }

        // Check for overflow
        for (int i=numbers.Length-2; i >= 0; i--)
        {
            // Overflow for numbers[i] is if it and all beneath it are MaxValue
            bool overflow = true;
            for (int k=i; k>=0; k--)
            {
                if (numbers[k] != uint.MaxValue)
                {
                    overflow = false;
                    break;
                }
            }

            if (overflow)
            {
                numbers[i+1]++;
                numbers[i] = 0;
            }
        }

        // Increment counter
        numbers[0]++;
    }
}

Answer 4

2^{8 * bytes} - 1

Example for 1 byte:

2^{8 * 1 byte}
= 2⁸
= 255

That's the highest number (integer) you can store in 1 byte.