C Program To Find Sum of Digits of A Number

The for loop is another way to achieve the same goal, but it’s more structured when the number of iterations is predictable.

In this situation, the loop keeps executing until the number is equal to zero, just like a while loop, but the initialization, condition and increment are done in one line.

Code Implementation to find sum of digits of a number using For loop

#include <stdio.h>

int main(void)
{
    int num, sum = 0, rem;

    printf("Enter a number: ");
    scanf("%d", &num);

    // Loop to calculate sum of digits
    for (; num != 0; num /= 10)
    {
        rem = num % 10; // Extract the last digit
        sum += rem;     // Add it to the sum
    }

    printf("Sum of digits of the number is %d", sum);
    return 0;
}

Sample Output:

Enter a number: 123564
Sum of digits of the number is 21

‍How the Code Works

• The software will ask the user for a number, and the number will be stored in the variable num.
• For Loop: The for loop continues while num is not equal to zero.
• Each time within the for loop, the last digit will be found by using num % 10. The last digit will be added to the sum.
• The number will be reduced by performing num / 10.
• Output: After finishing the loop, the final sum of digits will print out.

Quick Note:
The for loop is compact and preferred when you know exactly what you want to repeat, in this case, “until all digits are processed.”

This approach helps students get comfortable with loop structures and logic building in a clean, readable format.

Sometimes, instead of treating the number as an integer, we can take it as a string of characters.

This approach is particularly useful when you are dealing with very large numbers that may go beyond the range of standard data types like int or long.

sum of the digits of a number in C using char input:

Code Implementation to find sum of digits of a number using Character (Char) input

#include <stdio.h>

int main(void)
{
    char num[20];
    int sum = 0;

    printf("Enter a number: ");
    scanf("%s", num);

    // Iterate through each character until the null terminator
    for (int i = 0; num[i] != '\0'; i++)
    {
        sum += num[i] - '0';  // Convert character to digit and add to sum
    }

    printf("Sum of digits of the number is %d", sum);
    return 0;
}

Sample Output:

Enter a number: 12345
Sum of digits of the number is 15

How the Code Works

1. User Input: The user enters a number as a string, stored in the char array num.
2. Initialisation: sum is initialised to 0 to store the total sum of digits.
3. Loop Execution:
   
   • A for loop iterates through each character of num until the null terminator '\0' is reached.
   • Each character digit is converted to an integer using num[i] - '0'.
   • The converted digit is added to the sum.
4. Output: The final sum of the digits is printed after the loop completes.

Tip:
This method consolidates students' understanding of ASCII conversions, and that's the difference between numeric data and character data. Additionally, it is a great practice for students working with strings, loops, and type conversions - all key concepts in C programming.

Recursion is a technique in which a function solves a smaller instance of the exact same problem by calling itself. It is an essential idea in programming and promotes a strong grasp of logic. 

Code Implementation to find sum of digits of a number using Recursion

/* Find the sum of digits recursively */
 
#include <stdio.h>
 
long sum_of_digits_recur(long n)
{
    if (n == 0)
        return 0;
    else
        return n % 10 + sum_of_digits_recur(n / 10);
}
 
int main(void)
{
    long n;
    printf("Enter a number: ");
    scanf("%ld", &n);
    printf("Sum of digits of the number is %ld", sum_of_digits_recur(n));
    return 0;
}

Sample Output:

Enter a number: 12445
Sum of digits of the number is 16

How the Code Works

1. Function sum_of_digits_recur: This function calculates the sum of digits using recursion.
2. Base Case: If n equals 0, the function returns 0 and stops further recursion.
3. Recursive Case: The function returns the last digit (n % 10) added to the result of a recursive call with the remaining digits (n / 10). This continues until n becomes 0.
4. Main Function:
   
   • Asks the user to enter a number and stores it in n.
   • Calls sum_of_digits_recur(n) to calculate the sum of digits.
   • Print the result.

Bottom Line: Recursion might look complex at first, but it’s a powerful tool. This method helps you think like a problem-solver, breaking a big task into smaller, manageable ones.

In this instance, we are again using string input, but instead of using loop until '/0', we are using the strlen() function to obtain the length of the string to control the loop.

Code Implementation to find sum of digits of a number using the Input Number as String 

#include <stdio.h>
#include <string.h>

int main(void)
{
    char num[50];
    int sum = 0;

    printf("Enter a number: ");
    scanf("%s", num);
    // Loop through each character in the string
    for (int i = 0; i < strlen(num); i++)
    {
        sum += num[i] - '0'; // Convert character to digit and add to sum
    }

    printf("Sum of digits of the number is %d", sum);
    return 0;
}

Sample Output:

Enter a number: 12568
Sum of digits of the number is 22

How the Code Works

• User Input: A string value entered by the user is saved in the char array num.
• Loop Execution:
  
  • The program iterates through each character in the string one by one.
  • Each character (digit) is converted to its integer equivalent using the expression num[i] - '0'.
  • The converted digit is then added to the running total sum.
• Output: Once the loop completes, the program prints the total sum of the digits.

Tip:

This version teaches students how to use C library functions like strlen() for string manipulation, a key skill when working on text-based inputs.

Quick Recap on What We Learned So Far — Comparing All Methods

Let’s take a quick recap of everything we’ve learned about finding the sum of digits of a number in C. Each approach has its own logic, use case, and learning value.

Choose the technique that best fits your use case. For standard numbers, loops are simple and efficient. For very large numbers, character input is essential. Recursion is a wonderful way to practice function logic and breaking down larger problems.

This exercise reinforces core concepts like loops. The sum of digits program in C is a great way to see how variables, declared values, and functions interact with each other in the main body of a program.  By breaking a number into its individual digits, storing each digit in a variable, and adding them together, a programmer learns the logic behind the digits_sum operation.sum of digits of a number in in ways helps students build a solid foundation in programming. This exercise reinforces core concepts like loops, The sum of digits program in C is a great way to see how variables, declared values, and functions interact with each other in the main body of a program.  By breaking a number into its individual digits, storing each digit in a variable, and adding them together, a programmer learns the logic behind the digits_sum operation.

Whether using a while loop, for loop, or recursive function, this blog helps you apply key programming concepts like iteration, condition checking, and arithmetic computation. Practicing such programs strengthens your understanding of C fundamentals and prepares you to handle more advanced coding challenges with confidence and clarity.

To start your journey into software development and become job-ready, enrol on the CCBP Academy 4.0 program today!

Key Takeaways

• You explored multiple methods, iterative, recursive, and character-based, to calculate the sum of digits in C. 
• Each approach teaches a unique concept: loops for control flow, recursion for function logic, and strings for character operations. 
• Revisiting the same problem with different logic builds versatility and problem-solving depth, helping you write cleaner, more efficient programs.

Practical Advice

You can write other variations like finding the product or the reverse of digits; add input validation, and compare performance with them all as well. Remember to document your code; every little step builds your foundation in C and programming overall confidence.

1. What is the purpose of the sum of digits program?

The sum of digits program explains how to convert a number into individual digits and add them. This is valuable for learning more about loops, recursion and basic computations.

2. Is it possible to write the sum of digits program using recursion?

Yes, the sum of digits can also be defined recursively. After dividing the number by 10, taking the remainder, and arriving at 0, the recursive function sums the remainder until the number equals 0.

3. What is the mechanism of operation of the sum of digits approach based on character?

In the character-based methods, the number is actually handled as a string of characters. A character is converted to an integer, and then the sum is found by using a loop on the string.

4. Which method is better for finding the sum of digits: loop or recursion?

Both methods are equally correct, but general looping structures have been found to be more efficient in terms of memory utilisation. Recursion, in particular, is a good technique that one must study to encounter more complicated problems and learn problem-solving skills.

5. Is it possible to count the number of digits in large numbers?

Yes, it can be done, but numbers can be handled in larger numbers by using data types like long.

6. What’s the real-world application of this logic?

Digit-sum logic is used in checksum validation, cryptography, digital root calculations, and error detection algorithms.