Sum of Numbers with Units Digit K in Java

The task of finding numbers whose units digit is equal to k and their sum is equal to the given num is an interesting computational problem which can be solved using different approaches in Java.

Example 1

Input

Output:

Explanation

We have to determine the minimum size of sets of integers with the unit's digit as 9 and the sum equals 58. Examples of valid sets are the sets [9, 49] and [19, 39], and others. The minimum size which can be achieved in a valid set is 2.

Example 2:

Input

Output:

-1

Explanation

We need to find the minimum size of a set of integers with unit's digit 2 that sum up to 37. It is not possible to achieve a sum of 37 using only integers with a unit's digit of 2. Hence, the output is -1.

Approach 1: Using Dynamic Programming

Dynamic Programming (DP) is a powerful technique used to solve problems by breaking them down into smaller overlapping subproblems and storing the results of these subproblems to avoid redundant calculations.

Algorithm

Step 1: We create an array dp of size num + 1 to hold the minimum number of integers required to sum up to each value from 0 to num. We set dp[0] to 0 because no numbers are needed to sum up to 0.

Step 2: All other values in dp are initialized to Integer.MAX_VALUE to signify that those sums are initially unreachable.

Step 3: Filling the DP Array: We iterate through each possible sum j from 1 to num. For each sum j, we check if we can reach j by adding integers with unit's digit k.

Step 4: The integers with unit's digit k are of the form k, k+10, k+20, and so on. For each such integer i, if dp[j - i] is not Integer.MAX_VALUE, it means we can form the sum j by adding i to the sum j - i. We update dp[j] with the minimum number of integers required.

Step 5: After processing all sums, dp[num] will hold the minimum number of integers needed to sum up to num using integers with unit's digit k.

Step 6: If dp[num] is still Integer.MAX_VALUE, it indicates that it is not possible to form the sum num with integers having units digit k, so we return -1.

Filename: SumofNumbers.java

import java.util.Arrays;
public class SumofNumbers {
    public int minimumNumbers(int num, int k) {
        if (num == 0) {
            return 0; // Edge case: If num is 0, return 0 as the minimum size (empty set).
        }
        // Initialize dp array to store minimum numbers needed to achieve each sum
        int[] dp = new int[num + 1];
        Arrays.fill(dp, Integer.MAX_VALUE); // Initialize with max value
        dp[0] = 0; // Base case: 0 numbers needed to achieve sum 0
        // Iterate through all possible sums from 1 to num
        for (int j = 1; j <= num; j++) {
            // Try adding all possible integers with units digit k (k, k+10, k+20, ...)
            for (int i = k; i <= j; i += 10) {
                if (dp[j - i] != Integer.MAX_VALUE) {
                    dp[j] = Math.min(dp[j], dp[j - i] + 1);
                }
            }
        }
        return dp[num] == Integer.MAX_VALUE ? -1 : dp[num];
    }
    public static void main(String[] args) {
        SumofNumbers solution = new SumofNumbers();
        // Test cases
        int num1 = 58, k1 = 9;
        int num2 = 37, k2 = 2;
        int num3 = 0, k3 = 7;
        System.out.println("num = " + num1 + ", k = " + k1 + ": " + solution.minimumNumbers(num1, k1)); // Expected output: 2
        System.out.println("num = " + num2 + ", k = " + k2 + ": " + solution.minimumNumbers(num2, k2)); // Expected output: -1
        System.out.println("num = " + num3 + ", k = " + k3 + ": " + solution.minimumNumbers(num3, k3)); // Expected output: 0
    }
}   

Output:

 
num = 58, k = 9: 2
num = 37, k = 2: -1
num = 0, k = 7: 0

Time Complexity

The outer loop iterates through all possible sums from 1 to num, which gives us O(num) iterations. The inner loop iterates through all integers with unit's digit k, this is a constant number of iterations (up to 10 since the unit's digit ranges from 0 to 9). Therefore, the overall time complexity is O(num×10) = O(num).

Space Complexity

We use an array dp of size num + 1 to store the minimum number of integers required to achieve each sum from 0 to num. Therefore, the space complexity is O(num).

Approach 2: Optimized Approach

The optimized approach is used to systematically check all possible solutions. It involves iterating through all possible combinations and checking each one to see if it satisfies the problem conditions. The problem requires finding the minimum number of integers with a unit's digit k that sum up to num. The units digit of a number can range from 0 to 9.

Algorithm

Step 1: Initialize minimumNumbers method to check if num is 0. If true, return 0 immediately because an empty set sums up to 0.

Step 2: Iterative Checking: Iterate over possible counts i from 1 to 10 (since the units digit can only be from 0 to 9).

Step 3: For each i, calculate i * k and check if the units digit of i * k matches the units digit of num using i * k % 10 == num % 10.

Step 4: If a match is found, return i as the minimum number of integers needed to sum up to num.

Step 5: If no valid i is found after iterating through all possibilities (1 to 10), return -1 to indicate it is not possible to form num with integers having units digit k.

Filename: SumofNumbers1.java

public class SumofNumbers1 {
    public int minimumNumbers(int num, int k) {
        if (num == 0)
            return 0; // Edge case: If num is 0, return 0 as the minimum size (empty set).
        // Iterate from 1 to 10 (since units digit can only be 0-9) and check conditions
        for (int i = 1; i <= 10; ++i) {
            if (i * k % 10 == num % 10) { // Check if i*k has the same units digit as num
                return i; // Return the minimum size found
            }
        }
        return -1; // If no valid i is found, return -1
    }
    public static void main(String[] args) {
        SumofNumbers1 solution = new SumofNumbers1();
        // Test cases
        int num1 = 58, k1 = 9;
        int num2 = 37, k2 = 2;
        int num3 = 0, k3 = 7;
        System.out.println("num = " + num1 + ", k = " + k1 + ": " + solution.minimumNumbers(num1, k1)); // Expected output: 1
        System.out.println("num = " + num2 + ", k = " + k2 + ": " + solution.minimumNumbers(num2, k2)); // Expected output: -1
        System.out.println("num = " + num3 + ", k = " + k3 + ": " + solution.minimumNumbers(num3, k3)); // Expected output: 0
    }
}   

Output:

 
num = 58, k = 9: 2
num = 37, k = 2: -1
num = 0, k = 7: 0

Time Complexity

The minimumNumbers method iterates a fixed number of times (10 iterations), regardless of the size of num or k. It is because it loops from 1 to 10 to check all possible counts of integers with unit's digit k. These operations are constant time O(1). Therefore, the overall time complexity is constant O(1).

Space Complexity

The solution uses only a few constant space variables (num, k, i, count, and remaining), each of which requires a constant amount of space regardless of the input values. The space used by these variables does not change with the input size, hence the space complexity is O(1).

Next TopicUsing-underscore-as-variable-name-in-java

← prev next →