Sum of Digits of a Number

Try it on GfG Practice

Given a number n, find the sum of its digits.

Examples : 

Input: n = 687
Output: 21
Explanation: The sum of its digits are: 6 + 8 + 7 = 21

Input: n = 12
Output: 3
Explanation: The sum of its digits are: 1 + 2 = 3

Iterative Approach

The idea is to add the digits starting from the rightmost (least significant) digit and moving towards the leftmost (most significant) digit. This can be done by repeatedly extracting the last digit from the number using modulo 10 operation, adding it to the sum, and then removing it using integer division by 10. For eg: n = 1567, then 1567 / 10 = 156.7 = 156(Integer Division).

// Iterative C++ Code to find sum of digits

#include <iostream>
using namespace std;

int sumOfDigits(int n) {
    int sum = 0;
    while (n != 0) {

        // Extract the last digit
        int last = n % 10;

        // Add last digit to sum
        sum += last;

        // Remove the last digit
        n /= 10;
    }
    return sum;
}

int main() {
    int n = 12345;
    cout << sumOfDigits(n);
    return 0;
}

// Iterative C Code to find sum of digits

int sumOfDigits(int n) {
    int sum = 0;
    while (n != 0) {

        // Extract the last digit
        int last = n % 10;

        // Add last digit to sum
        sum += last;

        // Remove the last digit
        n /= 10;
    }
    return sum;
}

int main() {
    int n = 12345;
    printf("%d", sumOfDigits(n));
    return 0;
}

// Iterative Java Code to find sum of digits

class GfG {
    static int sumOfDigits(int n) {
        int sum = 0;
        while (n != 0) {

            // Extract the last digit
            int last = n % 10;

            // Add last digit to sum
            sum += last;

            // Remove the last digit
            n /= 10;
        }
        return sum;
    }

    public static void main(String[] args) {
        int n = 12345;
        System.out.println(sumOfDigits(n));
    }
}

# Iterative Python Code to find sum of digits

def sumOfDigits(n):
    sum = 0
    while n != 0:

        # Extract the last digit
        last = n % 10

        # Add last digit to sum
        sum += last

        # Remove the last digit
        n //= 10
    return sum

if __name__ == "__main__":
	n = 12345
	print(sumOfDigits(n))

// Iterative C# Code to find sum of digits

using System;
class GfG {
    static int sumOfDigits(int n) {
        int sum = 0;
        while (n != 0) {

            // Extract the last digit
            int last = n % 10;

            // Add last digit to sum
            sum += last;

            // Remove the last digit
            n /= 10;
        }
        return sum;
    }

    static void Main() {
        int n = 12345;
        Console.WriteLine(sumOfDigits(n));
    }
}

// Iterative JavaScript Code to find sum of digits

function sumOfDigits(n) {
    let sum = 0;
    while (n !== 0) {

        // Extract the last digit
        let last = n % 10;

        // Add last digit to sum
        sum += last;

        // Remove the last digit
        n = Math.floor(n / 10);
    }
    return sum;
}

// Driver Code
let n = 12345;
console.log(sumOfDigits(n));

15

Time Complexity: O(log₁₀n), as we are iterating over all the digits.
Auxiliary Space: O(1)

Recursive Approach

We can also use recursion to find the sum of digits. The idea is to extract the last digit. add it to the sum, and recursively call the function with the remaining number (after removing the last digit).

• Base Case: If the number is 0, return 0.
• Recursive Case: Extract the last digit and add it to the result of recursive call with n / 10.

// Recursive C++ Code to find sum of digits

#include <iostream>
using namespace std;

int sumOfDigits(int n) {
    
    // Base Case
    if (n == 0)
        return 0;

    // Recursive Case
    return (n % 10) + sumOfDigits(n / 10);
}

int main() {
    cout << sumOfDigits(12345);
    return 0;
}

// Recursive C Code to find sum of digits

#include <stdio.h>
int sumOfDigits(int n) {
    
    // Base Case 
    if (n == 0)
        return 0;

    // Recursive Case
    return (n % 10) + sumOfDigits(n / 10);
}

int main() {
    printf("%d", sumOfDigits(12345));
    return 0;
}

// Recursive Java Code to find sum of digits

import java.io.*;

class GfG {
    static int sumOfDigits(int n) {
        
        // Base Case
        if (n == 0)
            return 0;

        // Recursive Case
        return (n % 10) + sumOfDigits(n / 10);
    }

    public static void main(String[] args) {
        System.out.println(sumOfDigits(12345));
    }
}

# Recursive Python Code to find sum of digits

def sumOfDigits(n):
    
    # Base Case
    if n == 0:
        return 0
  
    # Recursive Case
    return n % 10 + sumOfDigits(n // 10)


if __name__ == "__main__":
    print(sumOfDigits(12345))

// Recursive C# Code to find sum of digits

using System;

class GfG {
    static int sumOfDigits(int n) {
        
        // Base Case
        if(n == 0)
            return 0;
      
        // Recursive Case
        return n % 10 + sumOfDigits(n / 10);
    }

    static void Main() {
        Console.Write(sumOfDigits(12345));
    }
}

// Recursive JavaScript Code to find sum of digits

function sumOfDigits(n) {
    
    // Base Case
    if (n == 0)
        return 0;

    // Recursive Case
    return (n % 10) + sumOfDigits(Math.floor(n / 10));
}

// Driver code
console.log(sumOfDigits(12345));

15

Time Complexity: O(log₁₀n), as we are iterating over all the digits.
Auxiliary Space: O(log₁₀n) because of function call stack.

Taking Input Number as String

The idea is to take the input number as a string and then iterate over all the characters(digits) to find the sum of digits. To find the actual value of a digit from a character, subtract the ASCII value of '0' from the character.

This approach is used when the input number is so large that it cannot be stored in integer data types.

// C++ Code to find the sum of digits by
// taking the input number as string

#include <iostream>
using namespace std;

int sumOfDigits(string &s) {
    int sum = 0;
    for (int i = 0; i < s.length(); i++) {
      
        // Extract digit from character
        int digit = s[i] - '0';
      
        // Add digit to the sum
        sum = sum + digit;
    }
    return sum;
}

int main() {
    string s = "123456789123456789123422";

    cout << sumOfDigits(s);
    return 0;
}

// C Code to find the sum of digits by
// taking the input number as string

#include <string.h>
int sumOfDigits(char *s) {
    int sum = 0;
    for (int i = 0; i < strlen(s); i++) {
      
        // Extract digit from character
        int digit = s[i] - '0';
      
        // Add digit to the sum
        sum = sum + digit;
    }
    return sum;
}

int main() {
    char s[] = "123456789123456789123422";

    printf("%d", sumOfDigits(s));
    return 0;
}

// Java Code to find the sum of digits by
// taking the input number as string

class GfG {
    static int sumOfDigits(String s) {
        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
          
            // Extract digit from character
            int digit = s.charAt(i) - '0';
          
            // Add digit to the sum
            sum = sum + digit;
        }
        return sum;
    }

    public static void main(String[] args) {
        String s = "123456789123456789123422";
        System.out.println(sumOfDigits(s));
    }
}

# Python Code to find the sum of digits by
# taking the input number as string

def sumOfDigits(s):
    sum = 0
    for i in range(len(s)):
      
        # Extract digit from character
        digit = ord(s[i]) - ord('0') 
      
        # Add digit to the sum
        sum = sum + digit
    return sum

if __name__ == "__main__":
    s = "123456789123456789123422"
    print(sumOfDigits(s))

// C# Code to find the sum of digits by
// taking the input number as string

using System;

class GfG {
    static int sumOfDigits(string s) {
        int sum = 0;
        for (int i = 0; i < s.Length; i++) {
          
            // Extract digit from character
            int digit = s[i] - '0';
          
            // Add digit to the sum
            sum = sum + digit;
        }
        return sum;
    }

    static void Main() {
        string s = "123456789123456789123422";

        Console.WriteLine(sumOfDigits(s));
    }
}

// JavaScript Code to find the sum of digits by
// taking the input number as string

function sumOfDigits(s) {
    let sum = 0;
    for (let i = 0; i < s.length; i++) {
      
        // Extract digit from character
        let digit = s[i] - '0';
      
        // Add digit to the sum
        sum = sum + digit;
    }
    return sum;
}

// Driver Code
let s = "123456789123456789123422";
console.log(sumOfDigits(s));

104

Time Complexity: O(len(s)), as we are iterating over all the characters(digits).
Auxiliary Space: O(1)

kartik

Follow

Improve

Article Tags :

• Recursion
• C Language
• C++
• DSA
• number-digits
• cpp-puzzle

+2 More

Practice Tags :

• CPP
• Recursion