Preimage Size of Factorial Zeroes Function

Preimage Size of Factorial Zeroes Function - Problem

Preimage Size of Factorial Zeroes Function

Imagine you're working as a mathematician analyzing factorial patterns. Your task is to understand the relationship between factorials and their trailing zeroes.

Given a function f(x) that counts the number of trailing zeroes in x! (x factorial), you need to find how many non-negative integers x produce exactly k trailing zeroes.

Key Insights:
• f(3) = 0 because 3! = 6 (no trailing zeroes)
• f(11) = 2 because 11! = 39916800 (two trailing zeroes)
• Trailing zeroes come from factors of 10, which means pairs of 2 and 5
• Since there are always more factors of 2 than 5, we only need to count factors of 5

The Challenge: For a given k, determine how many values of x satisfy f(x) = k. This is asking for the preimage size of the function f.

Input & Output

example_1.py — Basic case

$ Input: k = 3

› Output: 5

💡 Note: f(x) = 3 for x = 15, 16, 17, 18, 19. These are the only values where x! has exactly 3 trailing zeroes, so the answer is 5.

example_2.py — Edge case

$ Input: k = 0

› Output: 5

💡 Note: f(x) = 0 for x = 0, 1, 2, 3, 4. For x ≥ 5, x! will have at least one factor of 5, creating at least one trailing zero.

example_3.py — Impossible case

$ Input: k = 1000000000

› Output: 5

💡 Note: Even for very large k, if it's achievable by some factorial, there will be exactly 5 consecutive values of x that produce k trailing zeroes.

Constraints

0 ≤ k ≤ 10⁹
The answer will always be either 0 or 5
x must be a non-negative integer

Visualization

Tap to expand

Understanding the Visualization

Trailing zeros come from factors of 10

Each trailing zero needs one factor of 2 and one factor of 5

Factors of 2 are abundant

In any factorial, there are always more factors of 2 than 5

Count factors of 5

f(x) = floor(x/5) + floor(x/25) + floor(x/125) + ...

Function is non-decreasing

As x increases, f(x) never decreases

Gaps create impossible values

Some k values are impossible (like k=5), others have exactly 5 solutions

Key Takeaway

🎯 Key Insight: The preimage size is always 0 or 5 because f(x) increases in predictable steps, and binary search can efficiently find the boundaries of these steps.

Asked in

G Google 15 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses binary search to efficiently find the range of x values where f(x) = k. The key insight is that f(x) is non-decreasing and the answer is always either 0 or 5 due to the mathematical properties of factorials and factors of 5.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log²(k))	O(1)	Use binary search to find the range of x values where f(x) = k
Brute Force (Linear Search)	O(k * 5^k)	O(1)	Check each x from 0 upward until we find all x where f(x) = k

Binary Search (Optimal) — Algorithm Steps

Implement helper function to count trailing zeros in n!
Use binary search to find the leftmost x where f(x) = k
Use binary search to find the rightmost x where f(x) = k
If no such x exists, return 0
Otherwise, return (rightmost - leftmost + 1)
Optimization: The answer is always 0 or 5 due to mathematical properties

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search bounds

Initialize left=0, right=5k (upper bound for search)

Binary search for first

Find leftmost x where f(x) >= k

Verify existence

Check if f(first_x) actually equals k

Binary search for last

Find rightmost x where f(x) <= k

Calculate range

Return last - first + 1 (always 0 or 5)

Code -

solution.c — C

#include <stdio.h>

int trailingZeros(long long n) {
    int count = 0;
    while (n >= 5) {
        n /= 5;
        count += n;
    }
    return count;
}

long long findFirstX(int k) {
    long long left = 0, right = 5LL * k;
    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (trailingZeros(mid) < k) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

long long findLastX(int k) {
    long long left = 0, right = 5LL * k;
    while (left < right) {
        long long mid = left + (right - left + 1) / 2;
        if (trailingZeros(mid) <= k) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    return left;
}

int preimageSizeFZF(int k) {
    long long first = findFirstX(k);
    if (trailingZeros(first) != k) {
        return 0;
    }
    
    long long last = findLastX(k);
    return (int)(last - first + 1);
}

int main() {
    int k;
    scanf("%d", &k);
    printf("%d\n", preimageSizeFZF(k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log²(k))

Two binary searches, each taking O(log(5k)) iterations, and each f(x) calculation takes O(log(x)) = O(log(k)) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

22.4K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler