Smallest Divisible Digit Product II - Practice Coding Problems

Smallest Divisible Digit Product II - Problem

Math String Backtracking Greedy Number Theory Hard

You're given a string num representing a positive integer and an integer t. Your mission is to find the smallest zero-free number that is greater than or equal to num and has a special property: the product of its digits must be divisible by t.

A number is zero-free if none of its digits are 0. This constraint makes the problem particularly challenging since we can't use 0 as a "filler" digit.

Goal: Return a string representing this magical number, or "-1" if no such number exists.

Example: If num = "1234" and t = 6, we need to find the smallest number ≥ 1234 with no zeros where digit product is divisible by 6. The digit product of 1234 is 1×2×3×4 = 24, and 24 ÷ 6 = 4, so "1234" itself works!

Input & Output

example_1.py — Basic Case

$ Input: num = "1234", t = 6

› Output: "1234"

💡 Note: The digit product of 1234 is 1×2×3×4 = 24, and 24 is divisible by 6 (24 ÷ 6 = 4). Since 1234 ≥ 1234 and contains no zeros, it's our answer.

example_2.py — Need to Increment

$ Input: num = "1000", t = 10

› Output: "1125"

💡 Note: 1000 contains zeros, so we need to find a larger zero-free number. We need digit product divisible by 10 = 2×5. The number 1125 has product 1×1×2×5 = 10, which is divisible by 10.

example_3.py — Impossible Case

$ Input: num = "1", t = 11

› Output: "-1"

💡 Note: Since 11 is prime and greater than 7, and digits can only contribute prime factors 2, 3, 5, 7, it's impossible to create a digit product divisible by 11.

Constraints

1 ≤ num.length ≤ 10⁵
num consists of only digits and does not have leading zeros
1 ≤ t ≤ 10⁹
The result number should not exceed reasonable length limits

Visualization

Tap to expand

Understanding the Visualization

Factor Analysis

Break t = 60 into prime factors: 2² × 3 × 5

Digit Mapping

Map each digit to its prime factors: 6 = 2×3, 4 = 2², etc.

Greedy Assignment

Try to use the smallest digits that provide the required factors

Validation

Ensure the result is ≥ input number and zero-free

Key Takeaway

🎯 Key Insight: Only prime factors 2, 3, 5, 7 can be formed from digits 1-9. Use backtracking to distribute these factors optimally across digit positions, building the smallest valid number systematically.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses backtracking with prime factorization. Key insight: since digits 1-9 can only contribute prime factors 2, 3, 5, and 7, we first check if t can be formed using only these primes. Then we use backtracking to construct the number digit by digit, tracking remaining prime factors needed and pruning impossible branches. This avoids the exponential search space of brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Number)	O(k * d)	O(1)	Increment from the given number and check each candidate
Backtracking with Digit Construction	O(9^d)	O(d)	Build the number digit by digit using backtracking and pruning

Brute Force (Try Every Number) — Algorithm Steps

Convert input number to integer
For each number starting from the input
Check if the number contains any zeros
If zero-free, calculate product of digits
Check if product is divisible by t
Return first valid number found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from given number

Begin with the input number as starting point

Check zero-free condition

Verify no digit is zero

Calculate digit product

Multiply all digits together

Check divisibility

Test if product divides evenly by t

Code -

solution.c — C

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

bool hasZero(long long n) {
    char s[20];
    sprintf(s, "%lld", n);
    return strchr(s, '0') != NULL;
}

long long digitProduct(long long n) {
    long long product = 1;
    char s[20];
    sprintf(s, "%lld", n);
    for (int i = 0; s[i]; i++) {
        product *= (s[i] - '0');
    }
    return product;
}

char* smallestNumber(char* num, int t) {
    long long current = atoll(num);
    int maxIterations = 1000000;
    int iterations = 0;
    
    while (iterations < maxIterations) {
        if (!hasZero(current)) {
            long long product = digitProduct(current);
            if (product % t == 0) {
                char* result = malloc(20);
                sprintf(result, "%lld", current);
                return result;
            }
        }
        current++;
        iterations++;
    }
    
    char* result = malloc(3);
    strcpy(result, "-1");
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(k * d)

k is the difference between answer and input (could be huge), d is number of digits

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

28.4K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler