Minimum Moves to Make Array Complementary

Minimum Moves to Make Array Complementary - Problem

You are given an integer array nums of even length n and an integer limit. In one move, you can replace any integer from nums with another integer between 1 and limit, inclusive.

The array nums is complementary if for all indices i (0-indexed), nums[i] + nums[n - 1 - i] = target for some target value. For example, the array [1,2,3,4] is complementary because for all indices i, nums[i] + nums[n - 1 - i] = 5.

Return the minimum number of moves required to make nums complementary.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: Pairs are (1,4) with sum 5 and (2,3) with sum 5. Both pairs already sum to the same target value 5, so 0 moves are needed.

Example 2 — No Changes Needed

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

› Output: 1

💡 Note: Pairs are (1,3) with sum 4 and (4,2) with sum 6. For target sum 4, the first pair needs 0 moves and the second pair needs 1 move (change 4→2 or 2→0, but since values must be ≥1, change 4→2). Total: 1 move.

Example 3 — All Changes Required

$ Input: nums = [1,1,1,1], limit = 2

› Output: 0

💡 Note: Pairs are (1,1) with sum 2 and (1,1) with sum 2. Both pairs already sum to 2, so 0 moves are needed.

Constraints

n == nums.length
2 ≤ n ≤ 10⁵
1 ≤ limit ≤ 10⁵
1 ≤ nums[i] ≤ limit
n is even

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8

The key insight is that each pair contributes different costs for different target sums, creating cost ranges. Best approach uses difference array to efficiently track these range updates and find the minimum total cost. Time: O(n + limit), Space: O(limit)

Common Approaches

✓ Brute Force - Try All Targets

⏱️ Time: O(n × limit) Space: O(1)

For each possible target sum, iterate through all pairs and calculate how many moves are needed to make each pair sum to that target. Return the minimum moves across all targets.

Difference Array Optimization

⏱️ Time: O(n + limit) Space: O(limit)

Instead of checking each target separately, we analyze each pair's contribution to the move count across all possible targets using range updates with a difference array.

Brute Force - Try All Targets — Algorithm Steps

Try each target sum from 2 to 2*limit
For each pair, calculate moves needed for that target
Track minimum moves across all targets

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Target

Test target sum = 5

Count Moves

For each pair, calculate moves needed

Find Minimum

Track minimum across all targets

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int limit) {
    int n = numsSize;
    int minMoves = INT_MAX;
    
    // Try each possible target sum
    for (int target = 2; target <= 2 * limit; target++) {
        int moves = 0;
        
        // Check each pair
        for (int i = 0; i < n / 2; i++) {
            int left = nums[i];
            int right = nums[n - 1 - i];
            int currentSum = left + right;
            
            if (currentSum == target) {
                // No moves needed
                continue;
            } else {
                // Check if we can achieve target with one move
                int canOneMove = 0;
                
                // Try changing left to any value in [1, limit]
                int neededLeft = target - right;
                if (neededLeft >= 1 && neededLeft <= limit) {
                    canOneMove = 1;
                }
                
                // Try changing right to any value in [1, limit]
                int neededRight = target - left;
                if (neededRight >= 1 && neededRight <= limit) {
                    canOneMove = 1;
                }
                
                if (canOneMove) {
                    moves += 1;
                } else {
                    moves += 2;
                }
            }
        }
        
        if (moves < minMoves) {
            minMoves = moves;
        }
    }
    
    return minMoves;
}

int main() {
    static int nums[100000];
    int numsSize = 0;
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Parse numbers from [1,2,3,4] format
    char* p = line;
    while (*p && *p != '[') p++; // Find opening bracket
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\t') p++;
        if (*p == ']' || *p == '\0' || *p == '\n') break;
        
        // Parse number
        char* endPtr;
        long val = strtol(p, &endPtr, 10);
        if (endPtr != p) { // Successfully parsed a number
            nums[numsSize++] = (int)val;
            p = endPtr;
        } else {
            p++; // Skip invalid character
        }
    }
    
    int limit;
    scanf("%d", &limit);
    
    int result = solution(nums, numsSize, limit);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × limit)

For each of O(limit) targets, we check O(n) pairs

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking minimum

✓ Linear Space

12.0K Views

Medium Frequency

~35 min Avg. Time

234 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 Targets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler