Abbreviating the Product of a Range - Problem

Math Hard

You are given two positive integers left and right with left <= right. Calculate the product of all integers in the inclusive range [left, right].

Since the product may be very large, you will abbreviate it following these steps:

Count all trailing zeros in the product and remove them. Let us denote this count as C.
Denote the remaining number of digits in the product as d. If d > 10, then express the product as <pre>...<suf> where <pre> denotes the first 5 digits of the product, and <suf> denotes the last 5 digits of the product after removing all trailing zeros. If d <= 10, we keep it unchanged.
Finally, represent the product as a string "<pre>...<suf>eC".

Return a string denoting the abbreviated product of all integers in the inclusive range [left, right].

Input & Output

Example 1 — Small Range

$ Input: left = 1, right = 4

› Output: 24e0

💡 Note: Product is 1×2×3×4 = 24. No trailing zeros. Since 24 has 2 digits (≤ 10), return "24e0".

Example 2 — With Trailing Zeros

$ Input: left = 2, right = 5

› Output: 12e1

💡 Note: Product is 2×3×4×5 = 120. Remove 1 trailing zero → 12. Since 12 has 2 digits (≤ 10), return "12e1".

Example 3 — Large Range

$ Input: left = 1, right = 18

› Output: 64023...05728e3

💡 Note: Product is 18! = 6402373705728000. Remove 3 trailing zeros → 6402373705728. Since this has 13 digits (>10), return first 5 digits + '...' + last 5 digits + 'e3'.

Constraints

1 ≤ left ≤ right ≤ 10⁴
The product can be extremely large

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38

The key insight is to handle trailing zeros and significant digits separately using logarithms and modular arithmetic to avoid integer overflow. The optimized approach counts factors of 2 and 5 for trailing zeros, uses log₁₀ for first digits, and modular arithmetic for last digits. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Multiplication

⏱️ Time: O(n) Space: O(1)

Calculate the product by multiplying all numbers in the range, then count trailing zeros and format according to the rules. This approach works for small ranges but fails for large ranges due to overflow.

Logarithmic Approach

⏱️ Time: O(n) Space: O(1)

Count trailing zeros by counting factors of 2 and 5 separately. Use logarithms to compute the first and last 5 digits without calculating the full product, avoiding overflow issues.

Brute Force Multiplication — Algorithm Steps

Step 1: Multiply all numbers in range [left, right]
Step 2: Count and remove trailing zeros
Step 3: Format based on digit count rules

Visualization

Tap to expand

Step-by-Step Walkthrough

Multiply Range

Calculate product of all numbers

Remove Zeros

Count and remove trailing zeros

Format Result

Apply abbreviation rules

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(int left, int right) {
    if (left > right) {
        char* result = malloc(10);
        strcpy(result, "1e0");
        return result;
    }
    
    // Count factors of 2 and 5 to determine trailing zeros
    int factors_2 = 0;
    int factors_5 = 0;
    
    // Calculate product while extracting factors of 2 and 5
    long long product = 1;
    for (int i = left; i <= right; i++) {
        int num = i;
        // Extract factors of 2
        while (num % 2 == 0) {
            factors_2++;
            num /= 2;
        }
        // Extract factors of 5
        while (num % 5 == 0) {
            factors_5++;
            num /= 5;
        }
        // Multiply by remaining number
        product *= num;
    }
    
    // Number of trailing zeros
    int trailing_zeros = (factors_2 < factors_5) ? factors_2 : factors_5;
    
    // Apply remaining factors of 2 and 5
    int remaining_2 = factors_2 - trailing_zeros;
    int remaining_5 = factors_5 - trailing_zeros;
    
    for (int i = 0; i < remaining_2; i++) {
        product *= 2;
    }
    for (int i = 0; i < remaining_5; i++) {
        product *= 5;
    }
    
    // Convert to string for formatting
    char productStr[100];
    sprintf(productStr, "%lld", product);
    
    // Format based on length
    int len = strlen(productStr);
    char* result = malloc(100);
    
    if (len <= 10) {
        sprintf(result, "%se%d", productStr, trailing_zeros);
    } else {
        char prefix[6], suffix[6];
        strncpy(prefix, productStr, 5);
        prefix[5] = '\0';
        strcpy(suffix, productStr + len - 5);
        sprintf(result, "%s...%se%d", prefix, suffix, trailing_zeros);
    }
    
    return result;
}

int main() {
    int left, right;
    scanf("%d", &left);
    scanf("%d", &right);
    
    char* result = solution(left, right);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n numbers in the range

✓ Linear Growth

Space Complexity

O(1)

Only storing the product value and formatting variables

✓ Linear Space

29.0K Views

Medium Frequency

~35 min Avg. Time

892 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

Abbreviating the Product of a Range - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Multiplication — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler