Minimum Score by Changing Two Elements - Practice Coding Problems

Minimum Score by Changing Two Elements - Problem

Minimum Score by Changing Two Elements

You're given an integer array nums and need to minimize its "score" by strategically changing exactly two elements.

The score of an array is calculated as:
• Low score: minimum absolute difference between any two integers
• High score: maximum absolute difference between any two integers
• Total score = low score + high score

Your goal is to change exactly two elements in the array to any values you want, then return the minimum possible score.

Example: For [1, 4, 3], the current score is 1 + 3 = 4. By changing two elements optimally, you can achieve a lower score.

Input & Output

example_1.py — Basic case

$ Input: nums = [1, 4, 3]

› Output: 0

💡 Note: We can change the array to [4, 4, 3]. The low score is min(|4-4|, |4-3|, |4-3|) = 0. The high score is max(|4-4|, |4-3|, |4-3|) = 1. The score is 0 + 1 = 1. Actually, we can do better by changing to [3, 3, 3] to get score 0 + 0 = 0.

example_2.py — Larger array

$ Input: nums = [1, 4, 7, 8, 5]

› Output: 3

💡 Note: We can change the array to [4, 4, 7, 8, 5]. The low score becomes 0 (from |4-4|) and the high score becomes 4 (from |8-4|). Total score is 0 + 4 = 4. We can do better by changing to [4, 4, 5, 5, 5] to get score 0 + 1 = 1. Even better: [4, 5, 5, 5, 5] gives us score 1 + 1 = 2. Best: [5, 5, 5, 5, 5] gives score 0 + 0 = 0, but we can only change 2 elements. Optimal is [1, 5, 5, 8, 5] with score 0 + 7 = 7. Actually optimal is [5, 4, 7, 5, 5] giving score 0 + 3 = 3.

example_3.py — Edge case

$ Input: nums = [2, 2]

› Output: 0

💡 Note: With only 2 elements both the same, the low and high scores are both 0, so total score is 0. No changes needed, but we can change both to any value and still get score 0.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
You must change exactly two elements

Visualization

Tap to expand

Understanding the Visualization

Analyze Range

Sort the 'notes' to see the full range of discord

Identify Problems

Find the extreme notes causing the most discord

Strategic Tuning

Try different tuning strategies - remove extremes or create harmony

Minimize Discord

Choose the strategy that minimizes total discord (score)

Key Takeaway

🎯 Key Insight: The optimal solution requires analyzing multiple strategic approaches - removing extremes, creating equal elements, or balancing the range. Sorting first enables systematic evaluation of these strategies.

Asked in

G Google 23 a Amazon 18 f Meta 15 Apple 12

The optimal approach involves sorting the array and systematically trying key strategies: removing extreme values, making elements equal, or eliminating outliers. The key insight is that we want to either minimize the range by removing extremes or create duplicates to make the minimum difference zero.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possibilities)	O(n⁴)	O(1)	Try changing every pair of elements to every possible value and calculate the minimum score
Sorting + Strategic Analysis	O(n log n)	O(n)	Sort array and systematically try optimal strategies for minimizing score

Brute Force (Try All Possibilities) — Algorithm Steps

Generate all possible pairs of indices to change
For each pair, try various strategic values (existing values, averages, extremes)
Calculate the score for each configuration
Return the minimum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Select pair

Choose two positions to modify

Try values

Test different values for the selected positions

Calculate

Compute the score for each combination

Track minimum

Keep track of the best score found

Code -

solution.c — C

int minimumScore(int* nums, int numsSize) {
    int minScore = INT_MAX;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            int candidates[1000];
            int candCount = 0;
            
            // Add existing values as candidates
            for (int k = 0; k < numsSize; k++) {
                candidates[candCount++] = nums[k];
            }
            candidates[candCount++] = 0;
            
            for (int c1 = 0; c1 < candCount; c1++) {
                for (int c2 = 0; c2 < candCount; c2++) {
                    int* modified = malloc(numsSize * sizeof(int));
                    memcpy(modified, nums, numsSize * sizeof(int));
                    modified[i] = candidates[c1];
                    modified[j] = candidates[c2];
                    
                    int minDiff = INT_MAX;
                    int maxDiff = 0;
                    
                    for (int a = 0; a < numsSize; a++) {
                        for (int b = a + 1; b < numsSize; b++) {
                            int diff = abs(modified[a] - modified[b]);
                            if (diff < minDiff) minDiff = diff;
                            if (diff > maxDiff) maxDiff = diff;
                        }
                    }
                    
                    int score = minDiff + maxDiff;
                    if (score < minScore) minScore = score;
                    
                    free(modified);
                }
            }
        }
    }
    
    return minScore;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n²) pairs to change × O(n²) possible values × O(n²) to calculate score

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

34.4K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler