Smallest Greater Multiple Made of Two Digits

Smallest Greater Multiple Made of Two Digits - Problem

Math Enumeration Medium

Imagine you're working with a digital display system that can only show two specific digits! Given three integers k, digit1, and digit2, your challenge is to find the smallest integer that satisfies all these conditions:

🔢 Larger than k - Must exceed our starting number
🎯 Multiple of k - Must be divisible by k with no remainder
📟 Only uses digit1 and/or digit2 - Like a broken calculator that only has two working digit buttons!

Return the smallest such integer, or -1 if no valid number exists or if the result exceeds 2³¹ - 1.

Example: If k=2, digit1=1, digit2=2, we can form numbers like 1, 2, 11, 12, 21, 22, 111, 112, etc. We need the smallest one > 2 that's divisible by 2, which is 12!

Input & Output

example_1.py — Basic Case

$ Input: k = 2, digit1 = 1, digit2 = 2

› Output: 12

💡 Note: We need a number > 2 that uses only digits 1 and 2, and is divisible by 2. Possible numbers: 1 (too small), 2 (not greater), 11 (not divisible by 2), 12 (perfect! 12 > 2 and 12 % 2 == 0)

example_2.py — Single Digit

$ Input: k = 3, digit1 = 4, digit2 = 2

› Output: 24

💡 Note: Numbers using only 2 and 4: 2, 4, 22, 24, 42, 44... We need one > 3 and divisible by 3. Check: 24 % 3 == 0 ✓, so answer is 24

example_3.py — Edge Case with 0

$ Input: k = 7, digit1 = 1, digit2 = 0

› Output: 10

💡 Note: Using digits 1 and 0: 1, 10, 100, 101, 110, 111, 1000... We need > 7 and divisible by 7. First candidate 10: 10 > 7 ✓ but 10 % 7 = 3 ✗. Continue until we find a valid multiple.

Visualization

Tap to expand

Key Insight: Build only valid numbers instead of checking all numbers!Conveyor belt represents BFS queue - systematic and efficient!

Understanding the Visualization

Initialize Production

Start the assembly line with single digits (digit1 and digit2)

Quality Check

For each display: Is it bigger than prototype? Does it divide into k equal segments?

Expand Production

If not suitable, create larger displays by adding more digits to the end

First Success

Return the first display that passes all quality checks

Key Takeaway

🎯 Key Insight: Use BFS to generate only valid digit combinations instead of testing every possible number - like having a smart assembly line that only builds displays worth testing!

Time & Space Complexity

Time Complexity

⏱️

O(2^d)

Where d is the number of digits needed. In practice, much faster than brute force due to early termination.

✓ Linear Growth

Space Complexity

O(2^d)

Queue can hold at most 2^d numbers for d-digit combinations

✓ Linear Space

Constraints

1 ≤ k ≤ 10⁴
0 ≤ digit1 ≤ 9
0 ≤ digit2 ≤ 9
Result must not exceed 2³¹ - 1
Return -1 if no valid number exists or exceeds limit

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal approach uses BFS to systematically generate numbers using only the allowed digits. Instead of checking every possible number, we build valid candidates by appending digit1 and digit2 to existing numbers, checking divisibility as we go. This reduces time complexity significantly and finds the smallest valid multiple efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Number Generation (Optimal)	O(2^d)	O(2^d)	Use BFS to generate numbers using only digit1 and digit2, checking divisibility as we build them

BFS Number Generation (Optimal) — Algorithm Steps

Initialize queue with digit1 and digit2 (if non-zero)
For each number in queue, check if it's > k and divisible by k
If valid, return it; otherwise generate new numbers by appending both digits
Add new numbers to queue if they don't exceed the 32-bit limit
Continue until queue is empty (return -1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize queue

Start with single digits (digit1, digit2)

Check current number

Test if current > k and divisible by k

Generate children

Append both digits to create new numbers

Continue BFS

Process queue until answer found or empty

Code -

solution.c — C

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

#define MAX_QUEUE 100000

int solution(int k, int digit1, int digit2) {
    if (k == 1) {
        return digit1 != digit2 ? (digit1 < digit2 ? digit1 : digit2) : digit1;
    }
    
    long long queue[MAX_QUEUE];
    int front = 0, rear = 0;
    long long limit = (1LL << 31) - 1;
    
    // Add initial digits to queue (avoid leading zeros)
    if (digit1 != 0) {
        queue[rear++] = (long long) digit1;
    }
    if (digit2 != 0 && digit1 != digit2) {
        queue[rear++] = (long long) digit2;
    }
    
    // Handle case where one digit is 0
    if (digit1 == 0 || digit2 == 0) {
        int nonZero = digit1 != 0 ? digit1 : digit2;
        queue[rear++] = (long long) nonZero;
    }
    
    while (front < rear) {
        long long current = queue[front++];
        
        if (current > k && current % k == 0) {
            return (int) current;
        }
        
        // Generate next numbers by appending digits
        long long next1 = current * 10 + digit1;
        long long next2 = current * 10 + digit2;
        
        if (next1 <= limit && rear < MAX_QUEUE) {
            queue[rear++] = next1;
        }
        if (next2 <= limit && digit1 != digit2 && rear < MAX_QUEUE) {
            queue[rear++] = next2;
        }
    }
    
    return -1;
}

int main() {
    int k, digit1, digit2;
    scanf("%d %d %d", &k, &digit1, &digit2);
    printf("%d\n", solution(k, digit1, digit2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^d)

Where d is the number of digits needed. In practice, much faster than brute force due to early termination.

✓ Linear Growth

Space Complexity

O(2^d)

Queue can hold at most 2^d numbers for d-digit combinations

✓ Linear Space

Constraints

1 ≤ k ≤ 10⁴
0 ≤ digit1 ≤ 9
0 ≤ digit2 ≤ 9
Result must not exceed 2³¹ - 1
Return -1 if no valid number exists or exceeds limit

31.7K Views

Medium Frequency

~25 min Avg. Time

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

BFS Number Generation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler