Smallest Integer Divisible by K

Smallest Integer Divisible by K - Problem

Given a positive integer k, you need to find the length of the smallest positive integer n such that:

n is divisible by k
n only contains the digit 1

Return the length of n. If there is no such n, return -1.

Note: n may not fit in a 64-bit signed integer.

Input & Output

Example 1 — Basic Case

$ Input: k = 1

› Output: 1

💡 Note: The smallest integer containing only 1's that is divisible by 1 is "1" itself, which has length 1.

Example 2 — Requires Multiple 1's

$ Input: k = 3

› Output: 3

💡 Note: We need to find the smallest number with only 1's divisible by 3: 1%3=1, 11%3=2, 111%3=0. So "111" with length 3 is the answer.

Example 3 — Impossible Case

$ Input: k = 2

› Output: -1

💡 Note: Numbers containing only 1's are always odd, so they can never be divisible by 2. Return -1.

Constraints

1 ≤ k ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12

The key insight is to use modular arithmetic to avoid handling large numbers and detect cycles. If k has factors 2 or 5, no solution exists since numbers with only 1's are always odd and not divisible by 5. Best approach uses hash set with remainder tracking. Time: O(k), Space: O(k)

Common Approaches

✓ Brute Force Simulation

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

Build each number by appending '1' and check if it's divisible by k. Stop when we find the first one or hit a reasonable limit.

Modular Arithmetic with Cycle Detection

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

Instead of building actual numbers, track only remainders using modular arithmetic. Use a hash set to detect when we've seen a remainder before (indicating a cycle).

Brute Force Simulation — Algorithm Steps

Start with n = 1
Check if n % k == 0, return length if true
Generate next number: n = n * 10 + 1
Repeat until found or overflow

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with n=1, length=1

Check

Test if n % k == 0

Extend

If not divisible, n = n*10 + 1

Code -

solution.c — C

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

int solution(int k) {
    if (k % 2 == 0 || k % 5 == 0) {
        return -1;
    }
    
    int remainder = 1 % k;
    int length = 1;
    
    while (remainder != 0) {
        remainder = (remainder * 10 + 1) % k;
        length++;
        if (length > k) {  // Safety check to prevent infinite loop
            return -1;
        }
    }
    
    return length;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(k)

In worst case, we might need to check up to k different remainders

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current number and length

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler