Нахождение суммы цифр

Question

У меня есть 5-значное целое число, скажем

int num = 23456;

Как узнать сумму его цифр?

Answer 1

Используйте операцию по модулю , чтобы получить значение младшей цифры:

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

Если вам нужен способ сделать это без операторов управления и невероятно эффективно загружаться, 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 5

Как насчет этого:

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

Answer 6

Немного связано: если вы хотите сумму повторяющихся цифр , хорошая оптимизация будет:

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

Далее следует код.

Answer 7

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

сумма - сумма цифр числа n

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

На самом деле, я ответил другим (несколько смешным) ответом, который использовал абсолютно огромный массив для поиска в таблице, но, оглядываясь назад, это не так уж и плохо, если вы ограничите размер таблицы.

Следующие функции компенсируют пространство для времени.Как и во всех оптимизациях, вы должны сами их профилировать в целевой среде.

Первая (элегантная) рекурсивная версия:

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-битное значение без знака с глубиной рекурсии в семь кадров стека.

Для тех, кто даже не доверяет , что небольшое количество рекурсии (и вы должны, так какобычные программы идут так глубоко и даже без рекурсии), вы можете попробовать итеративное решение:

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, вы можете увеличить скорость до четырех или пяти раз, но вы можете написать программу для генерации оператора статического массива, приведенного выше: -)

Как и при любой оптимизацииварианты, мера, не угадай!

Я сам предпочитаю более элегантное рекурсивное решение, но я также один из тех, кто предпочитает загадочные кроссворды.Читайте в это, что вы будете.