Minimum Array Changes to Make Differences Equal

Minimum Array Changes to Make Differences Equal - Problem

You are given an integer array nums of size n where n is even, and an integer k.

You can perform some changes on the array, where in one change you can replace any element in the array with any integer in the range from 0 to k.

You need to perform some changes (possibly none) such that the final array satisfies the following condition:

There exists an integer X such that abs(a[i] - a[n - i - 1]) = X for all (0 <= i < n).

Return the minimum number of changes required to satisfy the above condition.

Input & Output

Example 1 — Already Optimal

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

› Output: 0

💡 Note: Pairs are (1,3) with diff=2 and (2,4) with diff=2. Both pairs already have the same difference X=2, so 0 changes needed.

Example 2 — Need Some Changes

$ Input: nums = [0,1,2,3], k = 3

› Output: 1

💡 Note: Pairs are (0,3) with diff=3 and (1,2) with diff=1. We can change one element to make both pairs have difference 2, requiring 1 change total.

Example 3 — Multiple Changes

$ Input: nums = [1,0,1,2], k = 2

› Output: 1

💡 Note: Pairs are (1,2) with diff=1 and (0,1) with diff=1. Both pairs already have difference 1, so 0 changes needed.

Constraints

2 ≤ nums.length ≤ 10⁵
nums.length is even
0 ≤ nums[i] ≤ k ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Input

Array [1,2,4,3] with k=4, pairs (1,3) and (2,4)

Process

Calculate differences and find common target difference

Output

Minimum changes needed: 0 (already optimal)

Key Takeaway

🎯 Key Insight: Group array elements into mirror pairs and find the difference that minimizes total changes

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to recognize this as a pairing problem where we need all pairs to have the same absolute difference. We can use frequency counting to efficiently track how many pairs need 0, 1, or 2 changes for each possible difference X. Best approach is frequency counting with Time: O(n + k), Space: O(k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Differences	O(k × n)	O(1)	Try every possible difference X from 0 to k and calculate minimum changes
Frequency Count - Optimal Solution	O(n + k)	O(k)	Count how many pairs need 0, 1, or 2 changes for each possible difference

Brute Force - Try All Differences — Algorithm Steps

Step 1: Try each possible difference X from 0 to k
Step 2: For each X, count changes needed for all pairs
Step 3: Return minimum changes across all X

Visualization

Tap to expand

Step-by-Step Walkthrough

Try X=0

Count changes needed for all pairs to have difference 0

Try X=1

Count changes needed for all pairs to have difference 1

Find Minimum

Return the X that requires fewest changes

Code -

solution.c — C

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

int solution(int* nums, int n, int k) {
    int minChanges = INT_MAX;
    
    // Try every possible difference X from 0 to k
    for (int x = 0; x <= k; x++) {
        int changes = 0;
        
        // Check each pair
        for (int i = 0; i < n / 2; i++) {
            int left = nums[i];
            int right = nums[n - 1 - i];
            int currentDiff = abs(left - right);
            
            if (currentDiff == x) {
                // Already matches, no changes needed
                continue;
            }
            
            // Try changing one element
            int canChangeOne = 0;
            // Change left to make difference x
            if ((right - x >= 0 && right - x <= k) || (right + x >= 0 && right + x <= k)) {
                canChangeOne = 1;
            }
            // Change right to make difference x
            if ((left - x >= 0 && left - x <= k) || (left + x >= 0 && left + x <= k)) {
                canChangeOne = 1;
            }
            
            if (canChangeOne) {
                changes += 1;
            } else {
                // Need to change both elements
                changes += 2;
            }
        }
        
        if (changes < minChanges) {
            minChanges = changes;
        }
    }
    
    return minChanges;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

For each of k possible differences, we check n/2 pairs

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track minimum changes

✓ Linear Space

27.9K Views

Medium Frequency

~25 min Avg. Time

845 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 Differences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler