Smallest Number With Given Digit Product - Practice Coding Problems

Smallest Number With Given Digit Product - Problem

Math Greedy Medium

Given a positive integer n, your task is to find the smallest positive integer whose digits multiply together to equal n. If no such number exists, return "-1".

This problem combines number theory with greedy algorithms. The key insight is that we want to use the largest possible digits (9, 8, 7, etc.) to minimize the total number of digits, and arrange them in ascending order to get the lexicographically smallest result.

Examples:
• n = 12 → "26" (2 × 6 = 12, and 26 < 34)
• n = 0 → "10" (1 × 0 = 0, smallest number with 0 as digit)
• n = 1 → "1" (trivial case)
• n = 11 → "-1" (11 is prime > 7, impossible)

Input & Output

example_1.py — Basic Case

$ Input: n = 12

› Output: "26"

💡 Note: 12 = 2 × 6, so we need digits whose product is 12. The possible combinations are: 2×6=12, 3×4=12. Since 26 < 34, the answer is "26".

example_2.py — Zero Case

$ Input: n = 0

› Output: "10"

💡 Note: To get digit product = 0, we need at least one digit to be 0. The smallest such number is "10" (1×0=0).

example_3.py — Impossible Case

$ Input: n = 11

› Output: "-1"

💡 Note: 11 is a prime number greater than 7. Since digits can only be 1-9, and we need positive integers (so no leading zeros), it's impossible to form a number whose digits multiply to 11.

Constraints

1 ≤ n ≤ 10⁹
Return value should be a string
n = 0 should return "10" (special case)

Visualization

Tap to expand

Understanding the Visualization

Input Processing

The target number n enters the factorization machine

Prime Breakdown

Machine extracts all factors of 2, 3, 5, and 7

Digit Assembly

Greedy machines combine factors into largest possible digits

Quality Control

Sort digits in ascending order for optimal result

Key Takeaway

🎯 Key Insight: Like an efficient factory, we break down the problem into manageable components (prime factorization), then use greedy optimization to reassemble them into the most efficient solution. The assembly line approach guarantees optimal results in minimal time!

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses prime factorization and greedy digit formation. We factorize n into primes 2, 3, 5, 7, then greedily combine factors to form the largest possible digits (9 from 3², 8 from 2³, 6 from 2×3, etc.). Finally, sort digits in ascending order to get the lexicographically smallest result. Time: O(log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Prime Factorization (Optimal)	O(log n)	O(1)	Use prime factorization and greedily combine factors into largest possible digits
Brute Force (Generate and Check)	O(10^k)	O(1)	Generate numbers sequentially and check if their digit product equals n

Greedy Prime Factorization (Optimal) — Algorithm Steps

Handle special cases: n=0 returns '10', n=1 returns '1'
Check if n has any prime factors > 7; if yes, return '-1'
Count occurrences of prime factors 2, 3, 5, 7 in n
Greedily form largest digits: 9 (from 3²), 8 (from 2³), 6 (from 2×3), etc.
Arrange resulting digits in ascending order to get lexicographically smallest number

Visualization

Tap to expand

Step-by-Step Walkthrough

Factorize n = 72

72 = 2³ × 3² = {2:3, 3:2}

Form 9 from 3²

Use two 3s to form digit 9, remaining: {2:3, 3:0}

Form 8 from 2³

Use three 2s to form digit 8, remaining: {2:0, 3:0}

Sort digits

Arrange [8, 9] in ascending order → "89"

Code -

solution.c — C

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

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

char* smallestNumber(int n) {
    char* result = (char*)malloc(50 * sizeof(char));
    
    if (n == 0) {
        strcpy(result, "10");
        return result;
    }
    if (n == 1) {
        strcpy(result, "1");
        return result;
    }
    
    int factors[10] = {0};
    
    // Count prime factors
    while (n % 2 == 0) {
        factors[2]++;
        n /= 2;
    }
    
    while (n % 3 == 0) {
        factors[3]++;
        n /= 3;
    }
    
    while (n % 5 == 0) {
        factors[5]++;
        n /= 5;
    }
    
    while (n % 7 == 0) {
        factors[7]++;
        n /= 7;
    }
    
    if (n > 1) {
        strcpy(result, "-1");
        return result;
    }
    
    int digits[100];
    int digitCount = 0;
    
    // Add 7s
    for (int i = 0; i < factors[7]; i++) {
        digits[digitCount++] = 7;
    }
    
    // Add 5s
    for (int i = 0; i < factors[5]; i++) {
        digits[digitCount++] = 5;
    }
    
    // Greedily use 3s to form 9s
    while (factors[3] >= 2) {
        digits[digitCount++] = 9;
        factors[3] -= 2;
    }
    
    // Greedily use 2s to form 8s
    while (factors[2] >= 3) {
        digits[digitCount++] = 8;
        factors[2] -= 3;
    }
    
    // Use remaining 2s and 3s to form 6s
    while (factors[2] >= 1 && factors[3] >= 1) {
        digits[digitCount++] = 6;
        factors[2]--;
        factors[3]--;
    }
    
    // Use remaining 2s to form 4s
    while (factors[2] >= 2) {
        digits[digitCount++] = 4;
        factors[2] -= 2;
    }
    
    // Add remaining factors
    for (int i = 0; i < factors[3]; i++) {
        digits[digitCount++] = 3;
    }
    for (int i = 0; i < factors[2]; i++) {
        digits[digitCount++] = 2;
    }
    
    qsort(digits, digitCount, sizeof(int), compare);
    
    for (int i = 0; i < digitCount; i++) {
        result[i] = '0' + digits[i];
    }
    result[digitCount] = '\0';
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We factorize n which takes O(log n) time, then process at most 8 digits

⚡ Linearithmic

Space Complexity

O(1)

Only using fixed arrays to count factors and store result digits

✓ Linear Space

23.4K Views

Medium-High Frequency

~18 min Avg. Time

847 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 Prime Factorization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler