Minimum Addition to Make Integer Beautiful

Minimum Addition to Make Integer Beautiful - Problem

Math Greedy Medium

You are given two positive integers n and target.

An integer is considered beautiful if the sum of its digits is less than or equal to target.

Your task is to find the minimum non-negative integer x such that n + x is beautiful.

Example: If n = 16 and target = 6, then n has digit sum 1 + 6 = 7 > 6, so it's not beautiful. We need to add x = 4 to get 16 + 4 = 20, which has digit sum 2 + 0 = 2 ≤ 6.

The input guarantees that it's always possible to make n beautiful by adding some non-negative value.

Input & Output

example_1.py — Python

$ Input: n = 16, target = 6

› Output: 4

💡 Note: The digit sum of 16 is 1 + 6 = 7, which is greater than target = 6. By adding 4, we get 16 + 4 = 20, and the digit sum of 20 is 2 + 0 = 2, which is less than or equal to 6.

example_2.py — Python

$ Input: n = 467, target = 6

› Output: 33

💡 Note: The digit sum of 467 is 4 + 6 + 7 = 17 > 6. We need to add 33 to get 467 + 33 = 500. The digit sum of 500 is 5 + 0 + 0 = 5 ≤ 6.

example_3.py — Python

$ Input: n = 1, target = 1

› Output: 0

💡 Note: The digit sum of 1 is 1, which equals the target. So we don't need to add anything, the answer is 0.

Constraints

1 ≤ n ≤ 10¹²
1 ≤ target ≤ 150
The input will be generated such that it is always possible to make n beautiful

Visualization

Tap to expand

Understanding the Visualization

Identify the problem

Check if current digit sum exceeds target

Find the rounding point

Determine which digit position to round up

Execute the transformation

Round up and set trailing digits to zero

Verify and return

Calculate the difference as our answer

Key Takeaway

🎯 Key Insight: Instead of incrementing one by one, we can strategically round up to powers of 10 to create zeros and minimize digit sum efficiently.

Asked in

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

The optimal solution uses a greedy approach that strategically rounds up digits from right to left. Instead of trying every possible addition, we identify that rounding to the next power of 10 creates trailing zeros, which significantly reduces the digit sum. This approach runs in O((log n)²) time and is much more efficient than brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(k * log(n))	O(1)	Try every possible addition from 0 upwards until we find a beautiful number
Greedy Digit Manipulation (Optimal)	O((log n)²)	O(log n)	Round up digits from right to left to minimize digit sum efficiently

Brute Force (Linear Search) — Algorithm Steps

Start with x = 0
Calculate n + x and find its digit sum
If digit sum ≤ target, return x
Otherwise, increment x and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with x = 0

Check if n itself is beautiful

Increment x

Try x = 1, 2, 3... until digit sum ≤ target

Calculate digit sum

For each n + x, sum all its digits

Return first valid x

When digit sum ≤ target, we found our answer

Code -

solution.c — C

#include <stdio.h>

int digitSum(long long num) {
    int total = 0;
    while (num > 0) {
        total += num % 10;
        num /= 10;
    }
    return total;
}

long long makeIntegerBeautiful(long long n, int target) {
    long long x = 0;
    while (digitSum(n + x) > target) {
        x++;
    }
    return x;
}

int main() {
    long long n;
    int target;
    scanf("%lld %d", &n, &target);
    printf("%lld\n", makeIntegerBeautiful(n, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * log(n))

k is the number we need to add (could be very large), log(n) for digit sum calculation

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler