Minimum Array Changes to Make Differences Equal

Minimum Array Changes to Make Differences Equal - Problem

You're given an even-sized integer array nums of length n, and an integer k representing the maximum value allowed in the array. Your goal is to transform this array into a perfectly symmetric one with respect to absolute differences.

In one operation, you can replace any element with any integer in the range [0, k]. You need to ensure that there exists some integer X such that:

|nums[i] - nums[n-1-i]| = X for all valid indices i

In other words, the absolute difference between each pair of elements that are symmetric about the center must be exactly the same. Return the minimum number of changes needed to achieve this beautiful symmetry.

Example: If nums = [1,0,1,2] and k = 2, pairs are (1,2) and (0,1) with differences 1 and 1 respectively - already symmetric!

Input & Output

example_1.py — Basic Case

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

› Output: 0

💡 Note: The array pairs are (1,2) and (0,1) with absolute differences 1 and 1 respectively. Since both pairs already have the same difference X=1, no changes are needed.

example_2.py — Need Changes

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

› Output: 2

💡 Note: The pairs are (0,3) with difference 3 and (1,2) with difference 1. To make all differences equal to 1, we need to change the pair (0,3) to achieve difference 1, requiring 2 changes (e.g., change to (1,2)).

example_3.py — Single Change

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

› Output: 1

💡 Note: The pairs are (1,1) with difference 0 and (0,2) with difference 2. We can make both have difference 1 by changing one element: change the first 1 to 0, making pairs (0,1) and (0,2), then change one element in (0,2) to get difference 1.

Constraints

2 ≤ nums.length ≤ 10⁵
nums.length is even
0 ≤ nums[i] ≤ k ≤ 10⁵
All elements are initially within the range [0, k]

Visualization

Tap to expand

Understanding the Visualization

Current Discord

Each pair of instruments has a different interval - some harmonious, some not

Categorize Solutions

For each pair, determine which target intervals can be achieved with 0, 1, or 2 retunings

Count Contributions

Use hash maps to track how many pairs contribute to each possible target interval

Find Harmony

Choose the target interval that requires the minimum total retunings across all pairs

Key Takeaway

🎯 Key Insight: By categorizing each pair's potential contributions to different target intervals, we can efficiently calculate the minimum total changes needed using hash maps and the cost formula: 0×zero + 1×one + 2×two.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses hash map categorization to track achievable differences with 0, 1, or 2 changes. For each pair, we categorize all possible target differences and use the formula total_cost = 0×zero + 1×one + 2×two to find the minimum. This approach runs in O(n×k) time and is the most efficient solution for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Difference Tracking (Optimal)	O(n × k)	O(k)	Smart tracking of achievable differences with 0, 1, or 2 changes using hash maps
Brute Force (Try All Differences)	O(n × k)	O(1)	Try every possible target difference from 0 to k and calculate minimum changes needed
Difference Counting with Hash Map	O(n × k)	O(k)	Count the cost of achieving each possible difference, then find the minimum

Optimized Difference Tracking (Optimal) — Algorithm Steps

For each symmetric pair, determine current difference (0 changes needed)
Find all differences achievable with exactly 1 change
Track counts using hash maps for each category (0, 1, 2 changes)
Calculate total cost for each possible target difference and return minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Categorize by Changes

For each pair, categorize all possible differences by 0, 1, or 2 changes needed

Count Contributions

Use hash maps to count how many pairs contribute to each category

Calculate Total Cost

For each target difference, calculate total cost using the formula: 0×zero + 1×one + 2×two

Find Optimal

Return the target difference with minimum total cost

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int minimumChanges(int* nums, int n, int k) {
    int* zeroChanges = (int*)calloc(k + 1, sizeof(int));
    int* oneChange = (int*)calloc(k + 1, sizeof(int));
    int totalPairs = n / 2;
    
    for (int i = 0; i < n / 2; i++) {
        int left = nums[i];
        int right = nums[n - 1 - i];
        int currentDiff = abs_val(left - right);
        
        // Track current difference (0 changes)
        zeroChanges[currentDiff]++;
        
        // Find all differences achievable with 1 change
        int* oneChangeDiffs = (int*)calloc(k + 1, sizeof(int));
        
        // Try changing left element
        for (int newLeft = 0; newLeft <= k; newLeft++) {
            int diff = abs_val(newLeft - right);
            oneChangeDiffs[diff] = 1;
        }
        
        // Try changing right element
        for (int newRight = 0; newRight <= k; newRight++) {
            int diff = abs_val(left - newRight);
            oneChangeDiffs[diff] = 1;
        }
        
        // Remove current diff (that's 0 changes, not 1)
        oneChangeDiffs[currentDiff] = 0;
        
        // Track one-change differences
        for (int diff = 0; diff <= k; diff++) {
            if (oneChangeDiffs[diff]) {
                oneChange[diff]++;
            }
        }
        
        free(oneChangeDiffs);
    }
    
    // Calculate minimum changes needed
    int minChanges = INT_MAX;
    
    // Check all possible target differences from 0 to k
    for (int targetDiff = 0; targetDiff <= k; targetDiff++) {
        // Pairs that already have targetDiff (0 changes)
        int zeroCost = zeroChanges[targetDiff];
        
        // Pairs that can achieve targetDiff with 1 change
        int oneCost = oneChange[targetDiff];
        
        // Remaining pairs need 2 changes
        int twoCost = totalPairs - zeroCost - oneCost;
        
        int totalChanges = 0 * zeroCost + 1 * oneCost + 2 * twoCost;
        if (totalChanges < minChanges) {
            minChanges = totalChanges;
        }
    }
    
    free(zeroChanges);
    free(oneChange);
    return minChanges;
}

int main() {
    int nums[] = {1, 0, 1, 2};
    int n = 4, k = 2;
    printf("%d\n", minimumChanges(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

For each pair, we consider at most O(k) possible differences achievable with 1 change

✓ Linear Growth

Space Complexity

O(k)

Hash maps store counts for at most O(k) different target differences

✓ Linear Space

31.5K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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

Optimized Difference Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler