Given an integer **N**, the task is to find the minimum count of numbers which needs to be added to get **N**. (All such numbers must have **9** as one’s digit)

**Examples:**

Input:N = 27Output:3

27 = 9 + 9 + 9

Input:N = 109Output:1

109 itself has 9 as one’s digit.

**Approach:**

- Check the one’s digit of
**N**, based on one’s digit the minimum count of numbers which needs to be added can be easily found. - If one’s digit is
**9:**The answer will**1**as the number itself has**9**as its one’s place digit. - If one’s digit is:
**1:**9 has to be added 9 times i.e. (9 * 9 = 81).**2:**9 has to be added 8 times i.e. (9 * 8 = 72).**3:**9 has to be added 7 times i.e. (9 * 7 = 63).**4:**9 has to be added 6 times i.e. (9 * 6 = 54).**5:**9 has to be added 5 times i.e. (9 * 5 = 45).**6:**9 has to be added 4 times i.e. (9 * 4 = 36).**7:**9 has to be added 3 times i.e. (9 * 3 = 27).**8:**9 has to be added 2 times i.e. (9 * 2 = 18).**0:**9 has to be added 10 times i.e. (9 * 10 = 90).

- Observation here is that only the minimum multiple count for all the cases above mentioned have to be added. This is because say for one’s digit as
**4**, all**9**(one’s place) from 6 numbers can be used and the result can be subtracted from**N**say it is**M**. Now,**M**will have**0**in one’s place. So, just use**5**numbers as**9**and sixth number as**(M + 9)**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find minimum count` `// of numbers(with one's digit 9)` `// that sum up to N` `int` `findMin(` `int` `N)` `{` ` ` `// Fetch one's digit` ` ` `int` `digit = N % 10;` ` ` `// Apply Cases mentioned in approach` ` ` `switch` `(digit) {` ` ` `case` `0:` ` ` `if` `(N >= 90)` ` ` `return` `10;` ` ` `break` `;` ` ` `case` `1:` ` ` `if` `(N >= 81)` ` ` `return` `9;` ` ` `break` `;` ` ` `case` `2:` ` ` `if` `(N >= 72)` ` ` `return` `8;` ` ` `break` `;` ` ` `case` `3:` ` ` `if` `(N >= 63)` ` ` `return` `7;` ` ` `break` `;` ` ` `case` `4:` ` ` `if` `(N >= 54)` ` ` `return` `6;` ` ` `break` `;` ` ` `case` `5:` ` ` `if` `(N >= 45)` ` ` `return` `5;` ` ` `break` `;` ` ` `case` `6:` ` ` `if` `(N >= 36)` ` ` `return` `4;` ` ` `break` `;` ` ` `case` `7:` ` ` `if` `(N >= 27)` ` ` `return` `3;` ` ` `break` `;` ` ` `case` `8:` ` ` `if` `(N >= 18)` ` ` `return` `2;` ` ` `break` `;` ` ` `case` `9:` ` ` `if` `(N >= 9)` ` ` `return` `1;` ` ` `break` `;` ` ` `}` ` ` `// If no possible answer exists` ` ` `return` `-1;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `N = 27;` ` ` `cout << findMin(N);` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` ` ` ` ` `// Function to find minimum count` ` ` `// of numbers(with one's digit 9)` ` ` `// that sum up to N` ` ` `static` `int` `findMin(` `int` `N)` ` ` `{` ` ` `// Fetch one's digit` ` ` `int` `digit = N % ` `10` `;` ` ` ` ` `// Apply Cases mentioned in approach` ` ` `switch` `(digit)` ` ` `{` ` ` `case` `0` `:` ` ` `if` `(N >= ` `90` `)` ` ` `return` `10` `;` ` ` `break` `;` ` ` `case` `1` `:` ` ` `if` `(N >= ` `81` `)` ` ` `return` `9` `;` ` ` `break` `;` ` ` `case` `2` `:` ` ` `if` `(N >= ` `72` `)` ` ` `return` `8` `;` ` ` `break` `;` ` ` `case` `3` `:` ` ` `if` `(N >= ` `63` `)` ` ` `return` `7` `;` ` ` `break` `;` ` ` `case` `4` `:` ` ` `if` `(N >= ` `54` `)` ` ` `return` `6` `;` ` ` `break` `;` ` ` `case` `5` `:` ` ` `if` `(N >= ` `45` `)` ` ` `return` `5` `;` ` ` `break` `;` ` ` `case` `6` `:` ` ` `if` `(N >= ` `36` `)` ` ` `return` `4` `;` ` ` `break` `;` ` ` `case` `7` `:` ` ` `if` `(N >= ` `27` `)` ` ` `return` `3` `;` ` ` `break` `;` ` ` `case` `8` `:` ` ` `if` `(N >= ` `18` `)` ` ` `return` `2` `;` ` ` `break` `;` ` ` `case` `9` `:` ` ` `if` `(N >= ` `9` `)` ` ` `return` `1` `;` ` ` `break` `;` ` ` `}` ` ` ` ` `// If no possible answer exists` ` ` `return` `-` `1` `;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `int` `N = ` `27` `;` ` ` ` ` `System.out.println(findMin(N));` ` ` `}` `}` `// This code is contributed by AnkitRai01` |

## Python3

`# Python3 implementation of the approach` `# Function to find minimum count` `# of numbers(with one's digit 9)` `# that sum up to N` `def` `findMin(N: ` `int` `):` ` ` `# Fetch one's digit` ` ` `digit ` `=` `N ` `%` `10` ` ` `# Apply Cases mentioned in approach` ` ` `if` `digit ` `=` `=` `0` `and` `N >` `=` `90` `:` ` ` `return` `10` ` ` `elif` `digit ` `=` `=` `1` `and` `N >` `=` `81` `:` ` ` `return` `9` ` ` `elif` `digit ` `=` `=` `2` `and` `N >` `=` `72` `:` ` ` `return` `8` ` ` `elif` `digit ` `=` `=` `3` `and` `N >` `=` `63` `:` ` ` `return` `7` ` ` `elif` `digit ` `=` `=` `4` `and` `N >` `=` `54` `:` ` ` `return` `6` ` ` `elif` `digit ` `=` `=` `5` `and` `N >` `=` `45` `:` ` ` `return` `5` ` ` `elif` `digit ` `=` `=` `6` `and` `N >` `=` `36` `:` ` ` `return` `4` ` ` `elif` `digit ` `=` `=` `7` `and` `N >` `=` `27` `:` ` ` `return` `3` ` ` `elif` `digit ` `=` `=` `8` `and` `N >` `=` `18` `:` ` ` `return` `2` ` ` `elif` `digit ` `=` `=` `9` `and` `N >` `=` `9` `:` ` ` `return` `1` ` ` `# If no possible answer exists` ` ` `return` `-` `1` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `27` ` ` `print` `(findMin(N))` `# This code is contributed by` `# sanjeev2552` |

## C#

`// C# implementation of the approach` `using` `System; ` ` ` `class` `GFG` `{` ` ` ` ` `// Function to find minimum count` ` ` `// of numbers(with one's digit 9)` ` ` `// that sum up to N` ` ` `static` `int` `findMin(` `int` `N)` ` ` `{` ` ` `// Fetch one's digit` ` ` `int` `digit = N % 10;` ` ` ` ` `// Apply Cases mentioned in approach` ` ` `switch` `(digit)` ` ` `{` ` ` `case` `0:` ` ` `if` `(N >= 90)` ` ` `return` `10;` ` ` `break` `;` ` ` `case` `1:` ` ` `if` `(N >= 81)` ` ` `return` `9;` ` ` `break` `;` ` ` `case` `2:` ` ` `if` `(N >= 72)` ` ` `return` `8;` ` ` `break` `;` ` ` `case` `3:` ` ` `if` `(N >= 63)` ` ` `return` `7;` ` ` `break` `;` ` ` `case` `4:` ` ` `if` `(N >= 54)` ` ` `return` `6;` ` ` `break` `;` ` ` `case` `5:` ` ` `if` `(N >= 45)` ` ` `return` `5;` ` ` `break` `;` ` ` `case` `6:` ` ` `if` `(N >= 36)` ` ` `return` `4;` ` ` `break` `;` ` ` `case` `7:` ` ` `if` `(N >= 27)` ` ` `return` `3;` ` ` `break` `;` ` ` `case` `8:` ` ` `if` `(N >= 18)` ` ` `return` `2;` ` ` `break` `;` ` ` `case` `9:` ` ` `if` `(N >= 9)` ` ` `return` `1;` ` ` `break` `;` ` ` `}` ` ` ` ` `// If no possible answer exists` ` ` `return` `-1;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main (String[] args)` ` ` `{` ` ` `int` `N = 27;` ` ` ` ` `Console.WriteLine(findMin(N));` ` ` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` `// Javascript implementation of the approach` `// Function to find minimum count` `// of numbers(with one's digit 9)` `// that sum up to N` `function` `findMin(N)` `{` ` ` ` ` `// Fetch one's digit` ` ` `let digit = N % 10;` ` ` `// Apply Cases mentioned in approach` ` ` `switch` `(digit)` ` ` `{` ` ` `case` `0:` ` ` `if` `(N >= 90)` ` ` `return` `10;` ` ` `break` `;` ` ` `case` `1:` ` ` `if` `(N >= 81)` ` ` `return` `9;` ` ` `break` `;` ` ` `case` `2:` ` ` `if` `(N >= 72)` ` ` `return` `8;` ` ` `break` `;` ` ` `case` `3:` ` ` `if` `(N >= 63)` ` ` `return` `7;` ` ` `break` `;` ` ` `case` `4:` ` ` `if` `(N >= 54)` ` ` `return` `6;` ` ` `break` `;` ` ` `case` `5:` ` ` `if` `(N >= 45)` ` ` `return` `5;` ` ` `break` `;` ` ` `case` `6:` ` ` `if` `(N >= 36)` ` ` `return` `4;` ` ` `break` `;` ` ` `case` `7:` ` ` `if` `(N >= 27)` ` ` `return` `3;` ` ` `break` `;` ` ` `case` `8:` ` ` `if` `(N >= 18)` ` ` `return` `2;` ` ` `break` `;` ` ` `case` `9:` ` ` `if` `(N >= 9)` ` ` `return` `1;` ` ` `break` `;` ` ` `}` ` ` `// If no possible answer exists` ` ` `return` `-1;` `}` `// Driver code` `let N = 27;` `document.write(findMin(N));` `// This code is contributed by souravmahato348` `</script>` |

**Output:**

3

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**