Minimize Rounding Error to Meet Target - Practice Coding Problems

Minimize Rounding Error to Meet Target - Problem

Array Math String Greedy Sorting Medium

You're working as a financial analyst and need to adjust a list of prices to meet an exact budget target. Given an array of decimal prices [p1, p2, ..., pn] and a target sum, you must round each price to its nearest integer (either floor or ceiling) such that the total equals the target.

Your goal: Find the rounding strategy that minimizes the total rounding error while achieving the exact target sum.

The rounding error for each price is |rounded_price - original_price|. You want to minimize the sum of all rounding errors.

Return: The minimum total rounding error as a string with exactly 3 decimal places, or "-1" if it's impossible to reach the target.

Example: If prices = [0.7, 2.3, 4.9] and target = 8, you could round to [1, 2, 5] with total error = 0.3 + 0.3 + 0.1 = 0.700

Input & Output

example_1.py — Basic Case

$ Input: [0.7, 2.3, 4.9] 8

› Output: 1.000

💡 Note: We can round to [1, 2, 5] giving sum=8 and error=|1-0.7|+|2-2.3|+|5-4.9|=0.3+0.3+0.1=0.7. Or [1, 3, 4] giving error=0.3+0.7+0.9=1.9. The minimum is 1.000.

example_2.py — Impossible Case

$ Input: [2.5, 3.5] 7

› Output: -1

💡 Note: The maximum possible sum is ceil(2.5)+ceil(3.5)=3+4=7, but we'd need sum=7. Wait, this should be possible! Let me recalculate: we can get [3,4]=7. Error would be 0.5+0.5=1.000.

example_3.py — Edge Case

$ Input: [1.0, 2.0, 3.0] 6

› Output: 0.000

💡 Note: All numbers are already integers, so no rounding error. Sum is exactly 6.

Constraints

1 ≤ prices.length ≤ 10³
0 ≤ prices[i] ≤ 10⁴
0 ≤ target ≤ 10⁷
Each price has at most 3 digits after decimal point

Visualization

Tap to expand

Baseline: Give floor amounts: $2K + $4K + $1K = $7K2. Target: Need $9K total, so $2K more to allocate3. Priority: Marketing (0.8 frac) > HR (0.7 frac) > IT (0.3 frac)4. Result: Give +$1K to Marketing and HR → [$3K, $4K, $2K]Total Error: 0.2 + 0.3 + 0.3 = 0.8 (minimized!)🎯 Final AllocationMarketing: $3K ✓Error: |3-2.8| = 0.2IT: $4KError: |4-4.3| = 0.3HR: $2K ✓Error: |2-1.7| = 0.3Total: $9K ✓

Understanding the Visualization

Baseline Allocation

Give each department the floor of their request to establish minimum spend

Calculate Shortfall

Determine how much more money needed to reach target budget

Prioritize by Impact

Rank departments by how close they are to next dollar (fractional part)

Strategic Increases

Give extra dollars to departments where it minimizes disappointment

Key Takeaway

🎯 Key Insight: Greedily prioritize rounding up numbers with the largest fractional parts - they're closest to the next integer and cause minimal error when rounded up!

Asked in

G Google 35 a Amazon 28 B Bloomberg 22 ⊞ Microsoft 15

The optimal approach uses a greedy strategy: round all numbers down first, then selectively round up those with the largest fractional parts until the target is reached. This minimizes total rounding error in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(1)	Try every possible combination of floor/ceil for each number
Greedy Strategy (Optimal)	O(n log n)	O(n)	Round all numbers down first, then greedily round up those with largest fractional parts

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n combinations of rounding decisions
For each combination, calculate the sum and total error
Keep track of the minimum error among valid combinations
Return the minimum error or -1 if no valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^n possible rounding decisions

Check Each Combination

Calculate sum and error for each combination

Find Minimum

Keep track of valid combinations with minimum error

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

char* minimizeError(double* prices, int n, int target) {
    double minError = 1e9;
    int found = 0;
    
    // Try all 2^n combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        int totalSum = 0;
        double totalError = 0;
        
        for (int i = 0; i < n; i++) {
            int rounded;
            if (mask & (1 << i)) {  // Round up
                rounded = (int)ceil(prices[i]);
            } else {  // Round down
                rounded = (int)floor(prices[i]);
            }
            
            totalSum += rounded;
            totalError += fabs(rounded - prices[i]);
        }
        
        if (totalSum == target) {
            found = 1;
            if (totalError < minError) {
                minError = totalError;
            }
        }
    }
    
    char* result = malloc(20);
    if (!found) {
        strcpy(result, "-1");
    } else {
        sprintf(result, "%.3f", minError);
    }
    return result;
}

int main() {
    double prices[100];
    int n = 0;
    char line[1000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        prices[n++] = atof(token);
        token = strtok(NULL, " ");
    }
    int target;
    scanf("%d", &target);
    printf("%s\n", minimizeError(prices, n, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all 2^n combinations of rounding decisions

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing current best result and temporary calculations

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

890 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler