Sum of Numbers With Units Digit K - Practice Coding Problems

Sum of Numbers With Units Digit K - Problem

You're tasked with finding the minimum number of positive integers that satisfy two specific conditions:

Each integer must have k as its units digit (the rightmost digit)
The sum of all these integers equals num

For example, if num = 58 and k = 9, you need positive integers ending in 9 that sum to 58. You could use [9, 49] (size 2) or [9, 9, 9, 9, 22] (size 5), but the minimum size would be 2.

Goal: Return the minimum possible size of such a set, or -1 if it's impossible to create such a set.

Note: The set can contain duplicate numbers, and an empty set has sum 0.

Input & Output

example_1.py — Basic Case

$ Input: num = 58, k = 9

› Output: 2

💡 Note: We need positive integers ending in 9 that sum to 58. The optimal solution uses 2 numbers: [9, 49]. Both end in 9 and sum to 58.

example_2.py — Impossible Case

$ Input: num = 37, k = 2

› Output: -1

💡 Note: We need numbers ending in 2 to sum to 37. But any sum of numbers ending in 2 will have an even units digit (2, 4, 6, 8, 0), never 7. Therefore impossible.

example_3.py — Edge Case Zero

$ Input: num = 0, k = 7

› Output: 0

💡 Note: To get sum 0, we use an empty set (0 numbers). This is valid since the problem states an empty set sums to 0.

Visualization

Tap to expand

Understanding the Visualization

Identify the target

Extract the units digit of our target sum

Find the pattern

Calculate how many coins we need to match the target's ending digit

Verify feasibility

Check if our minimum sum doesn't exceed the target

Return the answer

The first valid pattern gives us the minimum count

Key Takeaway

🎯 Key Insight: Units digits of multiples follow predictable patterns that repeat every 10 steps, allowing us to find the answer in constant time rather than trying all possibilities.

Time & Space Complexity

Time Complexity

⏱️

O(1)

We only check at most 10 possible values since units digits repeat every 10

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space

✓ Linear Space

Constraints

0 ≤ num ≤ 3000
0 ≤ k ≤ 9
All integers in the set must be positive
The set can contain duplicate values

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses modular arithmetic to solve this in O(1) time. Since units digits follow a pattern that repeats every 10 numbers, we only need to check counts 1-10 to find the minimum valid set size. The key insight is that using n numbers ending in k produces a sum with units digit (n × k) % 10.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(num/k)	O(1)	Try all possible set sizes until we find a valid combination
Mathematical Optimization (Optimal)	O(1)	O(1)	Use modular arithmetic to directly calculate the minimum set size

Brute Force Enumeration — Algorithm Steps

Start with set size n = 1
For current size n, check if we can use n numbers ending in k
Calculate minimum possible sum: n * k (using k, k, k, ...)
Check if remaining sum (num - n*k) can be distributed in multiples of 10
If valid, return n; otherwise increment n and repeat
If n becomes too large, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with size 1

Try using just one number ending in k

Check feasibility

Verify if remaining sum can be distributed

Increment size

If current size fails, try the next larger size

Return first valid

First valid size found is the minimum

Code -

solution.c — C

#include <stdio.h>

int minimumNumbers(int num, int k) {
    if (num == 0) return 0;
    
    for (int count = 1; count <= num / k; count++) {
        int minSum = count * k;
        if (minSum > num) break;
        
        int diff = num - minSum;
        if (diff % 10 == 0) {
            return count;
        }
    }
    
    return -1;
}

int main() {
    int num, k;
    scanf("%d %d", &num, &k);
    printf("%d\n", minimumNumbers(num, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(num/k)

In worst case, we might need to check up to num/k different set sizes

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

0 ≤ num ≤ 3000
0 ≤ k ≤ 9
All integers in the set must be positive
The set can contain duplicate values

28.8K Views

Medium Frequency

~18 min Avg. Time

1.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler