Smallest Greater Multiple Made of Two Digits - Problem

Math Enumeration Medium

Given three integers k, digit1, and digit2, find the smallest integer that satisfies all of the following conditions:

The integer is larger than k
The integer is a multiple of k
The integer is comprised of only the digits digit1 and/or digit2

Return the smallest such integer. If no such integer exists or the integer exceeds the limit of a signed 32-bit integer (2³¹ - 1 = 2147483647), return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 12

💡 Note: Numbers using digits 1,2: 1, 2, 11, 12, 21, 22... First number > 2 that's divisible by 2 is 12

Example 2 — Single Digit

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

› Output: 24

💡 Note: Numbers using digits 4,2: 2, 4, 22, 24, 42, 44... First number > 3 divisible by 3 is 24 (2+4=6, divisible by 3)

Example 3 — No Solution

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

› Output: -1

💡 Note: All numbers made from digits 3,5 are odd, so none can be divisible by 2

Constraints

1 ≤ k ≤ 500
0 ≤ digit1 ≤ 9
0 ≤ digit2 ≤ 9
digit1 ≠ digit2

Visualization

Tap to expand

Asked in

G Google 15 A Amazon 12 M Microsoft 8

The key insight is to use BFS to systematically generate numbers using only the allowed digits while tracking remainders modulo k. The optimal approach uses BFS with modular arithmetic to avoid integer overflow and efficiently find the smallest valid multiple. Time: O(k), Space: O(k)

Common Approaches

✓ BFS Number Generation

⏱️ Time: O(2^d) Space: O(2^d)

Use breadth-first search to build valid numbers digit by digit. Start with the allowed digits and keep appending digit1 or digit2 to generate longer numbers. Check for multiples of k using modular arithmetic.

BFS with Modular Arithmetic

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

Optimize BFS by tracking remainders when divided by k instead of actual numbers. This prevents integer overflow and makes the search more efficient by pruning duplicate remainder states.

Brute Force Check

⏱️ Time: O(n × log n) Space: O(1)

Start from k+1 and check each number to see if it's a multiple of k and contains only the allowed digits. Continue until we find the first valid number or exceed the 32-bit limit.

BFS Number Generation — 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
Generate new numbers by appending digit1 and digit2
Continue until valid number found or limit exceeded

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with single digits 1, 2

Expand

Generate 11, 12, 21, 22

Check

Find first valid multiple

Code -

solution.c — C

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

#define MAX_QUEUE 100000

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

int solution(int k, int digit1, int digit2) {
    if (k == 0) return -1;
    
    long long limit = (1LL << 31) - 1;
    static long long queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    // Add initial digits in ascending order (avoid leading zeros)
    int digits[2] = {digit1, digit2};
    qsort(digits, 2, sizeof(int), compare);
    
    for (int i = 0; i < 2; i++) {
        if (digits[i] != 0) {
            queue[rear++] = digits[i];
        }
    }
    
    while (front < rear) {
        long long num = queue[front++];
        
        if (num > k && num % k == 0) {
            return num;
        }
        
        // Generate next numbers in ascending order
        for (int i = 0; i < 2; i++) {
            long long nextNum = num * 10 + digits[i];
            if (nextNum <= limit && rear < MAX_QUEUE) {
                queue[rear++] = nextNum;
            }
        }
    }
    
    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)

Explores up to 2^d combinations where d is number of digits in result

✓ Linear Growth

Space Complexity

O(2^d)

Queue can hold up to 2^d numbers at each level

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

425 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

Smallest Greater Multiple Made of Two Digits - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Number Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler