Count trailing zeroes in factorial of a number - GeeksforGeeks

28 Oct, 2021
Given an integer n, write a function that returns count of trailing zeroes in n!. Examples : 
Input: n = 5
Output: 1 
Factorial of 5 is 120 which has one trailing 0.

Input: n = 20
Output: 4
Factorial of 20 is 2432902008176640000 which has
4 trailing zeroes.

Input: n = 100
Output: 24
Approach:A simple method is to first calculate factorial of n, then count trailing 0s in the result (We can count trailing 0s by repeatedly dividing the factorial by 10 till the remainder is 0). The above method can cause overflow for slightly bigger numbers as the factorial of a number is a big number (See factorial of 20 given in above examples). The idea is to consider prime factors of a factorial n. A trailing zero is always produced by prime factors 2 and 5. If we can count the number of 5s and 2s, our task is done. Consider the following examples.n = 5: There is one 5 and 3 2s in prime factors of 5! (2 * 2 * 2 * 3 * 5). So a count of trailing 0s is 1.n = 11: There are two 5s and eight 2s in prime factors of 11! (2 8 * 34 * 52 * 7). So the count of trailing 0s is 2. We can easily observe that the number of 2s in prime factors is always more than or equal to the number of 5s. So if we count 5s in prime factors, we are done. How to count the total number of 5s in prime factors of n!? A simple way is to calculate floor(n/5). For example, 7! has one 5, 10! has two 5s. It is not done yet, there is one more thing to consider. Numbers like 25, 125, etc have more than one 5. For example, if we consider 28! we get one extra 5 and the number of 0s becomes 6. Handling this is simple, first, divide n by 5 and remove all single 5s, then divide by 25 to remove extra 5s, and so on. Following is the summarized formula for counting trailing 0s.
Approach:A simple method is to first calculate factorial of n, then count trailing 0s in the result (We can count trailing 0s by repeatedly dividing the factorial by 10 till the remainder is 0). 
The above method can cause overflow for slightly bigger numbers as the factorial of a number is a big number (See factorial of 20 given in above examples). The idea is to consider prime factors of a factorial n. A trailing zero is always produced by prime factors 2 and 5. If we can count the number of 5s and 2s, our task is done. Consider the following examples.n = 5: There is one 5 and 3 2s in prime factors of 5! (2 * 2 * 2 * 3 * 5). So a count of trailing 0s is 1.n = 11: There are two 5s and eight 2s in prime factors of 11! (2 8 * 34 * 52 * 7). So the count of trailing 0s is 2. 
We can easily observe that the number of 2s in prime factors is always more than or equal to the number of 5s. So if we count 5s in prime factors, we are done. How to count the total number of 5s in prime factors of n!? A simple way is to calculate floor(n/5). For example, 7! has one 5, 10! has two 5s. It is not done yet, there is one more thing to consider. Numbers like 25, 125, etc have more than one 5. For example, if we consider 28! we get one extra 5 and the number of 0s becomes 6. Handling this is simple, first, divide n by 5 and remove all single 5s, then divide by 25 to remove extra 5s, and so on. Following is the summarized formula for counting trailing 0s.
Trailing 0s in n! = Count of 5s in prime factors of n!
                  = floor(n/5) + floor(n/25) + floor(n/125) + ....
Following is a program based on the above formula: 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to count// trailing 0s in n!#include <iostream>using namespace std; // Function to return trailing// 0s in factorial of nint findTrailingZeros(int n){    if (n < 0) // Negative Number Edge Case        return -1;     // Initialize result    int count = 0;     // Keep dividing n by powers of    // 5 and update count    for (int i = 5; n / i >= 1; i *= 5)        count += n / i;     return count;} // Driver Codeint main(){    int n = 100;    cout << "Count of trailing 0s in " << 100 << "! is "         << findTrailingZeros(n);    return 0;}
// Java program to count// trailing 0s in n!import java.io.*; class GFG {    // Function to return trailing    // 0s in factorial of n    static int findTrailingZeros(int n)    {        if (n < 0) // Negative Number Edge Case            return -1;         // Initialize result        int count = 0;         // Keep dividing n by powers        // of 5 and update count        for (int i = 5; n / i >= 1; i *= 5)            count += n / i;         return count;    }     // Driver Code    public static void main(String[] args)    {        int n = 100;        System.out.println("Count of trailing 0s in " + n                           + "! is "                           + findTrailingZeros(n));    }} // This code is contributed by Pramod Kumar
# Python3 program to# count trailing 0s# in n! # Function to return# trailing 0s in# factorial of n  def findTrailingZeros(n):    # Negative Number Edge Case    if(n < 0):        return -1     # Initialize result    count = 0     # Keep dividing n by    # 5 & update Count    while(n >= 5):        n //= 5        count += n     return count  # Driver programn = 100print("Count of trailing 0s " +      "in 100! is", findTrailingZeros(n)) # This code is contributed by Uttam Singh
// C# program to count// trailing 0s in n!using System; class GFG{         // Function to return trailing    // 0s in factorial of n    static int findTrailingZeros(int n)    {                 if(n < 0) //Negative Number Edge Case              return -1;                      // Initialize result        int count = 0;         // Keep dividing n by powers        // of 5 and update count        for (int i = 5; n / i >= 1; i *= 5)            count += n / i;         return count;    }         // Driver Code    public static void Main ()    {        int n = 100;        Console.WriteLine("Count of trailing 0s in " +                                           n +"! is "+                                findTrailingZeros(n));    }} // This code is contributed by vt_m
<?php// PHP program to count// trailing 0s in n! // Function to return trailing// 0s in factorial of nfunction findTrailingZeros( $n){         if($n < 0) //Negative Number Edge Case      return -1;          // Initialize result    $count = 0;     // Keep dividing n by powers    // of 5 and update count    for ($i = 5; $n / $i >= 1; $i *= 5)        $count += $n / $i;     return $count;} // Driver Code $n = 100;echo "Count of trailing 0s in " , 100,     "! is " , findTrailingZeros($n); // This code is contributed by vt_m?>
<script> // JavaScript program to count// trailing 0s in n! // Function to return trailing// 0s in factorial of nfunction findTrailingZeros(n){     if(n < 0) //Negative Number Edge Case      return -1;         // Initialize result    let count = 0;     // Keep dividing n by powers of    // 5 and update count    for (let i = 5; Math.floor(n / i) >= 1; i *= 5)        count += Math.floor(n / i);     return count;} // Driver Code    let n = 100;    document.write("Count of trailing 0s in " + 100        + "! is " + findTrailingZeros(n)); // This code is contributed by Surbhi Tyagi </script>
Output : 
Count of trailing 0s in 100! is 24 
Time Complexity: O(log5n)
Auxiliary Space: O(1)
This article is contributed by Rahul Jain. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Raju Yadav
vt_m
Rishi_Mohan
uttam_singh
surbhityagi15
anujk2901
subhammahato348
factorial
MakeMyTrip
Mathematical
MakeMyTrip
Mathematical
factorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Merge two sorted arrays
Prime Numbers
Modulo Operator (%) in C/C++ with Examples
Sieve of Eratosthenes
Program for Decimal to Binary Conversion
Find all factors of a natural number | Set 1
Program to find sum of elements in a given array
The Knight's tour problem | Backtracking-1
Operators in C / C++
Minimum number of jumps to reach end