Fastest way to sum digits in a number

Given a large number, e.g. 9223372036854775807 (Int64.MaxValue), what is the quickest way to sum the digits?

Currently I am ToStringing and reparsing each c开发者_StackOverflow社区har into an int:

num.ToString().Sum(c => int.Parse(new String(new char[] { c })));

Which is surely horrifically inefficent. Any suggestions?

And finally, how would you make this work with BigInteger?

Thanks

Well, another option is:

int sum = 0;
while (value != 0)
{
    int remainder;
    value = Math.DivRem(value, 10, out remainder);
    sum += remainder;
}

BigInteger has a DivRem method as well, so you could use the same approach.

Note that I've seen DivRem not be as fast as doing the same arithmetic "manually", so if you're really interested in speed, you might want to consider that.

Also consider a lookup table with (say) 1000 elements precomputed with the sums:

int sum = 0;
while (value != 0)
{
    int remainder;
    value = Math.DivRem(value, 1000, out remainder);
    sum += lookupTable[remainder];
}

That would mean fewer iterations, but each iteration has an added array access...

Nobody has discussed the BigInteger version. For that I'd look at 10¹, 10², 10⁴, 10⁸ and so on until you find the last 10²ⁿ that is less than your value. Take your number div and mod 10²ⁿ to come up with 2 smaller values. Wash, rinse, and repeat recursively. (You should keep your iterated squares of 10 in an array, and in the recursive part pass along the information about the next power to use.)

With a BigInteger with k digits, dividing by 10 is O(k). Therefore finding the sum of the digits with the naive algorithm is O(k²).

I don't know what C# uses internally, but the non-naive algorithms out there for multiplying or dividing a k-bit by a k-bit integer all work in time O(k^1.6) or better (most are much, much better, but have an overhead that makes them worse for "small big integers"). In that case preparing your initial list of powers and splitting once takes times O(k^1.6). This gives you 2 problems of size O((k/2)^1.6) = 2^-0.6O(k^1.6). At the next level you have 4 problems of size O((k/4)^1.6) for another 2^-1.2O(k^1.6) work. Add up all of the terms and the powers of 2 turn into a geometric series converging to a constant, so the total work is O(k^1.6).

This is a definite win, and the win will be very, very evident if you're working with numbers in the many thousands of digits.

Yes, it's probably somewhat inefficient. I'd probably just repeatedly divide by 10, adding together the remainders each time.

The first rule of performance optimization: Don't divide when you can multiply instead. The following function will take four digit numbers 0-9999 and do what you ask. The intermediate calculations are larger than 16 bits. We multiple the number by 1/10000 and take the result as a Q16 fixed point number. Digits are then extracted by multiplication by 10 and taking the integer part.

#define TEN_OVER_10000 ((1<<25)/1000 +1) // .001 Q25

int sum_digits(unsigned int n)
{
    int c;
    int sum = 0;
    n = (n * TEN_OVER_10000)>>9; // n*10/10000 Q16
    for (c=0;c<4;c++)
    {
    printf("Digit: %d\n", n>>16);
        sum += n>>16;
        n = (n & 0xffff) * 10; // next digit
    }
    return sum;
}

This can be extended to larger sizes but its tricky. You need to ensure that the rounding in the fixed point calculation always works correctly. I also did 4 digit numbers so the intermediate result of the fixed point multiply would not overflow.

    Int64 BigNumber = 9223372036854775807;

    String BigNumberStr = BigNumber.ToString();
    int Sum = 0;

    foreach (Char c in BigNumberStr)
        Sum += (byte)c;

    // 48 is ascii value of zero
    // remove in one step rather than in the loop
    Sum -= 48 * BigNumberStr.Length;

Instead of int.parse, why not subtract '0' from each digit to get the actual value.

Remember, '9' - '0' = 9, so you should be able to do this in order k (length of the number). The subtraction is just one operation, so that should not slow things down.