Open In App

Find sum of digits in factorial of a number

Improve
Improve
Like Article
Like
Save
Share
Report

Given a number n, write code to find the sum of digits in the factorial of the number. Given n ≤ 5000
 Examples: 

Input : 10
Output : 27
Input : 100
Output : 648

It is not possible to store a number as large as 100! under some data types so, idea is to store an extremely large number in a vector. 
 

1) Create a vector to store factorial digits and
   initialize it with 1.
2) One by one multiply numbers from 1 to n to 
   the vector. We use school mathematics for this
   purpose.
3) Sum all the elements in vector and return the sum.

C++




// C++ program to find sum of digits in factorial
// of a number
#include <bits/stdc++.h>
using namespace std;
 
// Function to multiply x with large number
// stored in vector v. Result is stored in v.
void multiply(vector<int> &v, int x)
{
    int carry = 0, res;
    int size = v.size();
    for (int i = 0 ; i < size ; i++)
    {
        // Calculate res + prev carry
        int res = carry + v[i] * x;
 
        // updation at ith position
        v[i] = res % 10;
        carry = res / 10;
    }
    while (carry != 0)
    {
        v.push_back(carry % 10);
        carry /= 10;
    }
}
 
// Returns sum of digits in n!
int findSumOfDigits(int n)
{
    vector<int> v;     // create a vector of type int
    v.push_back(1);    // adds 1 to the end
 
    // One by one multiply i to current vector
    // and update the vector.
    for (int i=1; i<=n; i++)
        multiply(v, i);
 
    // Find sum of digits in vector v[]
    int sum = 0;
    int size = v.size();
    for (int i = 0 ; i < size ; i++)
        sum += v[i];
    return sum;
}
 
// Driver code
int main()
{
    int n = 1000;
    cout << findSumOfDigits(n);
    return 0;
}


Java




// Java program to find sum of digits in factorial
// of a number
import java.util.*;
class GFG{
// Function to multiply x with large number
// stored in vector v. Result is stored in v.
static ArrayList<Integer> v=new ArrayList<Integer>();
static void multiply(int x)
{
    int carry = 0;
    int size = v.size();
    for (int i = 0 ; i < size ; i++)
    {
        // Calculate res + prev carry
        int res = carry + v.get(i) * x;
 
        // updation at ith position
        v.set(i,res % 10);
        carry = res / 10;
    }
    while (carry != 0)
    {
        v.add(carry % 10);
        carry /= 10;
    }
}
 
// Returns sum of digits in n!
static int findSumOfDigits(int n)
{
    v.add(1); // adds 1 to the end
 
    // One by one multiply i to current vector
    // and update the vector.
    for (int i=1; i<=n; i++)
        multiply(i);
 
    // Find sum of digits in vector v[]
    int sum = 0;
    int size = v.size();
    for (int i = 0 ; i < size ; i++)
        sum += v.get(i);
    return sum;
}
 
// Driver code
public static void main(String[] args)
{
    int n = 1000;
    System.out.println(findSumOfDigits(n));
}
}
// this code is contributed by mits


Python 3




# Python 3 program to find sum of digits
# in factorial of a number
 
# Function to multiply x with large number
# stored in vector v. Result is stored in v.
def multiply(v, x):
    carry = 0
    size = len(v)
    for i in range(size):
         
        # Calculate res + prev carry
        res = carry + v[i] * x
 
        # updation at ith position
        v[i] = res % 10
        carry = res // 10
 
    while (carry != 0):
        v.append(carry % 10)
        carry //= 10
 
# Returns sum of digits in n!
def findSumOfDigits( n):
    v = []     # create a vector of type int
    v.append(1) # adds 1 to the end
 
    # One by one multiply i to current
    # vector and update the vector.
    for i in range(1, n + 1):
        multiply(v, i)
 
    # Find sum of digits in vector v[]
    sum = 0
    size = len(v)
    for i in range(size):
        sum += v[i]
    return sum
 
# Driver code
if __name__ == "__main__":
     
    n = 1000
    print(findSumOfDigits(n))
 
# This code is contributed by ita_c


C#




// C# program to find sum of digits in factorial
// of a number
using System;
using System.Collections;
class GFG{
// Function to multiply x with large number
// stored in vector v. Result is stored in v.
static ArrayList v=new ArrayList();
static void multiply(int x)
{
    int carry = 0;
    int size = v.Count;
    for (int i = 0 ; i < size ; i++)
    {
        // Calculate res + prev carry
        int res = carry + (int)v[i] * x;
 
        // updation at ith position
        v[i] = res % 10;
        carry = res / 10;
    }
    while (carry != 0)
    {
        v.Add(carry % 10);
        carry /= 10;
    }
}
 
// Returns sum of digits in n!
static int findSumOfDigits(int n)
{
    v.Add(1); // adds 1 to the end
 
    // One by one multiply i to current vector
    // and update the vector.
    for (int i=1; i<=n; i++)
        multiply(i);
 
    // Find sum of digits in vector v[]
    int sum = 0;
    int size = v.Count;
    for (int i = 0 ; i < size ; i++)
        sum += (int)v[i];
    return sum;
}
 
// Driver code
static void Main()
{
    int n = 1000;
    Console.WriteLine(findSumOfDigits(n));
}
}
// this code is contributed by mits


Javascript




<script>
// Javascript program to find sum of digits in factorial
// of a number
     
    // Function to multiply x with large number
    // stored in vector v. Result is stored in v.
    let v=[];
    function multiply(x)
    {
        let carry = 0;
    let size = v.length;
    for (let i = 0 ; i < size ; i++)
    {
        // Calculate res + prev carry
        let res = carry + v[i] * x;
   
        // updation at ith position
        v[i]=res % 10;
        carry = Math.floor(res / 10);
    }
    while (carry != 0)
    {
        v.push(carry % 10);
        carry = Math.floor(carry/10);
    }
    }
     
    // Returns sum of digits in n!
    function findSumOfDigits(n)
    {
        v.push(1); // adds 1 to the end
   
    // One by one multiply i to current vector
    // and update the vector.
    for (let i=1; i<=n; i++)
        multiply(i);
   
    // Find sum of digits in vector v[]
    let sum = 0;
    let size = v.length;
    for (let i = 0 ; i < size ; i++)
        sum += v[i];
    return sum;
    }
     
    // Driver code
    let n = 1000;
    document.write(findSumOfDigits(n));
     
     
    // This code is contributed by avanitrachhadiya2155
</script>


PHP




<?php
// PHP program to find sum of digits in
// factorial of a number
 
// Function to multiply x with large number
// stored in vector v. Result is stored in v.
function multiply(&$v, $x)
{
    $carry = 0;
    $size = count($v);
    for ($i = 0 ; $i < $size ; $i++)
    {
        // Calculate res + prev carry
        $res = $carry + $v[$i] * $x;
 
        // updation at ith position
        $v[$i] = $res % 10;
        $carry = (int)($res / 10);
    }
    while ($carry != 0)
    {
        array_push($v, $carry % 10);
        $carry = (int)($carry / 10);
    }
}
 
// Returns sum of digits in n!
function findSumOfDigits($n)
{
    $v = array(); // create a vector of type int
    array_push($v, 1); // adds 1 to the end
 
    // One by one multiply i to current vector
    // and update the vector.
    for ($i = 1; $i <= $n; $i++)
        multiply($v, $i);
 
    // Find sum of digits in vector v[]
    $sum = 0;
    $size = count($v);
    for ($i = 0 ; $i < $size ; $i++)
        $sum += $v[$i];
    return $sum;
}
 
// Driver code
$n = 1000;
print(findSumOfDigits($n));
 
// This code is contributed by mits
?>


Output

10539




Time complexity: O(n^2) since using multiple loops
Auxiliary space: O(n) because it is using space for vector v

Approach#2: Using for loop

This approach calculates the factorial of the given number using a loop and then finds the sum of its digits by converting the factorial to a string and iterating through each character to add the digit to a running total. 

Algorithm

1. Compute the factorial of the given number using any of the previous approaches.
2. Convert the factorial to a string.
3. Traverse through each character in the string and convert it to an integer and add it to the sum variable.
4. Return the sum.

C++




// CPP program for the above approach
#include <iostream>
#include <string>
#include <vector>
 
class GFG {
public:
    static int sumOfDigitsFactorial(int n)
    {
        // Initialize factorial as 1
        std::vector<int> fact{ 1 };
 
        // Compute the factorial of a given number.
        for (int i = 2; i <= n; ++i) {
            multiply(fact, i);
        }
 
        // Set the sum of digits as zero.
        int sumOfDigits = 0;
        for (int digit : fact) {
            sumOfDigits += digit;
        }
 
        return sumOfDigits;
    }
 
    // Function to multiply the factorial with a number.
    static void multiply(std::vector<int>& num, int x)
    {
        int carry = 0;
 
        for (int i = 0; i < num.size() || carry; ++i) {
            if (i == num.size()) {
                num.push_back(0);
            }
 
            long long product
                = (long long)num[i] * x + carry;
            num[i] = product % 10;
            carry = product / 10;
        }
    }
};
 
// Example usage
int main()
{
    std::cout << "Sum of digits factorial for n=10: "
              << GFG::sumOfDigitsFactorial(10) << std::endl;
    std::cout << "Sum of digits factorial for n=100: "
              << GFG::sumOfDigitsFactorial(100)
              << std::endl;
    return 0;
}
 
// This code is contributed by Susobhan Akhuli


Java




// Java program for the above approach
import java.math.BigInteger;
 
public class GFG {
 
    public static int sumOfDigitsFactorial(int n)
    {
        // Declare a variable fact as BigInteger.
        BigInteger fact = BigInteger.ONE;
 
        // Compute the factorial of a given number.
        for (BigInteger i = BigInteger.valueOf(2);
             i.compareTo(BigInteger.valueOf(n)) <= 0;
             i = i.add(BigInteger.ONE)) {
            fact = fact.multiply(i);
        }
 
        // Set the sum of digits as zero.
        int sumOfDigits = 0;
        for (char digit : fact.toString().toCharArray()) {
            sumOfDigits += Character.getNumericValue(digit);
        }
 
        return sumOfDigits;
    }
 
    // Example usage
    public static void main(String[] args)
    {
        System.out.println(
            "Sum of digits factorial for n=10: "
            + sumOfDigitsFactorial(10));
        System.out.println(
            "Sum of digits factorial for n=100: "
            + sumOfDigitsFactorial(100));
    }
}
 
// This code is contributed by Susobhan Akhuli


Python3




def sum_of_digits_factorial(n):
    fact = 1
    for i in range(2, n+1):
        fact *= i
    sum_of_digits = 0
    for digit in str(fact):
        sum_of_digits += int(digit)
    return sum_of_digits
 
# Example usage
print(sum_of_digits_factorial(10))
print(sum_of_digits_factorial(100))


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG {
    public static int SumOfDigitsFactorial(int n)
    {
        // Initialize factorial as 1
        List<int> fact = new List<int>{ 1 };
 
        // Compute the factorial of a given number.
        for (int i = 2; i <= n; ++i) {
            Multiply(fact, i);
        }
 
        // Set the sum of digits as zero.
        int sumOfDigits = 0;
        foreach(int digit in fact) { sumOfDigits += digit; }
 
        return sumOfDigits;
    }
 
    // Function to multiply the factorial with a number.
    public static void Multiply(List<int> num, int x)
    {
        int carry = 0;
 
        for (int i = 0; i < num.Count || carry != 0; ++i) {
            if (i == num.Count) {
                num.Add(0);
            }
 
            long product = (long)num[i] * x + carry;
            num[i] = (int)(product % 10);
            carry = (int)(product / 10);
        }
    }
 
    // Example usage
    static void Main()
    {
        Console.WriteLine(
            "Sum of digits factorial for n=10: "
            + SumOfDigitsFactorial(10));
        Console.WriteLine(
            "Sum of digits factorial for n=100: "
            + SumOfDigitsFactorial(100));
    }
}
 
// This code is contributed by Susobhan Akhuli


Javascript




// Javascript code addition
 
function sum_of_digits_factorial(n) {
     
  // declaring a variable fact as bigInt.
  let fact = BigInt(1);
     
  // compute the factorial of a given number.
  for (let i = 2n; i <= BigInt(n); i++) {
    fact *= i;
  }
      
  // set sum of digits as zero.
  let sum_of_digits = 0;
  for (const digit of fact.toString()) {
    sum_of_digits += parseInt(digit);
  }
  return sum_of_digits;
}
 
// Example usage
console.log(sum_of_digits_factorial(10));
console.log(sum_of_digits_factorial(100));
 
// The code is contributed by Arushi Goel.


Output

Sum of digits factorial for n=10: 27
Sum of digits factorial for n=100: 648


Time complexity: O(n)), where n is the given number
Auxiliary Space: O(1)



Last Updated : 26 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads