Given an integer **n**, the task is to find the number of trailing zeros in the function i.e. **f(n) = 1 ^{1} * 2^{2} * 3^{3} * … * n^{n}**.

**Examples:**

Input:n = 5

Output:5

f(5) = 1^{1}* 2^{2}* 3^{3}* 4^{4}* 5^{5}= 1 * 4 * 27 * 256 * 3125 = 86400000

Input:n = 12

Output:15

**Approach:** We know that **5 * 2 = 10** i.e. 1 trailing zero is the result of the multiplication of a single 5 and a single 2. So, if we have **x** number of **5** and **y** number of **2** then the number of trailing zeros will be **min(x, y)**.

Now, for every number **i** in the series, we need to count the number of **2** and **5** in its factors say **x** and **y** but the number of **2s** and **5s** will be **x * i** and **y * i** respectively because in the series **i** is raised to the power itself i.e. **i ^{i}**. Count the number of

**2s**and

**5s**in the complete series and print the minimum of them which is the required answer.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the number of ` `// trailing zeros ` `int` `trailing_zeros(` `int` `N) ` `{ ` ` ` ` ` `// To store the number of 2s and 5s ` ` ` `int` `count_of_two = 0, count_of_five = 0; ` ` ` ` ` `for` `(` `int` `i = 1; i <= N; i++) { ` ` ` ` ` `int` `val = i; ` ` ` ` ` `while` `(val % 2 == 0 && val > 0) { ` ` ` `val /= 2; ` ` ` ` ` `// If we get a factor 2 then we ` ` ` `// have i number of 2s because ` ` ` `// the power of the number is ` ` ` `// raised to i ` ` ` `count_of_two += i; ` ` ` `} ` ` ` ` ` `while` `(val % 5 == 0 && val > 0) { ` ` ` `val /= 5; ` ` ` ` ` `// If we get a factor 5 then ` ` ` `// we have i number of 5s ` ` ` `// because the power of the ` ` ` `// number is raised to i ` ` ` `count_of_five += i; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Take the minimum of them ` ` ` `int` `ans = min(count_of_two, count_of_five); ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `N = 12; ` ` ` ` ` `cout << trailing_zeros(N); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` ` ` `class` `GFG ` `{ ` ` ` `// Function to return the number of ` `// trailing zeros ` `static` `int` `trailing_zeros(` `int` `N) ` `{ ` ` ` ` ` `// To store the number of 2s and 5s ` ` ` `int` `count_of_two = ` `0` `, count_of_five = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `1` `; i <= N; i++) ` ` ` `{ ` ` ` `int` `val = i; ` ` ` `while` `(val % ` `2` `== ` `0` `&& val > ` `0` `) ` ` ` `{ ` ` ` `val /= ` `2` `; ` ` ` ` ` `// If we get a factor 2 then we ` ` ` `// have i number of 2s because ` ` ` `// the power of the number is ` ` ` `// raised to i ` ` ` `count_of_two += i; ` ` ` `} ` ` ` ` ` `while` `(val % ` `5` `== ` `0` `&& val > ` `0` `) ` ` ` `{ ` ` ` `val /= ` `5` `; ` ` ` ` ` `// If we get a factor 5 then ` ` ` `// we have i number of 5s ` ` ` `// because the power of the ` ` ` `// number is raised to i ` ` ` `count_of_five += i; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Take the minimum of them ` ` ` `int` `ans = Math.min(count_of_two, count_of_five); ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main (String[] args) ` `{ ` ` ` `int` `N = ` `12` `; ` ` ` `System.out.println(trailing_zeros(N)); ` `} ` `} ` ` ` `// This code is contributed by chandan_jnu ` |

*chevron_right*

*filter_none*

## Python3

`# Python 3 implementation of the approach ` ` ` `# Function to return the number of ` `# trailing zeros ` `def` `trailing_zeros(N): ` ` ` ` ` `# To store the number of 2s and 5s ` ` ` `count_of_two ` `=` `0` ` ` `count_of_five ` `=` `0` ` ` ` ` `for` `i ` `in` `range` `(` `1` `, N ` `+` `1` `, ` `1` `): ` ` ` `val ` `=` `i ` ` ` ` ` `while` `(val ` `%` `2` `=` `=` `0` `and` `val > ` `0` `): ` ` ` `val ` `/` `=` `2` ` ` ` ` `# If we get a factor 2 then we ` ` ` `# have i number of 2s because ` ` ` `# the power of the number is ` ` ` `# raised to i ` ` ` `count_of_two ` `+` `=` `i ` ` ` ` ` `while` `(val ` `%` `5` `=` `=` `0` `and` `val > ` `0` `): ` ` ` `val ` `/` `=` `5` ` ` ` ` `# If we get a factor 5 then we ` ` ` `# have i number of 5s because ` ` ` `# the power of the number is ` ` ` `# raised to i ` ` ` `count_of_five ` `+` `=` `i ` ` ` ` ` `# Take the minimum of them ` ` ` `ans ` `=` `min` `(count_of_two, count_of_five) ` ` ` ` ` `return` `ans ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` `N ` `=` `12` ` ` ` ` `print` `(trailing_zeros(N)) ` ` ` `# This code is contributed by ` `# Sanjit_Prasad ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the above approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `// Function to return the number of ` ` ` `// trailing zeros ` ` ` `static` `int` `trailing_zeros(` `int` `N) ` ` ` `{ ` ` ` ` ` `// To store the number of 2s and 5s ` ` ` `int` `count_of_two = 0, count_of_five = 0; ` ` ` ` ` `for` `(` `int` `i = 1; i <= N; i++) ` ` ` `{ ` ` ` `int` `val = i; ` ` ` `while` `(val % 2 == 0 && val > 0) ` ` ` `{ ` ` ` `val /= 2; ` ` ` ` ` `// If we get a factor 2 then we ` ` ` `// have i number of 2s because ` ` ` `// the power of the number is ` ` ` `// raised to i ` ` ` `count_of_two += i; ` ` ` `} ` ` ` ` ` `while` `(val % 5 == 0 && val > 0) ` ` ` `{ ` ` ` `val /= 5; ` ` ` ` ` `// If we get a factor 5 then ` ` ` `// we have i number of 5s ` ` ` `// because the power of the ` ` ` `// number is raised to i ` ` ` `count_of_five += i; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Take the minimum of them ` ` ` `int` `ans = Math.Min(count_of_two, count_of_five); ` ` ` ` ` `return` `ans; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `N = 12; ` ` ` `Console.WriteLine(trailing_zeros(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Ryuga ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP implementation of the approach ` ` ` `// Function to return the number of ` `// trailing zeros ` `function` `trailing_zeros(` `$N` `) ` `{ ` ` ` ` ` `// To store the number of 2s and 5s ` ` ` `$count_of_two` `= 0; ` ` ` `$count_of_five` `= 0; ` ` ` ` ` `for` `(` `$i` `= 1; ` `$i` `<= ` `$N` `; ` `$i` `++) ` ` ` `{ ` ` ` `$val` `= ` `$i` `; ` ` ` ` ` `while` `(` `$val` `% 2 == 0 && ` `$val` `> 0) ` ` ` `{ ` ` ` `$val` `/= 2; ` ` ` ` ` `// If we get a factor 2 then we ` ` ` `// have i number of 2s because ` ` ` `// the power of the number is ` ` ` `// raised to i ` ` ` `$count_of_two` `+= ` `$i` `; ` ` ` `} ` ` ` ` ` `while` `(` `$val` `% 5 == 0 && ` `$val` `> 0) ` ` ` `{ ` ` ` `$val` `/= 5; ` ` ` ` ` `// If we get a factor 5 then ` ` ` `// we have i number of 5s ` ` ` `// because the power of the ` ` ` `// number is raised to i ` ` ` `$count_of_five` `+= ` `$i` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Take the minimum of them ` ` ` `$ans` `= min(` `$count_of_two` `, ` `$count_of_five` `); ` ` ` ` ` `return` `$ans` `; ` `} ` ` ` `// Driver code ` `$N` `= 12; ` `echo` `trailing_zeros(` `$N` `); ` ` ` `// This code is contributed by ita_c ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

15

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.