数字之和为 N 且每个数字最多出现 K 次的最小数

给定两个正整数N和K ，任务是找到最小的数字，其数字总和为N，并且该数字中每个不同的数字最多出现K次。如果不存在这样的数字，则打印“-1” 。

例子：

Input: N = 25, K = 3
Output: 799
Explanation: Sum of digits of the number = (7 + 9 + 9) = 25 and is the smallest possible.

Input: N =100, K = 2
Output: -1

方法：可以使用贪婪方法解决给定的问题。请按照以下步骤解决问题：

• 每个数字最多出现K次的任何数字的最大可能数字总和是K * 45 。
• 初始化一个字符串，比如res ，以存储形成的结果字符串。
• 如果N大于K * 45 ，则无法获得这样的数字。因此，打印“-1” 。
• 否则，继续减去从9到1 ，从N开始的每个数字，最多 K次。将当前数字添加到res 。继续直到 N 小于当前数字。
• 如果N小于当前数字，则将N作为数字插入res 。
• 完成上述步骤后，将字符串res以相反的顺序打印为所需答案。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the smallest number
// whose sum of digits is N and each
// digit occurring at most K times
void findSmallestNumberPossible(int N, int K)
{
    // Maximum sum possible using
    // each digit at most K times
    if (N > 45 * K) {
        cout << "-1";
        return;
    }
 
    // Append smallest number into
    // the resultant string
    string res = "";
    int count = 0;
 
    // Iterate over the range [9, 1]
    for (int i = 9; i >= 1;) {
 
        // If the count of the digit
        // is K, then update count and
        // check for the next digit
        if (count == K) {
            i--;
            count = 0;
        }
 
        // If N is greater than
        // current digit
        if (N > i) {
 
            // Subtract i from N
            N -= i;
 
            // Insert i as a digit
            res += (char)48 + i;
        }
        else {
 
            // Insert remaining N
            // as a digit
            res += (char)N + 48;
            N = 0;
            break;
        }
 
        // Increment count
        count++;
    }
 
    // Reverse the string
    reverse(res.begin(),
            res.end());
 
    // Print the answer
    cout << res;
}
 
// Driver Code
int main()
{
    int N = 25, K = 3;
 
    // Function Call
    findSmallestNumberPossible(N, K);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
 
class GFG{
 
// Function to find the smallest number
// whose sum of digits is N and each
// digit occurring at most K times
static void findSmallestNumberPossible(int N, int K)
{
     
    // Maximum sum possible using
    // each digit at most K times
    if (N > 45 * K)
    {
        System.out.print("-1");
        return;
    }
 
    // Append smallest number into
    // the resultant string
    StringBuilder res = new StringBuilder();
    int count = 0;
 
    // Iterate over the range [9, 1]
    for(int i = 9; i >= 1😉
    {
         
        // If the count of the digit
        // is K, then update count and
        // check for the next digit
        if (count == K)
        {
            i--;
            count = 0;
        }
 
        // If N is greater than
        // current digit
        if (N > i)
        {
             
            // Subtract i from N
            N -= i;
 
            // Insert i as a digit
            res.append((char)('0' + i));
        }
        else
        {
             
            // Insert remaining N
            // as a digit
            res.append((char)('0' + N));
            N = 0;
            break;
        }
 
        // Increment count
        count++;
    }
 
    // Reverse the string
    res.reverse();
 
    // Print the answer
    System.out.print(res.toString());
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 25, K = 3;
 
    // Function Call
    findSmallestNumberPossible(N, K);
}
}
 
// This code is contributed by jithin

Python3

# Python3 program for the above approach
 
# Function to find the smallest number
# whose sum of digits is N and each
# digit occurring at most K times
def findSmallestNumberPossible(N, K) :
 
    # Maximum sum possible using
    # each digit at most K times
    if (N > 45 * K) :
        print("-1", endl = "");
        return;
 
    # Append smallest number into
    # the resultant string
    res = "";
    count = 0;
 
    # Iterate over the range [9, 1]
    i = 9;   
    while i >= 1 :
 
        # If the count of the digit
        # is K, then update count and
        # check for the next digit
        if (count == K) :
            i -= 1;
            count = 0;
 
        # If N is greater than
        # current digit
        if (N > i) :
 
            # Subtract i from N
            N -= i;
 
            # Insert i as a digit
            res += chr(48 + i);
         
        else :
 
            # Insert remaining N
            # as a digit
            res += chr(N + 48);
            N = 0;
            break;
 
        # Increment count
        count += 1;
 
    # Reverse the string
    res = res[::-1]
 
    # Print the answer
    print(res, end = "");
 
# Driver Code
if __name__ == "__main__" :
 
    N = 25; K = 3;
 
    # Function Call
    findSmallestNumberPossible(N, K);
     
    # This code is contributed by AnkThon

C#

// C# program to implement
// the above approach 
using System;
class GFG
{
  
// Function to find the smallest number
// whose sum of digits is N and each
// digit occurring at most K times
static void findSmallestNumberPossible(int N, int K)
{
      
    // Maximum sum possible using
    // each digit at most K times
    if (N > 45 * K)
    {
        Console.Write("-1");
        return;
    }
  
    // Append smallest number into
    // the resultant string
    string res = "" ;
    int count = 0;
  
    // Iterate over the range [9, 1]
    for (int i = 9; i >= 1;)
    {
  
        // If the count of the digit
        // is K, then update count and
        // check for the next digit
        if (count == K)
        {
            i--;
            count = 0;
        }
  
        // If N is greater than
        // current digit
        if (N > i)
        {
  
            // Subtract i from N
            N -= i;
  
            // Insert i as a digit
            res += (char)('0' + i);
        }
        else
        {
  
            // Insert remaining N
            // as a digit
            res += (char)('0' + N);
            N = 0;
            break;
        }
  
        // Increment count
        count++;
    }
     
     // Reverse the string
     string ans = "";
     for (int i = res.Length - 1; i >= 0; i--)
     {
         ans += res[i] + "";
          
     }
   
     // Print the answer
     Console.WriteLine(ans);
}
  
// Driver Code
public static void Main()
{
    int N = 25, K = 3;
  
    // Function Call
    findSmallestNumberPossible(N, K);
}
}
 
// This code is contributed by susmitakundugoaldanga

Javascript

 
      // JavaScript program to implement
      // the above approach
       
      // Function to find the smallest number
      // whose sum of digits is N and each
      // digit occurring at most K times
      function findSmallestNumberPossible(N, K) {
        // Maximum sum possible using
        // each digit at most K times
        if (N > 45 * K) {
          document.write("-1");
          return;
        }
 
        // Append smallest number into
        // the resultant string
        var res = "";
        var count = 0;
 
        // Iterate over the range [9, 1]
        for (var i = 9; i >= 1; ) {
          // If the count of the digit
          // is K, then update count and
          // check for the next digit
          if (count === K) {
            i--;
            count = 0;
          }
 
          // If N is greater than
          // current digit
          if (N > i) {
            // Subtract i from N
            N -= i;
 
            // Insert i as a digit
            res += String.fromCharCode("0".charCodeAt(0) + i);
          } else {
            // Insert remaining N
            // as a digit
            res += String.fromCharCode("0".charCodeAt(0) + N);
            N = 0;
            break;
          }
 
          // Increment count
          count++;
        }
 
        // Reverse the string
        var ans = "";
        for (var i = res.length - 1; i >= 0; i--) {
          ans += res[i] + "";
        }
 
        // Print the answer
        document.write(ans);
      }
 
      // Driver Code
      var N = 25,
        K = 3;
 
      // Function Call
      findSmallestNumberPossible(N, K);
       

输出：

799

时间复杂度： O(log ₁₀ N)
辅助空间： O(1)