Smallest Divisible Digit Product I - Practice Coding Problems

Smallest Divisible Digit Product I - Problem

Math Enumeration Easy

Find the Magic Number! 🎯

You are given two integers n and t. Your task is to find the smallest number greater than or equal to n such that the product of its digits is divisible by t.

For example, if n = 15 and t = 3, you need to find the smallest number ≥ 15 where multiplying all its digits gives a result divisible by 3. The number 16 has digit product 1×6 = 6, which is divisible by 3!

Think of it as finding the next "lucky number" where all digits multiply to create a multiple of your target value.

Input & Output

example_1.py — Simple Case

$ Input: n = 15, t = 3

› Output: 16

💡 Note: Starting from 15: digit product of 15 is 1×5=5 (not divisible by 3). Next number 16 has digit product 1×6=6, which is divisible by 3.

example_2.py — Already Valid

$ Input: n = 23, t = 6

› Output: 23

💡 Note: The number 23 itself has digit product 2×3=6, which is divisible by 6. So we return 23 directly.

example_3.py — Zero Digit Case

$ Input: n = 101, t = 2

› Output: 111

💡 Note: Number 101 has digit product 1×0×1=0, not divisible by 2. We need to find the next number without zero digits. Numbers 102-110 all contain 0. First valid is 111 with product 1×1×1=1, but 1 is not divisible by 2. Next is 112 with product 1×1×2=2, which is divisible by 2.

Visualization

Tap to expand

Understanding the Visualization

Set Production Line

Start the conveyor belt at number n, our minimum required plate number

Quality Check Station

For each plate, multiply all digits together to get the 'magic number'

Divisibility Test

Check if our magic number is divisible by the lucky number t

Ship or Continue

If divisible, ship the plate! Otherwise, move to the next number on the line

Key Takeaway

🎯 Key Insight: Like a quality control system, we systematically check each candidate until we find one that meets our mathematical requirement!

Time & Space Complexity

Time Complexity

⏱️

O(k × d)

In worst case similar to brute force, but often much faster in practice

✓ Linear Growth

Space Complexity

O(d)

Need to store digits of the number being constructed

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁶
1 ≤ t ≤ 10⁶
The answer is guaranteed to exist within reasonable bounds

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 🍎 Apple 6

The optimal approach is sequential search with smart optimizations. Start from n and check each number's digit product for divisibility by t. Key optimizations include special handling of zero digits and mathematical analysis of the target divisor t to make intelligent jumps when possible.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Digit Construction	O(k × d)	O(d)	Smart digit manipulation to construct the answer more efficiently

Optimized Digit Construction — Algorithm Steps

Start from number n
If current number's digit product is already divisible by t, return it
Otherwise, try to modify digits intelligently to create divisibility
Consider incrementing and adjusting digits to minimize the result
Handle special cases like when digit product contains 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze current number

Check if current number already satisfies the condition

Handle zero digits

Special handling when digit product contains zeros

Smart incrementing

Increment strategically to minimize search space

Construct optimal result

Build the smallest valid number efficiently

Code -

solution.c — C

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

long long digitProduct(long long num) {
    long long product = 1;
    while (num > 0) {
        product *= num % 10;
        num /= 10;
    }
    return product;
}

long long smallestNumber(long long n, long long t) {
    long long current = n;
    
    if (digitProduct(current) % t == 0) {
        return current;
    }
    
    while (1) {
        long long product = digitProduct(current);
        
        if (product % t == 0) {
            return current;
        }
        
        current++;
    }
}

int main() {
    long long n, t;
    scanf("%lld %lld", &n, &t);
    printf("%lld\n", smallestNumber(n, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × d)

In worst case similar to brute force, but often much faster in practice

✓ Linear Growth

Space Complexity

O(d)

Need to store digits of the number being constructed

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁶
1 ≤ t ≤ 10⁶
The answer is guaranteed to exist within reasonable bounds

26.8K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Digit Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler