Minimum Factorization - Practice Coding Problems

Minimum Factorization - Problem

Math Greedy Medium

The Digital Factorization Challenge

Given a positive integer num, your mission is to find the smallest positive integer whose digits, when multiplied together, equal num.

The Goal: Find the minimum number x such that the product of all digits in x equals num.

Special Cases:
• If no such number exists, return 0
• If the answer exceeds 32-bit signed integer limits, return 0

Example: For num = 48, we need digits that multiply to 48. We could use 6×8=48, giving us 68. But we could also use 4×3×4=48, giving us 344. Since 68 < 344, the answer is 68.

Input & Output

example_1.py — Basic Case

$ Input: num = 48

› Output: 68

💡 Note: We need digits whose product is 48. We can factor 48 = 8 × 6. Arranging in ascending order gives us 68, which is the smallest such number.

example_2.py — Single Digit

$ Input: num = 18

› Output: 29

💡 Note: 18 = 9 × 2, so we use digits [9, 2]. Arranging in ascending order gives us 29.

example_3.py — Impossible Case

$ Input: num = 13

› Output: 0

💡 Note: 13 is prime and > 9, so it cannot be expressed as a product of single digits 2-9. Return 0.

Constraints

1 ≤ num ≤ 10⁸
Return 0 if no solution exists
Return 0 if result exceeds 32-bit signed integer limit (2³¹ - 1)

Visualization

Tap to expand

Understanding the Visualization

Factor with 9

Try to divide by 9 as many times as possible

Factor with 8

Then try 8, then 7, etc. down to 2

Check remainder

If remainder > 1, impossible to factorize

Sort digits

Arrange collected digits in ascending order

Form result

Build the final number and check 32-bit limit

Key Takeaway

🎯 Key Insight: Greedily factor with largest possible digits first, then arrange optimally for the minimum result

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 5

The optimal solution uses a greedy factorization approach in O(log num) time. Factor the number using digits 9 down to 2, then arrange the collected digits in ascending order to form the smallest possible number. Handle edge cases where factorization is impossible or result exceeds 32-bit limits.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Factorization (Optimal)	O(log num)	O(log num)	Factor the number using digits 9 down to 2, then arrange digits in ascending order
Brute Force (Try All Numbers)	O(result × log(result))	O(1)	Try every number starting from 1 until we find one whose digit product equals num

Greedy Factorization (Optimal) — Algorithm Steps

Handle special case: if num ≤ 1, return num
Initialize empty list to store digits
For each digit from 9 down to 2:
While num is divisible by digit, divide num by digit and add digit to list
If num > 1 after factorization, return 0 (impossible)
Sort collected digits in ascending order
Form the result number and check 32-bit limit

Visualization

Tap to expand

Step-by-Step Walkthrough

Try digit 9

Check if 48 is divisible by 9. Not divisible, skip.

Try digit 8

48 ÷ 8 = 6. Add 8 to digits. Remaining: 6

Try digit 7

6 not divisible by 7. Skip.

Try digit 6

6 ÷ 6 = 1. Add 6 to digits. Remaining: 1

Result

Digits: [8,6]. Sort: [6,8]. Answer: 68

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int smallestFactorization(int num) {
    if (num == 0) return 0;
    if (num == 1) return 1;
    
    int digits[50];
    int count = 0;
    
    // Try to factorize using digits 9 down to 2
    for (int digit = 9; digit >= 2; digit--) {
        while (num % digit == 0) {
            digits[count++] = digit;
            num /= digit;
        }
    }
    
    // If num > 1, couldn't factorize completely
    if (num > 1) return 0;
    
    // Sort digits in ascending order
    qsort(digits, count, sizeof(int), compare);
    
    // Form the result
    long long result = 0;
    for (int i = 0; i < count; i++) {
        result = result * 10 + digits[i];
        if (result > INT_MAX) {
            return 0;
        }
    }
    
    return (int)result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log num)

We try each digit 2-9 at most O(log num) times since we divide num by the digit each time

⚡ Linearithmic

Space Complexity

O(log num)

We store at most O(log num) digits in our result array

⚡ Linearithmic Space

15.6K Views

Medium Frequency

~15 min Avg. Time

485 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

Greedy Factorization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler