Minimum Score by Changing Two Elements

Minimum Score by Changing Two Elements - Problem

You are given an integer array nums.

The low score of nums is the minimum absolute difference between any two integers.

The high score of nums is the maximum absolute difference between any two integers.

The score of nums is the sum of the high and low scores.

Return the minimum score after changing two elements of nums.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: Change nums to [4,4,4]. Low score = 0 (min difference), High score = 0 (max-min), Total = 0+0 = 0

Example 2 — Different Values

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

› Output: 3

💡 Note: Change to [4,4,5,5,5]. Low score = 1 (difference between 4 and 5), High score = 1 (5-4), Total = 1+1 = 2. Actually optimal is changing to get score 3.

Example 3 — Small Array

$ Input: nums = [10,20]

› Output: 0

💡 Note: Change both elements to same value, e.g., [20,20]. Low score = 0, High score = 0, Total = 0

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15

The key insight is that after sorting, we only need to consider three strategic patterns: removing the two smallest elements, removing the two largest elements, or removing one from each end. The optimal approach sorts first then tries these three cases. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force

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

For each pair of positions, try all possible values and calculate the resulting score. This explores every possible combination but is very slow.

Optimized Greedy

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

Sort the array first, then try specific patterns: removing the two smallest, two largest, or one from each end. This covers all optimal scenarios without exhaustive search.

Sort and Strategic Removal

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

Sort the array to see the natural order, then strategically change the two most extreme elements (smallest/largest) to minimize both the range and minimum difference.

Brute Force — Algorithm Steps

For each pair of indices (i,j)
Try different values at these positions
Calculate low score (min difference) and high score (max difference)
Track minimum total score

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Positions

Select two positions to change

Try Values

Test all possible values at those positions

Calculate Score

Find min and max differences, sum them

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int minScore = INT_MAX;
    
    // Try changing every pair of elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Try different values for positions i and j
            for (int k = 0; k < n; k++) {
                for (int l = 0; l < n; l++) {
                    int val1 = nums[k], val2 = nums[l];
                    
                    // Create modified array
                    int modified[1000];
                    for (int m = 0; m < n; m++) {
                        modified[m] = nums[m];
                    }
                    modified[i] = val1;
                    modified[j] = val2;
                    
                    // Calculate low score (min difference)
                    int low = INT_MAX;
                    for (int x = 0; x < n; x++) {
                        for (int y = x + 1; y < n; y++) {
                            int diff = abs(modified[x] - modified[y]);
                            if (diff < low) low = diff;
                        }
                    }
                    
                    // Calculate high score (max difference)
                    int minVal = modified[0], maxVal = modified[0];
                    for (int m = 0; m < n; m++) {
                        if (modified[m] < minVal) minVal = modified[m];
                        if (modified[m] > maxVal) maxVal = modified[m];
                    }
                    int high = maxVal - minVal;
                    
                    // Update minimum score
                    if (low + high < minScore) {
                        minScore = low + high;
                    }
                }
            }
        }
    }
    
    return minScore;
}

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[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Nested loops: choose 2 positions (O(n²)), try values (O(n²))

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler