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++ 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 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 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# 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 |
<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 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 ?> |
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.
// 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 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 |
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# 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 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. |
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)