Minimum Factorization

Minimum Factorization - Problem

Math Greedy Medium

Given a positive integer num, return the smallest positive integer x whose multiplication of each digit equals num.

If there is no answer or the answer does not fit in a 32-bit signed integer, return 0.

Note: The result must be composed of digits 2-9 only (no 0 or 1), and we want the smallest possible number.

Input & Output

Example 1 — Basic Factorization

$ Input: num = 48

› Output: 68

💡 Note: 48 = 8 × 6. The digits are [8, 6]. Arranging in ascending order gives 68.

Example 2 — Single Digit

$ Input: num = 9

› Output: 9

💡 Note: 9 is already a single digit, so the answer is 9 itself.

Example 3 — No Valid Factorization

$ Input: num = 11

› Output: 0

💡 Note: 11 is prime and cannot be factored using digits 2-9, so return 0.

Constraints

1 ≤ num ≤ 2³¹ - 1
The result must fit in a 32-bit signed integer

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is to use greedy factorization with digits 9 down to 2, then arrange factors in ascending order. The greedy approach is optimal with Time: O(log num), Space: O(log num).

Common Approaches

✓ Brute Force Generation

⏱️ Time: O(9^k) Space: O(9^k)

Try every possible number by generating combinations of digits 2-9, check if their product equals num, and return the smallest valid result. This approach systematically explores all possibilities.

Greedy Factorization

⏱️ Time: O(log num) Space: O(log num)

Use a greedy approach to factor the number starting from digit 9 down to 2. This ensures we get the minimum number of digits, and arranging them in ascending order gives the smallest result.

Brute Force Generation — Algorithm Steps

Generate all combinations of digits 2-9
For each combination, calculate digit product
Keep track of smallest valid combination
Return result or 0 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all combinations of digits 2-9

Check

Calculate product of each combination

Select

Return smallest valid combination

Code -

solution.c — C

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

int minResult = INT_MAX;
int found = 0;

void generate(int* current, int currentSize, int remaining, int start, int target) {
    if (currentSize == remaining) {
        int product = 1;
        for (int i = 0; i < currentSize; i++) {
            product *= current[i];
        }
        if (product == target) {
            // Sort current array
            for (int i = 0; i < currentSize - 1; i++) {
                for (int j = i + 1; j < currentSize; j++) {
                    if (current[i] > current[j]) {
                        int temp = current[i];
                        current[i] = current[j];
                        current[j] = temp;
                    }
                }
            }
            
            int num = 0;
            for (int i = 0; i < currentSize; i++) {
                num = num * 10 + current[i];
            }
            if (num < minResult) {
                minResult = num;
            }
            found = 1;
        }
        return;
    }
    
    for (int i = start; i <= 9; i++) {
        current[currentSize] = i;
        generate(current, currentSize + 1, remaining, i, target);
    }
}

int solution(int num) {
    if (num == 1) return 1;
    
    minResult = INT_MAX;
    found = 0;
    
    for (int length = 1; length <= 9; length++) {
        int current[10];
        generate(current, 0, length, 2, num);
        if (found) {
            return minResult;
        }
    }
    
    return 0;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(9^k)

Generate all combinations of digits 2-9 up to length k, where k can be large

✓ Linear Growth

Space Complexity

O(9^k)

Store all generated combinations before filtering

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

456 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

Brute Force Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler