仅使用 D 形成的可被 K 整除的数字的最小长度

给定 2 个整数D和K，任务是找到由重复D形成的可被K整除的数字的最小长度。如果不存在这样的数字，则打印-1 。

例子：

Input : D = 1, K = 37
Output : 3
Explanation : The minimum number formed by repeating 1 that is divisible by 37 is 111

Input : D = 2, K = 36
Output : -1

天真的方法：想法是不断形成数字，直到它可以被K整除或超出范围。

时间复杂度： O(10^18)
辅助空间： O(1)

有效方法：这个想法是存储通过将数字除以K并将余数存储在数组中而产生的余数。而当同样的余数再次出现时，可以断定不存在这样的数。请按照以下步骤解决问题：

• 将变量cnt初始化为0以存储答案，将变量m初始化为存储数字。
• 初始化大小为K的向量v[]以存储余数并将v[m]的值设置为1。
• 在while循环中迭代并执行以下步骤
  • 如果m等于0，则返回cnt的值作为答案。
  • 将m的值设置为(((m * (10 % k)) % k) + (d % k)) % k。
  • 如果v[m]等于1，则返回-1 ，因为不可能有这样的数字。
  • 将v[m]的值设置为1 ，并将cnt的值增加1。
• 执行上述步骤后，返回值-1。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to form the smallest number
// possible
int smallest(int k, int d)
{
    int cnt = 1;
    int m = d % k;
 
    // Array to mark the remainders
    // counted already
    vector v(k, 0);
    v[m] = 1;
 
    // Iterate over the range
    while (1) {
        if (m == 0)
            return cnt;
        m = (((m * (10 % k)) % k) + (d % k)) % k;
 
        // If that remainder is already found,
        // return -1
        if (v[m] == 1)
            return -1;
        v[m] = 1;
        cnt++;
    }
    return -1;
}
 
// Driver Code
int main()
{
 
    int d = 1;
    int k = 41;
    cout << smallest(k, d);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to form the smallest number
// possible
static int smallest(int k, int d)
{
    int cnt = 1;
    int m = d % k;
 
    // Array to mark the remainders
    // counted already
    int[] v = new int[k];
    Arrays.fill(v, 0);
    v[m] = 1;
 
    // Iterate over the range
    while (1 != 0)
    {
        if (m == 0)
            return cnt;
             
        m = (((m * (10 % k)) % k) + (d % k)) % k;
 
        // If that remainder is already found,
        // return -1
        if (v[m] == 1)
            return -1;
             
        v[m] = 1;
        cnt++;
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int d = 1;
    int k = 41;
     
    System.out.println(smallest(k, d));
}
}
 
// This code is contributed by sanjoy_62

Python3

# Python program for the above approach;
 
# Function to form the smallest number
# possible
def smallest(k, d):
    cnt = 1
    m = d % k
 
    # Array to mark the remainders
    # counted already
    v = [0 for i in range(k)];
    v[m] = 1
 
    # Iterate over the range
    while (1):
        if (m == 0):
            return cnt
        m = (((m * (10 % k)) % k) + (d % k)) % k
 
        # If that remainder is already found,
        # return -1
        if (v[m] == 1):
            return -1
        v[m] = 1
        cnt += 1
 
    return -1
 
# Driver Code
d = 1
k = 41
print(smallest(k, d))
 
# This code is contributed by gfgking

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to form the smallest number
// possible
static int smallest(int k, int d)
{
    int cnt = 1;
    int m = d % k;
 
    // Array to mark the remainders
    // counted already
    int [] v = new int[k];
    for(int i=0;i

---

Javascript

        // JavaScript program for the above approach;
 
        // Function to form the smallest number
        // possible
        function smallest(k, d) {
            let cnt = 1;
            let m = d % k;
 
            // Array to mark the remainders
            // counted already
            let v = new Array(k).fill(0);
            v[m] = 1;
 
            // Iterate over the range
            while (1) {
                if (m == 0)
                    return cnt;
                m = (((m * (10 % k)) % k) + (d % k)) % k;
 
                // If that remainder is already found,
                // return -1
                if (v[m] == 1)
                    return -1;
                v[m] = 1;
                cnt++;
            }
            return -1;
        }
 
        // Driver Code
        let d = 1;
        let k = 41;
        document.write(smallest(k, d));
         
   // This code is contributed by Potta Lokesh
    

输出

5

时间复杂度： O(K)
辅助空间： O(K)