Count digits in a factorial

Given an integer n, find the number of digits that appear in its factorial, where factorial is defined as, factorial(n) = 1*2*3*4........*n and factorial(0) = 1

Examples : 

Input:  5
Output: 3
Explanation: 5! = 120, i.e., 3 digits

Input: 10
Output: 7
Explanation: 10! = 3628800, i.e., 7 digits

[Naive approach] Calculate factorial of Number - O(n) Time and O(1) Space:

A naive solution would be to calculate the n! first and then calculate the number of digits present in it. However as the value for n! can be very large, it would become cumbersome to store them in a variable .

[Better approach] Using logarithmic property

To solve the problem follow the below idea:

We know,
log(a*b) = log(a) + log(b)

Therefore
log( n! ) = log(1*2*3....... * n) = log(1) + log(2) + ........ +log(n)

Now, observe that the floor value of log base 10 increased by 1, of any number, gives the number of digits present in that number. Hence, output would be : floor(log(n!)) + 1.

#include <iostream>
#include <cmath>

using namespace std;
 
int digitsInFactorial(int n) {
    
    // factorial exists only for n>=0
    if (n < 0)
        return 0;

    // base case
    if (n <= 1)
        return 1;

    // else iterate through n and calculate the
    // value
    double digits = 0;
    for (int i = 2; i <= n; i++)
        digits += log10(i);

    return floor(digits) + 1;
}

int main()
{
    cout << digitsInFactorial(120) << endl;
    return 0;
}

class GFG {
    static int digitsInFactorial(int n)
    {
        // factorial exists only for n>=0
        if (n < 0)
            return 0;

        // base case
        if (n <= 1)
            return 1;

        // else iterate through n and calculate the
        // value
        double digits = 0;
        for (int i = 2; i <= n; i++)
            digits += Math.log10(i);

        return (int)(Math.floor(digits)) + 1;
    }

    public static void main(String[] args)
    {

        System.out.println(digitsInFactorial(120));
    }
}

import math

def digitsInFactorial(n):

    # factorial exists only for n>=0
    if (n < 0):
        return 0

    # base case
    if (n <= 1):
        return 1

    # else iterate through n and
    # calculate the value
    digits = 0
    for i in range(2, n + 1):
        digits += math.log10(i)

    return math.floor(digits) + 1

if __name__ == "__main__":
  print(digitsInFactorial(120))

using System;
class GFG {

    static int digitsInFactorial(int n)
    {

        // factorial exists only for n>=0
        if (n < 0)
            return 0;

        // base case
        if (n <= 1)
            return 1;

        // else iterate through n and
        // calculate the value
        double digits = 0;
        for (int i = 2; i <= n; i++)
            digits += Math.Log10(i);

        return (int)Math.Floor(digits) + 1;
    }

    public static void Main()
    {
        Console.Write(digitsInFactorial(120) + "\n");
    }
}

function digitsInFactorial(n) 
{ 
    // factorial exists only for n>=0 
    if (n < 0) 
        return 0; 

    // base case 
    if (n <= 1) 
        return 1; 

    // else iterate through n and calculate the 
    // value 
    let digits = 0; 
    for (let i=2; i<=n; i++) 
        digits += Math.log10(i); 

    return Math.floor(digits) + 1; 
} 

// Driver code 
console.log(digitsInFactorial(120)); 

<?php
function digitsInFactorial($n)
{
    // factorial exists only for n>=0
    if ($n < 0)
        return 0;

    // base case
    if ($n <= 1)
        return 1;

    // else iterate through n and 
    // calculate the value
    $digits = 0;
    for ($i = 2; $i <= $n; $i++)
        $digits += log10($i);

    return floor($digits) + 1;
}

// Driver code
echo digitsInFactorial(120), "\n";

?>

199

Time complexity: O(n log n) since calculating log in a loop
Auxiliary space: O(1) because it is using constant variables

[Best Approach] Using Stirling's approximation formula

1. The countDigitsInFactorial(int n) function takes an integer n as input and returns the number of digits in the factorial of n. If n is negative, it returns 0. If n is 0 or 1, the factorial is 1, and it returns 1.
2. In the countDigitsInFactorial(int n) function, the double x variable is declared and initialized using the Stirling's approximation formula for the factorial. This formula provides a good approximation of the value of the factorial for large values of n. 
3. where M_E is the mathematical constant Euler number e, and M_PI is the mathematical constant \pi.
4. The formula used in this code is a simplified version of Stirling's approximation that takes the logarithm of the above formula to get the number of digits in the factorial. 

#include <cmath>
#include <iostream>
using namespace std;

int digitsInFactorial(int n)
{
    // factorial exists only for n>=0
    if (n < 0)
    {
        return 0;
    }
    if (n <= 1)
    {
        return 1;
    }
    
     // Calculating the digit's values
    double x = (n * log10(n / M_E) + log10(2 * M_PI * n) / 2.0);
    
     // returning the floor value + 1
    return floor(x) + 1;
}

int main()
{
    cout << digitsInFactorial(120) << endl;

    return 0;
}

public class GFG {
    public static int digitsInFactorial(int n)
    {
        // factorial exists only for n>=0
        if (n < 0) {
            return 0;
        }
        if (n <= 1) {
            return 1;
        }
        // Calculating the digit's values
        double x = (n * Math.log10(n / Math.E)
                    + Math.log10(2 * Math.PI * n) / 2.0);
        // returning the floor value + 1
        return (int)Math.floor(x) + 1;
    }

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

import math
def digitsInFactorial(n):
    
    # factorial exists only for n>=0
    if n < 0:
        return 0
    if n <= 1:
        return 1

    #  // Calculating the digit's values
    x = (n * math.log10(n / math.e) + math.log10(2 * math.pi * n) / 2.0)

    # returning the floor value + 1
    return math.floor(x) + 1


# Testing the function with sample inputs
if __name__ == "__main__":
    print(digitsInFactorial(120))

using System;

public class GFG {
    static int digitsInFactorial(int n)
    {  
        // factorial exists only for n>=0
        if (n < 0) {
            return 0;
        }
        if (n <= 1) {
            return 1;
        }
        
         // Calculating the digit's values
        double x = (n * Math.Log10(n / Math.E)
                    + Math.Log10(2 * Math.PI * n) / 2.0);
                    
         // returning the floor value + 1            
        return (int)Math.Floor(x) + 1;
    }

    public static void Main()
    {
        Console.WriteLine(digitsInFactorial(120));
    }
}

function digitsInFactorial(n) {
    
    // factorial exists only for n>=0
    if (n < 0) {
        return 0;
    }
    
    if (n <= 1) {
        return 1;
    }
    
     // Calculating the digit's values
    let x = n * Math.log10(n / Math.E) + Math.log10(2 * Math.PI * n) / 2.0;
    
     // returning the floor value + 1
    return Math.floor(x) + 1;
}

// Driver Code
console.log(digitsInFactorial(120));

199

Time complexity: O(1)
The time complexity of the above approach to count the number of digits in n! using Stirling's approximation and logarithms is O(1), meaning it is constant time complexity.

Auxiliary space: O(1)
In the next set, we'd see how to further optimize our approach and reduce the time complexity for the same program.