Related Articles

# Count of minimum numbers having K as the last digit required to obtain sum N

• Difficulty Level : Easy
• Last Updated : 28 Jul, 2021

Given a positive integer N and a digit K, the task is to find the minimum count of numbers ending with digit K such that the sum of those numbers is N. If no such number exists whose sum is K, then print “-1”.

Examples:

Input: N = 42, K = 3
Output: 4
Explanation:
The given number N(= 43) can be expressed as 3 + 3 + 13 + 23, such all the numbers ends with digit K(= 3). Therefore, the count split numbers 4.

Input: N = 17, K = 3
Output: -1

Approach: The given problem can be solved by an observation that if a number can be expressed as the sum of numbers ending with digit K, then the result will be the maximum of 10. Follow the steps below to solve the problem:

• If the digit K is even and the integer N is odd, then print “-1″ as it is not possible to obtain an odd sum with an even number.
• For the number K, find the smallest number ending with digit i over the range [0, 9]. If it is not possible, then set the value as INT_MAX.
• Also, for each number K find the minimum steps required to create a number that ends with digit i over the range [0, 9].
• Now, if the smallest number ending with digit i is greater than N with unit digit i then print “-1” as it is no possible to make the sum of numbers as N.
• Otherwise, the answer will be minimum steps to create a number that ends with digit i which is the same as the unit digit of N because the remaining digit can be obtained by inserting those digits in any of the numbers that contribute to the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `int` `minCount(``int` `N, ``int` `K)``{``    ``// Stores the smallest number that``    ``// ends with digit i (0, 9)``    ``int` `SmallestNumber;` `    ``// Stores the minimum number of``    ``// steps to create a number ending``    ``// with digit i``    ``int` `MinimumSteps;` `    ``// Initialize elements as infinity``    ``for` `(``int` `i = 0; i <= 9; i++) {``        ``SmallestNumber[i] = INT_MAX;``        ``MinimumSteps[i] = INT_MAX;``    ``}` `    ``for` `(``int` `i = 1; i <= 10; i++) {` `        ``int` `num = K * i;` `        ``// Minimum number``        ``// ending with digit i``        ``SmallestNumber[num % 10]``            ``= min(``                ``SmallestNumber[num % 10],``                ``num);` `        ``// Minimum steps to create a``        ``// number ending with digit i``        ``MinimumSteps[num % 10]``            ``= min(``                ``MinimumSteps[num % 10], i);``    ``}` `    ``// If N < SmallestNumber then,``    ``// return -1``    ``if` `(N < SmallestNumber[N % 10]) {``        ``return` `-1;``    ``}` `    ``// Otherwise, return answer``    ``else` `{``        ``return` `MinimumSteps[N % 10];``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 42, K = 7;``    ``cout << minCount(N, K);` `    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.util.*;` `class` `GFG{` `static` `int` `minCount(``int` `N, ``int` `K)``{``    ` `    ``// Stores the smallest number that``    ``// ends with digit i (0, 9)``    ``int` `SmallestNumber[] = ``new` `int``[``10``];` `    ``// Stores the minimum number of``    ``// steps to create a number ending``    ``// with digit i``    ``int` `MinimumSteps[] = ``new` `int``[``10``];` `    ``// Initialize elements as infinity``    ``for``(``int` `i = ``0``; i <= ``9``; i++)``    ``{``        ``SmallestNumber[i] = Integer.MAX_VALUE;``        ``MinimumSteps[i] = Integer.MAX_VALUE;``    ``}` `    ``for``(``int` `i = ``1``; i <= ``10``; i++)``    ``{``        ``int` `num = K * i;``        ` `        ``// Minimum number``        ``// ending with digit i``        ``SmallestNumber[num % ``10``] = Math.min(``            ``SmallestNumber[num % ``10``], num);` `        ``// Minimum steps to create a``        ``// number ending with digit i``        ``MinimumSteps[num % ``10``] = Math.min(``            ``MinimumSteps[num % ``10``], i);``    ``}` `    ``// If N < SmallestNumber then,``    ``// return -1``    ``if` `(N < SmallestNumber[N % ``10``])``    ``{``        ``return` `-``1``;``    ``}` `    ``// Otherwise, return answer``    ``else``    ``{``        ``return` `MinimumSteps[N % ``10``];``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``42``, K = ``7``;``  ` `    ``System.out.println(minCount(N, K));``}``}` `// This code is contributed by hritikrommie`

## Python3

 `# Python3 program for the above approach``import` `sys` `def` `minCount(N, K):``  ` `    ``# Stores the smallest number that``    ``# ends with digit i (0, 9)``    ``SmallestNumber ``=` `[``0` `for` `i ``in` `range``(``10``)]` `    ``# Stores the minimum number of``    ``# steps to create a number ending``    ``# with digit i``    ``MinimumSteps ``=` `[``0` `for` `i ``in` `range``(``10``)]` `    ``# Initialize elements as infinity``    ``for` `i ``in` `range``(``10``):``        ``SmallestNumber[i] ``=` `sys.maxsize;``        ``MinimumSteps[i] ``=` `sys.maxsize` `    ``for` `i ``in` `range``(``1``,``11``,``1``):``        ``num ``=` `K ``*` `i` `        ``# Minimum number``        ``# ending with digit i``        ``SmallestNumber[num ``%` `10``] ``=` `min``(SmallestNumber[num ``%` `10``],num)` `        ``# Minimum steps to create a``        ``# number ending with digit i``        ``MinimumSteps[num ``%` `10``] ``=` `min``(MinimumSteps[num ``%` `10``], i)` `    ``# If N < SmallestNumber then,``    ``# return -1``    ``if` `(N < SmallestNumber[N ``%` `10``]):``        ``return` `-``1` `    ``# Otherwise, return answer``    ``else``:``        ``return` `MinimumSteps[N ``%` `10``]` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `42``    ``K ``=` `7``    ``print``(minCount(N, K))``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG{``    ` `    ``static` `int` `minCount(``int` `N, ``int` `K)``    ``{``        ` `        ``// Stores the smallest number that``        ``// ends with digit i (0, 9)``        ``int``[] SmallestNumber = ``new` `int``;``    ` `        ``// Stores the minimum number of``        ``// steps to create a number ending``        ``// with digit i``        ``int``[] MinimumSteps = ``new` `int``;``    ` `        ``// Initialize elements as infinity``        ``for``(``int` `i = 0; i <= 9; i++)``        ``{``            ``SmallestNumber[i] = Int32.MaxValue;``            ``MinimumSteps[i] = Int32.MaxValue;``        ``}``    ` `        ``for``(``int` `i = 1; i <= 10; i++)``        ``{``            ``int` `num = K * i;``            ` `            ``// Minimum number``            ``// ending with digit i``            ``SmallestNumber[num % 10] = Math.Min(``                ``SmallestNumber[num % 10], num);``    ` `            ``// Minimum steps to create a``            ``// number ending with digit i``            ``MinimumSteps[num % 10] = Math.Min(``                ``MinimumSteps[num % 10], i);``        ``}``    ` `        ``// If N < SmallestNumber then,``        ``// return -1``        ``if` `(N < SmallestNumber[N % 10])``        ``{``            ``return` `-1;``        ``}``    ` `        ``// Otherwise, return answer``        ``else``        ``{``            ``return` `MinimumSteps[N % 10];``        ``}``    ``}``    ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `N = 42, K = 7;``      ` `        ``Console.Write(minCount(N, K));``    ``}``}` `// This code is contributed by shubhamsingh10`

## Javascript

 ``
Output:
`6`

Time Complexity: O(1)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up