How can I count the digits in an integer without a string cast?

Question

I fear there's a simple and obvious answer to this question. I need to determine how many digits wide a count of items is, so that I can pad each item number with the minimum number of leading zeros required to maintain alignment. For example, I want no leading zeros if the total is < 10, 1 if it's between 10 and 99, etc.

One solution would be to cast the item count to a string and then count characters. Yuck! Is there a better way?

Edit: I would not have thought to use the common logarithm (I didn't know such a thing existed). So, not obvious - to me - but definitely simple. This question has generated way more activity than I expected. I'll let the dust settle before I choose a best answer.

Answer 1

 int length = (number ==0) ? 1 : (int)Math.log10(number) + 1;

should do it.

Answer 2

One solution is provided by base 10 logarithm, a bit overkill.

Answer 3

You can use a while loop, which will likely be faster than a logarithm because this uses integer arithmetic only:

int len = 0;
while (n > 0) {
    len++;
    n /= 10;
}

I leave it as an exercise for the reader to adjust this algorithm to handle zero and negative numbers.

Answer 4

You can loop through and delete by 10, count the number of times you loop;

int num = 423;
int minimum = 1;
while (num > 10) {
    num = num/10;
    minimum++;
}

Answer 5

int length = (int)Math.Log10(Math.Abs(number)) + 1;

You may need to account for the negative sign..

Answer 6

If you are going to pad the number in .Net, then

num.ToString().PadLeft(10, '0')

might do what you want.

Answer 7

Since a number doesn't have leading zeroes, you're converting anyway to add them. I'm not sure why you're trying so hard to avoid it to find the length when the end result will have to be a string anyway.

Answer 8

Okay, I can't resist: use /=:

#include <stdio.h>

int
main(){
        int num = 423;
        int count = 1;
        while( num /= 10)
                count ++;
        printf("Count: %d\n", count);
        return 0;
}
534 $ gcc count.c && ./a.out
Count: 3
535 $

Answer 9

A more efficient solution than repeated division would be repeated if statements with multiplies... e.g. (where n is the number whose number of digits is required)

unsigned int test = 1;
unsigned int digits = 0;
while (n >= test)
{
  ++digits;
  test *= 10;
}

If there is some reasonable upper bound on the item count (e.g. the 32-bit range of an unsigned int) then an even better way is to compare with members of some static array, e.g.

// this covers the whole range of 32-bit unsigned values
const unsigned int test[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };

unsigned int digits = 0;
while(n >= test[digits]) ++digits;

Answer 10

I would have posted a comment but my rep score won't grant me that distinction.

All I wanted to point out was that even though the Log(10) is a very elegant (read: very few lines of code) solution, it is probably the one most taxing on the processor.

I think jherico's answer is probably the most efficient solution and therefore should be rewarded as such.

Especially if you are going to be doing this for a lot of numbers..