Minimum Cost to Move Chips to The Same Position

Minimum Cost to Move Chips to The Same Position - Problem

Imagine you have n poker chips scattered across different positions on a number line. Your goal is to gather all chips at the same position with minimal cost.

You have two types of moves available:

Free moves: Move a chip 2 positions left or right (position ± 2) at zero cost
Costly moves: Move a chip 1 position left or right (position ± 1) at cost = 1

Given an array position where position[i] represents the location of the i-th chip, return the minimum cost needed to move all chips to the same position.

Key insight: Since moving 2 positions is free, you can think of positions as either "even" or "odd". Moving between even positions (or between odd positions) costs nothing, but moving from even to odd (or vice versa) costs exactly 1.

Input & Output

example_1.py — Basic Case

$ Input: position = [1,2,3]

› Output: 1

💡 Note: Move chip at position 2 to position 1 (cost 1) or position 3 (cost 1). All other moves are free since they involve ±2 steps. Even positions: 1 chip at 2, Odd positions: 2 chips at 1,3. Answer = min(1,2) = 1

example_2.py — All Same Parity

$ Input: position = [2,2,2,3,3]

› Output: 2

💡 Note: Even positions: 3 chips at position 2. Odd positions: 2 chips at position 3. To gather all chips, move the 2 odd chips to even positions (each costs 1). Answer = min(3,2) = 2

example_3.py — Single Chip

$ Input: position = [1]

› Output: 0

💡 Note: Only one chip, so it's already gathered at one position. No moves needed. Answer = 0

Constraints

1 ≤ chips.length ≤ 100
1 ≤ chips[i] ≤ 10⁹
Note: The large constraint on position values (up to 10⁹) hints that we shouldn't iterate through all positions

Visualization

Tap to expand

Understanding the Visualization

Understand Movement Costs

±2 moves are free, ±1 moves cost 1. This means switching between even/odd parity always costs exactly 1.

Group by Parity

Separate chips into even and odd position groups. Within each group, all chips can reach each other for free.

Choose Strategy

Either move all even chips to odd positions, or vice versa. Choose the cheaper option.

Calculate Result

The minimum cost is always min(even_count, odd_count).

Key Takeaway

🎯 Key Insight: Since ±2 moves are free, positions are essentially either 'even type' or 'odd type'. The minimum cost is always the count of the minority group.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution recognizes that since moving ±2 positions costs 0, we only need to consider the parity (even/odd) of positions. Count chips at even vs odd positions, then move the smaller group to join the larger group. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Count Even vs Odd (Greedy)	O(n)	O(1)	Count chips at even vs odd positions, move the smaller group
Brute Force (Try All Positions)	O(n²)	O(1)	Try every possible final position and calculate the minimum cost

Optimal: Count Even vs Odd (Greedy) — Algorithm Steps

Count how many chips are at even positions
Count how many chips are at odd positions
The optimal solution moves all chips from the smaller group to join the larger group
Return min(even_count, odd_count)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count by Parity

Even positions: [2, 4] = 2 chips, Odd positions: [1, 3, 5] = 3 chips

Identify Minority

Even count (2) < Odd count (3), so move even chips

Calculate Cost

Cost = min(2, 3) = 2. Move 2 chips from even to odd positions

Result

All chips can be at odd positions with cost 2

Code -

solution.c — C

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

int minCostToMoveChips(int* position, int positionSize) {
    int evenCount = 0;
    int oddCount = 0;
    
    // Count chips at even vs odd positions
    for (int i = 0; i < positionSize; i++) {
        if (position[i] % 2 == 0) {
            evenCount++;
        } else {
            oddCount++;
        }
    }
    
    // Move the smaller group to join the larger group
    return evenCount < oddCount ? evenCount : oddCount;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for [1,2,3] format
    int position[100];
    int size = 0;
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        position[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", minCostToMoveChips(position, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to count even and odd positions

✓ Linear Growth

Space Complexity

O(1)

Only using two counters for even and odd positions

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Optimal: Count Even vs Odd (Greedy) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler