> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0172-factorial-trailing-zeroes.md).

# 0172. Factorial Trailing Zeroes

<https://leetcode.com/problems/factorial-trailing-zeroes>

## Description

Given an integer `n`, return *the number of trailing zeroes in* `n!`.

Note that `n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1`.

**Example 1:**

```
**Input:** n = 3
**Output:** 0
**Explanation:** 3! = 6, no trailing zero.
```

**Example 2:**

```
**Input:** n = 5
**Output:** 1
**Explanation:** 5! = 120, one trailing zero.
```

**Example 3:**

```
**Input:** n = 0
**Output:** 0
```

**Constraints:**

* `0 <= n <= 104`

**Follow up:** Could you write a solution that works in logarithmic time complexity?

## ac

```java
class Solution {
    public int trailingZeroes(int n) {
        int res = 0;
        while (n >= 5) {
            n /= 5;
            res += n;
        }
        return res;
    }
}
/*
tailing 0s result from 2 * 5, so counting them.
2 is ample, almost n / 2. so just count 5.
n! = 5 * 10 * 15 * 25 * 30 ...
some have one '5', some have two '5'.
n / 5 : count those have one '5'
n / 5 / 5 : count those have two '5'
.
.
.
so, that is: n /= 5; res += n;

*/
```