Sum of Mutated Array Closest to Target

Sum of Mutated Array Closest to Target - Problem

Given an integer array arr and a target value target, return the integer value such that when we change all the integers larger than value in the given array to be equal to value, the sum of the array gets as close as possible (in absolute difference) to target.

In case of a tie, return the minimum such integer.

Notice that the answer is not necessarily a number from arr.

Input & Output

Example 1 — Basic Case

$ Input: arr = [4,9,3], target = 10

› Output: 3

💡 Note: When value = 3: [min(4,3), min(9,3), min(3,3)] = [3,3,3], sum = 9. When value = 4: sum = 11. Both |9-10|=1 and |11-10|=1, so return minimum value = 3.

Example 2 — Exact Target

$ Input: arr = [2,3,5], target = 10

› Output: 5

💡 Note: When value = 5: no elements change since all ≤ 5, sum = 2+3+5 = 10 = target exactly.

Example 3 — Small Target

$ Input: arr = [60864,25176,27249,21296,64451,35928,53067,25101,77699], target = 4

› Output: 0

💡 Note: Target is very small, so optimal value is 0 (makes all elements 0), giving sum closest to 4.

Constraints

1 ≤ arr.length ≤ 10⁴
1 ≤ arr[i], target ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 12 M Microsoft 10

The key insight is that the sum function is monotonic - as the mutation value increases, the sum increases. This allows us to use binary search on the answer space to efficiently find the optimal value. Time: O(n log max_val), Space: O(1).

Common Approaches

✓ Binary Search on Answer Space

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

Use binary search on the answer space (possible mutation values) since the sum function is monotonic. We can determine if a given mutation value produces a sum too high or too low, allowing binary search.

Brute Force - Try All Possible Values

⏱️ Time: O(n * max_val) Space: O(1)

For each possible value from 0 to maximum element in array, calculate the sum after mutation and track which gives closest sum to target. This ensures we check all candidates but is inefficient.

Sort + Prefix Sum Optimization

⏱️ Time: O(n²) Space: O(1)

Sort the array and use prefix sums to quickly calculate the sum after mutation for any value. This allows us to test candidates more efficiently than brute force.

Binary Search on Answer Space — Algorithm Steps

Step 1: Set search range from 0 to max(arr)
Step 2: For mid value, calculate sum after mutation
Step 3: Adjust search range based on whether sum is above/below target

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Range

Search space from 0 to max(arr)

Binary Search

Test middle values and narrow range

Find Optimal

Converge to value giving sum closest to target

Code -

solution.c — C

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

int calculateSum(int* arr, int arrSize, int val) {
    int sum = 0;
    for (int i = 0; i < arrSize; i++) {
        sum += (arr[i] < val) ? arr[i] : val;
    }
    return sum;
}

int solution(int* arr, int arrSize, int target) {
    if (arrSize == 0) return 0;
    
    // Find max element
    int maxVal = 0;
    for (int i = 0; i < arrSize; i++) {
        if (arr[i] > maxVal) {
            maxVal = arr[i];
        }
    }
    
    int left = 0, right = maxVal;
    int bestVal = 0;
    int bestDiff = INT_MAX;
    
    // Binary search on answer space
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int currentSum = calculateSum(arr, arrSize, mid);
        int diff = abs(currentSum - target);
        
        // Update best answer
        if (diff < bestDiff || (diff == bestDiff && mid < bestVal)) {
            bestDiff = diff;
            bestVal = mid;
        }
        
        if (currentSum < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    // Also check values around the binary search result
    int candidates[] = {left - 1, left, right, right + 1};
    for (int c = 0; c < 4; c++) {
        int val = candidates[c];
        if (val >= 0) {
            int currentSum = calculateSum(arr, arrSize, val);
            int diff = abs(currentSum - target);
            if (diff < bestDiff || (diff == bestDiff && val < bestVal)) {
                bestDiff = diff;
                bestVal = val;
            }
        }
    }
    
    return bestVal;
}

void parseArray(const char* str, int* 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;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int arr[100];
    int arrSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            arr[arrSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", solution(arr, arrSize, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log max_val)

Binary search runs log(max_val) iterations, each taking O(n) to calculate sum

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler