Minimize Rounding Error to Meet Target

Minimize Rounding Error to Meet Target - Problem

Array Math String Greedy Sorting Medium

Given an array of prices [p1, p2, ..., pn] and a target, round each price pi to Roundi(pi) so that the rounded array [Round1(p1), Round2(p2), ..., Roundn(pn)] sums to the given target.

Each operation Roundi(pi) could be either Floor(pi) or Ceil(pi).

Return the string "-1" if the rounded array is impossible to sum to target. Otherwise, return the smallest rounding error, which is defined as Σ |Roundi(pi) - pi| for i from 1 to n, as a string with three places after the decimal.

Input & Output

Example 1 — Basic Case

$ Input: prices = [0.700,2.800,4.900], target = 8

› Output: "1.000"

💡 Note: Round to [1,3,5] to get sum=9>8. Round to [1,3,4] to get sum=8 with error |1-0.7|+|3-2.8|+|4-4.9|=0.3+0.2+0.9=1.4. But round to [0,3,5] gets sum=8 with error 0.7+0.2+0.1=1.0 which is better.

Example 2 — Impossible Case

$ Input: prices = [1.000,4.000,7.000], target = 20

› Output: "-1"

💡 Note: Maximum possible sum is 1+4+7=12, which is less than target 20, so it's impossible.

Example 3 — All Integers

$ Input: prices = [1.500,2.500,3.500], target = 6

› Output: "1.500"

💡 Note: Round to [1,2,3] gives sum=6. Error is |1-1.5|+|2-2.5|+|3-3.5|=0.5+0.5+0.5=1.5.

Constraints

1 ≤ prices.length ≤ 10⁴
0 ≤ prices[i] ≤ 10⁴
0 ≤ target ≤ 5 * 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a greedy approach: calculate feasibility bounds using floor/ceiling sums, then minimize error by rounding numbers with smallest fractional parts up first. Best approach is Greedy by Fractional Part: Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n) Space: O(n)

For each price, we can either round down (floor) or round up (ceil). Generate all possible combinations and find the one that meets the target with minimum error.

Greedy by Fractional Part

⏱️ Time: O(n log n) Space: O(n)

Calculate bounds using all floors and all ceilings. If target is achievable, greedily select which numbers to round up based on their fractional parts to minimize error.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^n combinations of floor/ceil choices
For each combination, calculate sum and error
Return combination with target sum and minimum error

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create 2^n combinations of floor/ceil choices

Check Each

Calculate sum and error for each combination

Find Best

Return combination with target sum and minimum error

Code -

solution.c — C

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

typedef struct {
    double frac;
    int index;
} FracPair;

int compare_desc(const void* a, const void* b) {
    FracPair* fa = (FracPair*)a;
    FracPair* fb = (FracPair*)b;
    if (fa->frac > fb->frac) return -1;
    if (fa->frac < fb->frac) return 1;
    return 0;
}

char* solution(double* prices, int n, int target) {
    // Calculate floor sum and ceiling sum
    int floor_sum = 0;
    int ceil_sum = 0;
    for (int i = 0; i < n; i++) {
        floor_sum += (int)floor(prices[i]);
        ceil_sum += (int)ceil(prices[i]);
    }
    
    // Check if target is achievable
    if (target < floor_sum || target > ceil_sum) {
        char* result = malloc(20);
        strcpy(result, "-1");
        return result;
    }
    
    // Number of elements that need to be rounded up
    int need_to_round_up = target - floor_sum;
    
    // Create list of (fractional_part, index)
    FracPair* fractional_parts = malloc(n * sizeof(FracPair));
    for (int i = 0; i < n; i++) {
        double frac = prices[i] - floor(prices[i]);
        fractional_parts[i].frac = frac;
        fractional_parts[i].index = i;
    }
    
    // Sort by fractional part (descending) to minimize error
    qsort(fractional_parts, n, sizeof(FracPair), compare_desc);
    
    // Calculate minimum error
    double total_error = 0.0;
    
    for (int i = 0; i < n; i++) {
        double frac = fractional_parts[i].frac;
        if (i < need_to_round_up) {
            // Round up - error is (1 - fractional_part)
            total_error += 1.0 - frac;
        } else {
            // Round down - error is fractional_part
            total_error += frac;
        }
    }
    
    free(fractional_parts);
    
    char* result = malloc(20);
    sprintf(result, "%.3f", total_error);
    return result;
}

void parseDoubleArray(const char* str, double* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        char* endptr;
        arr[(*size)++] = strtod(p, &endptr);
        p = endptr;
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    double prices[100];
    int n = 0;
    parseDoubleArray(line, prices, &n);
    
    int target;
    scanf("%d", &target);
    
    char* result = solution(prices, n, target);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

2^n combinations, each taking O(n) time to evaluate

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary arrays

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

385 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