Finding the sum of the digits

Question

I've have a 5 digit integer say, int num = 23456

how to find the sum of the digits.???

Answer 1

Use the modulo operation to get the value of the least significant digit:

int num = 23456;
int total = 0;
while (num != 0) {
    total += num % 10;
    num /= 10;
}

If the input could be a negative number then it would be a good idea to check for that and invert the sign.

Answer 2

int sum=0;while(num){sum+=num%10;num/=10;}

Gives a negative answer if num is negative, in C99 anyway.

Is this homework?

Answer 3

#include <stdio.h>

int main()
{
    int i = 23456;
    int sum = 0;

    while(i)
    {
        sum += i % 10;
        i /= 10;
    }

    printf("%i", sum);

    return 0;
}

Answer 4

How about this:

for(sum=0 ,num=23456;num; sum+=num %10, num/=10);

Answer 5

If you want a way to do it without control statements, and incredibly efficient to boot, O(1) instead of the O(n), n = digit count method:

int getSum (unsigned int val) {
    static int lookup[] = {
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, //     0-    9
         1,  2,  3,  4,  5,  6,  7,  8,  9, 10, //    10-   19
         2,  3,  4,  5,  6,  7,  8,  9, 10, 11, //    20-   29
         :
         9, 10, 11, 12, 13, 14, 15, 16, 17, 18, //    90-   99
         :
        14, 15, 16, 17, 18, 19, 20, 21, 22, 23, // 23450-23459
        ::
    };
    return lookup[23456];
}

---

:-)

Answer 6

Slightly related: if you want the repeated digit sum, a nice optimization would be:

if (num%3==0) return (num%9==0) ? 9 : 3;

Followed by the rest of the code.

Answer 7

Actually, I answered with another (somewhat humorous) answer which used a absolutely huge array for a table lookup but, thinking back on it, it's not that bad an idea, provided you limit the table size.

The following functions trade off space for time. As with all optimisations, you should profile them yourself in the target environment.

First the (elegant) recursive version:

unsigned int getSum (unsigned int val) {
    static const unsigned char lookup[] = {
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, //   0-  9
         1,  2,  3,  4,  5,  6,  7,  8,  9, 10, //  10- 19
         2,  3,  4,  5,  6,  7,  8,  9, 10, 11, //  20- 29
         :
        18, 19, 20, 21, 22, 23, 24, 25, 26, 27  // 990-999
    };
    return (val == 0) ? 0 : getSum (val / 1000) + lookup[val%1000];
}

It basically separates the number into three-digit groupings with fixed lookups for each possibility. This can easily handle a 64-bit unsigned value with a recursion depth of seven stack frames.

For those who don't even trust that small amount of recursion (and you should, since normal programs go that deep and more even without recursion), you could try the iterative solution:

unsigned int getSum (unsigned int val) {
    static const unsigned char lookup[] = {
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, //   0-  9
         1,  2,  3,  4,  5,  6,  7,  8,  9, 10, //  10- 19
         2,  3,  4,  5,  6,  7,  8,  9, 10, 11, //  20- 29
         :
        18, 19, 20, 21, 22, 23, 24, 25, 26, 27  // 990-999
    };
    unsigned int tot = 0;
    while (val != 0) {
        tot += lookup[val%1000];
        val /= 1000;
    }
    return tot;
}

These are probably three times faster than the one-digit-at-a-time solution, at the cost of a thousand bytes of data. If you're not adverse to using 10K or 100K, you could increase the speed to four or five times but you may want to write a program to generate the static array statement above :-)

As with all optimisation options, measure, don't guess!

I prefer the more elegant recursive solution myself but I'm also one of those types who prefer cryptic crosswords. Read into that what you will.

Answer 8

   #include <stdio.h>
  2 #include <stdlib.h>
  3
  4 #define BUFSIZE 20
  5
  6 int main(void)
  7 {
  8         int     number = 23456;
  9         char    myBuf[BUFSIZE];
 10         int     result;
 11         int     i = 0;
 12
 13         sprintf(myBuf,"%i\0",number);
 14
 15         for( i = 0; i < BUFSIZE && myBuf[i] != '\0';i++)
 16         {
 17                 result += (myBuf[i]-48);
 18         }
 19
 20         printf("The result is %d",result);
 21         return 0;
 22 }
 23

Another idea here using the sprintf and the ascii number representation