Minimum count of numbers required with unit digit X that sums up to N

Given two integers N and X, the task is to find the minimum count of integers with sum N and having unit digit X. If no such representation exists then print -1.
Examples: 
 

Input: N = 38, X = 9 
Output:
Explanation: 
Minimum two integers are required with unit digit as X to represent as a sum equal to 38. 
38 = 19 + 19 or 38 = 29 + 9
Input: N = 6, X = 4 
Output: -1 
Explanation: 
No such representation of 
 

 

Approach: 
Follow the steps below to solve the problem: 
 

Below is the implementation of the above approach:
 



filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to calculate and return
// the minimum number of times a number
// with unit digit X needs to be added
// to get a sum N
int check(int unit_digit, int X)
{
    int times, digit;
  
    // Calculate the number of
    // additions required to get unit
    // digit of N
    for (int times = 1; times <= 10;
         times++) {
        digit = (X * times) % 10;
        if (digit == unit_digit)
            return times;
    }
  
    // If unit digit of N
    // cannot be obtained
    return -1;
}
  
// Function to return the minimum
// number required to represent N
int getNum(int N, int X)
{
    int unit_digit;
  
    // Stores unit digit of N
    unit_digit = N % 10;
  
    // Stores minimum addition
    // of X required to
    // obtain unit digit of N
    int times = check(unit_digit, X);
  
    // If unit digit of N
    // cannot be obtained
    if (times == -1)
        return times;
  
    // Otherwise
    else {
  
        // If N is greater than
        // or equal to (X*times)
        if (N >= (times * X))
  
            // Minimum count of numbers
            // that needed to represent N
            return times;
  
        // Representation not
        // possible
        else
            return -1;
    }
}
  
// Driver Code
int main()
{
    int N = 58, X = 7;
    cout << getNum(N, X) << endl;
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to implement
// the above approach
class GFG{
      
// Function to calculate and return
// the minimum number of times a number
// with unit digit X needs to be added
// to get a sum N
static int check(int unit_digit, int X)
{
    int times, digit;
  
    // Calculate the number of
    // additions required to get unit
    // digit of N
    for (times = 1; times <= 10;
                    times++) 
    {
        digit = (X * times) % 10;
        if (digit == unit_digit)
            return times;
    }
  
    // If unit digit of N
    // cannot be obtained
    return -1;
}
  
// Function to return the minimum
// number required to represent N
static int getNum(int N, int X)
{
    int unit_digit;
  
    // Stores unit digit of N
    unit_digit = N % 10;
  
    // Stores minimum addition
    // of X required to
    // obtain unit digit of N
    int times = check(unit_digit, X);
  
    // If unit digit of N
    // cannot be obtained
    if (times == -1)
        return times;
  
    // Otherwise
    else 
    {
  
        // If N is greater than
        // or equal to (X*times)
        if (N >= (times * X))
  
            // Minimum count of numbers
            // that needed to represent N
            return times;
  
        // Representation not
        // possible
        else
            return -1;
    }
}
  
// Driver Code
public static void main(String []args)
{
    int N = 58, X = 7;
    System.out.println( getNum(N, X));
}
}
  
// This code is contributed by Ritik Bansal
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
  
# Function to calculate and return
# the minimum number of times a number
# with unit digit X needs to be added
# to get a sum N
def check(unit_digit, X):
      
    # Calculate the number of additions
    # required to get unit digit of N
    for times in range(1, 11):
        digit = (X * times) % 10
        if (digit == unit_digit):
            return times
              
    # If unit digit of N
    # cannot be obtained
    return -1
  
# Function to return the minimum
# number required to represent N
def getNum(N, X):
      
    # Stores unit digit of N
    unit_digit = N % 10
  
    # Stores minimum addition
    # of X required to
    # obtain unit digit of N
    times = check(unit_digit, X)
  
    # If unit digit of N
    # cannot be obtained
    if (times == -1):
        return times
  
    # Otherwise
    else:
  
        # If N is greater than
        # or equal to (X*times)
        if (N >= (times * X)):
  
            # Minimum count of numbers
            # that needed to represent N
            return times
  
        # Representation not
        # possible
        else:
            return -1
  
# Driver Code
N = 58
X = 7
  
print(getNum(N, X))
  
# This code is contributed by Sanjit_Prasad
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to implement
// the above approach
using System;
class GFG{
      
// Function to calculate and return
// the minimum number of times a number
// with unit digit X needs to be added
// to get a sum N
static int check(int unit_digit, int X)
{
    int times, digit;
  
    // Calculate the number of
    // additions required to get unit
    // digit of N
    for (times = 1; times <= 10;
                    times++) 
    {
        digit = (X * times) % 10;
        if (digit == unit_digit)
            return times;
    }
  
    // If unit digit of N
    // cannot be obtained
    return -1;
}
  
// Function to return the minimum
// number required to represent N
static int getNum(int N, int X)
{
    int unit_digit;
  
    // Stores unit digit of N
    unit_digit = N % 10;
  
    // Stores minimum addition
    // of X required to
    // obtain unit digit of N
    int times = check(unit_digit, X);
  
    // If unit digit of N
    // cannot be obtained
    if (times == -1)
        return times;
  
    // Otherwise
    else
    {
  
        // If N is greater than
        // or equal to (X*times)
        if (N >= (times * X))
  
            // Minimum count of numbers
            // that needed to represent N
            return times;
  
        // Representation not
        // possible
        else
            return -1;
    }
}
  
// Driver Code
public static void Main()
{
    int N = 58, X = 7;
    Console.Write(getNum(N, X));
}
}
  
// This code is contributed by Code_Mech
chevron_right

Output: 
4

 

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

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.





Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :