Question

我有一个5位整数，比如说

int num = 23456;

如何找到其数字的总和？

Answer 1

使用modulo operation获取最低有效数字的值：

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

如果输入可能是负数，那么检查并反转符号是个好主意。

Answer 2

#include <stdio.h>

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

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

    printf("%i", sum);

    return 0;
}

Answer 3

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

如果num为负数，则给出否定答案，无论如何都是C99。

这是家庭作业吗？

Answer 4

这个怎么样：

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

Answer 5

如果你想要一种没有控制语句的方法，并且启动效率极高，O(1)而不是O(n), n = digit count方法：

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

略有关联：如果你想要repeated digit sum，一个很好的优化是：

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

其次是代码。

Answer 7

实际上，我回答了另一个（有点幽默）的答案，它使用一个绝对庞大的数组进行表查找但是，回想一下，如果你限制表的大小，那就不是一个好主意了。

以下功能可以在空间上进行权衡。与所有优化一样，您应该在目标环境中自行配置它们。

首先是（优雅的）递归版本：

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];
}

它基本上将数字分成三位数组，每种可能性都有固定查找。这可以轻松处理64位无符号值，递归深度为7个堆栈帧。

对于那些甚至不信任少量递归的人（你应该，因为正常的程序会那么深入，甚至没有递归），你可以尝试迭代解决方案：

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;
}

这些可能比一位一位数的解决方案快三倍，代价是千字节数据。如果你不喜欢使用10K或100K，你可以将速度提高到四到五倍，但你可能想编写一个程序来生成上面的静态数组语句： - ）

与所有优化选项一样，测量，不要猜测！

我更喜欢自己更优雅的递归解决方案，但我也是喜欢神秘填字游戏的人之一。请阅读您的意见。

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

这里使用sprintf和ascii数字表示的另一个想法

Answer 9

#include<stdio.h>
main()
{
                 int sum=0,n;
                 scanf("%d",&n);
                 while(n){
                       sum+=n%10;
                       n/=10;
                 }
                 printf("result=%d",sum);
}

sum是数字n的数字之和

找到数字的总和

9 个答案: