Skip to content
Related Articles

Related Articles

Minimum numbers with one’s place as 9 to be added to get N

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 10 Mar, 2022

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 = 27 
Output:
27 = 9 + 9 + 9

Input: N = 109 
Output:
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. 1: 9 has to be added 9 times i.e. (9 * 9 = 81).
    2. 2: 9 has to be added 8 times i.e. (9 * 8 = 72).
    3. 3: 9 has to be added 7 times i.e. (9 * 7 = 63).
    4. 4: 9 has to be added 6 times i.e. (9 * 6 = 54).
    5. 5: 9 has to be added 5 times i.e. (9 * 5 = 45).
    6. 6: 9 has to be added 4 times i.e. (9 * 4 = 36).
    7. 7: 9 has to be added 3 times i.e. (9 * 3 = 27).
    8. 8: 9 has to be added 2 times i.e. (9 * 2 = 18).
    9. 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

 

Time Complexity: O(1)

Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!