Sum of Mutated Array Closest to Target - Practice Coding Problems

Sum of Mutated Array Closest to Target - Problem

Imagine you have an array of numbers and you need to cap some values to reach a specific target sum. Given an integer array arr and a target value, you need to find the optimal threshold value such that:

All numbers greater than the threshold get replaced with the threshold itself
All numbers less than or equal to the threshold remain unchanged
The resulting array sum is as close as possible to the target

Your goal is to return this optimal threshold value. In case of a tie (two thresholds give equally close sums), return the smaller threshold.

Important: The answer doesn't have to be a number from the original array - it can be any integer!

Example: For array [4,9,3] and target 10, if we use threshold 3, we get [3,3,3] → sum = 9. If we use threshold 4, we get [4,4,3] → sum = 11. Since |10-9| = 1 and |10-11| = 1, both are equally close, so we return the smaller threshold: 3.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: When threshold = 3: [4,9,3] becomes [3,3,3] with sum = 9. When threshold = 4: [4,9,3] becomes [4,4,3] with sum = 11. Both have distance 1 from target 10, but we return the smaller threshold: 3.

example_2.py — Exact Match

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

› Output: 5

💡 Note: When threshold = 5: [2,3,5] remains [2,3,5] with sum = 10. This exactly matches our target, so distance = 0. Answer is 5.

example_3.py — Large Threshold Needed

$ Input: arr = [60864,25176,27249,21296,64451,35842,15611,24533,18808,44838], target = 56803

› Output: 11361

💡 Note: This requires testing various thresholds to find the one that produces a sum closest to 56803. The optimal threshold turns out to be 11361.

Constraints

1 ≤ arr.length ≤ 10⁴
1 ≤ arr[i], target ≤ 10⁵
The answer is guaranteed to be unique

Visualization

Tap to expand

Understanding the Visualization

Original Requests

Employees request salaries: [4000, 9000, 3000]

Set Cap

CEO sets salary cap at 3000 (threshold = 3)

Apply Cap

Final salaries: [3000, 3000, 3000] = 9000 total

Check Target

Target budget was 10000, difference = 1000

Compare Options

Cap of 4000 gives total 11000 (diff=1000), same distance but higher cap, so prefer 3000

Key Takeaway

🎯 Key Insight: The monotonic relationship between threshold and sum allows us to use binary search, reducing time complexity from O(n × max_value) to O(n log max_value).

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 15 f Meta 12

The optimal approach uses binary search to efficiently find the threshold value. Since the sum decreases monotonically as we lower the threshold, we can search for the optimal value in O(n log max_value) time instead of trying all possibilities. The key insight is recognizing this monotonic property and leveraging it for optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Thresholds)	O(n × max_value)	O(1)	Try every possible threshold value and pick the one giving sum closest to target
Binary Search (Optimal)	O(n log n + n log(max_value))	O(1)	Use binary search to efficiently find the optimal threshold value

Brute Force (Try All Thresholds) — Algorithm Steps

Find the maximum value in the array (upper bound for threshold)
For each possible threshold from 0 to max_value:
Calculate the sum after applying this threshold
Track the threshold that gives the closest sum to target
In case of ties, prefer the smaller threshold

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with threshold = 0, track best result

Calculate Sum

For current threshold, sum all min(arr[i], threshold)

Check Distance

Compare |sum - target| with best distance found

Update Best

If closer (or tied with smaller threshold), update best

Next Threshold

Increment threshold and repeat until max value

Code -

solution.c — C

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

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

int findBestValue(int* arr, int arrSize, int target) {
    int maxVal = 0;
    for (int i = 0; i < arrSize; i++) {
        if (arr[i] > maxVal) maxVal = arr[i];
    }
    
    int bestThreshold = 0;
    int closestDiff = INT_MAX;
    
    // Try every possible threshold from 0 to maxVal
    for (int threshold = 0; threshold <= maxVal; threshold++) {
        int currentSum = calculateSum(arr, arrSize, threshold);
        int diff = abs(currentSum - target);
        
        // Update if this is closer, or same distance but smaller threshold
        if (diff < closestDiff || (diff == closestDiff && threshold < bestThreshold)) {
            closestDiff = diff;
            bestThreshold = threshold;
        }
    }
    
    return bestThreshold;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max_value)

For each of max_value possible thresholds, we scan the entire array of n elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track best threshold and closest sum

✓ Linear Space

28.7K Views

Medium Frequency

~25 min Avg. Time

986 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 Thresholds) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler