Minimum Operations to Make the Array Alternating

Minimum Operations to Make the Array Alternating - Problem

Medium

🎯 Make the Array Alternating

Imagine you have a pattern array where elements follow a specific alternating structure. Your task is to transform any given array into this special pattern with the minimum number of changes.

What makes an array "alternating"?

Elements at even positions (0, 2, 4...) must all be equal
Elements at odd positions (1, 3, 5...) must all be equal
Even and odd position values must be different from each other

For example: [2, 1, 2, 1, 2, 1] is alternating because all even indices have value 2, all odd indices have value 1, and 2 ≠ 1.

Your Mission: Given an array, determine the minimum operations needed to make it alternating, where one operation = changing any element to any positive integer.

Input & Output

example_1.py — Basic Case

$ Input: [3,1,3,2,4,1]

› Output: 2

💡 Note: Make even positions all 3: [3,1,3,2,3,1]. Make odd positions all 1: [3,1,3,1,3,1]. Total: 2 operations.

example_2.py — Already Alternating

$ Input: [1,2,1,2,1,2]

› Output: 0

💡 Note: Array is already alternating - even positions are 1, odd positions are 2, and 1 ≠ 2.

example_3.py — Single Element

$ Input: [5]

› Output: 0

💡 Note: Single element arrays are considered alternating by default.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
All values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern Positions

Separate array into even-indexed and odd-indexed elements

Count Current Patterns

Find most frequent values in each position group

Resolve Conflicts

Ensure chosen values for even/odd positions are different

Calculate Minimum Changes

Count elements that need to change to match optimal pattern

Key Takeaway

🎯 Key Insight: By treating even and odd positions separately and using frequency counting, we can find the optimal alternating pattern in linear time without testing all combinations.

Asked in

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

The optimal solution uses frequency counting to find the most common values at even and odd positions in O(n) time. Key insight: we only need to consider the top 2 most frequent values for each position type to handle conflicts where both positions want the same value.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k² × n)	O(k)	Try every possible value for even and odd positions
Frequency Counting (Optimal)	O(n)	O(k)	Count frequencies of even and odd positions, pick optimal combination

Brute Force (Try All Combinations) — Algorithm Steps

Get all unique values from the array
For each unique value as even position target:
For each different unique value as odd position target:
Count operations needed for this combination
Return minimum operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Unique Values

Find all unique values: [3, 1, 2, 4]

Try Combinations

Test each pair where even ≠ odd value

Count Operations

For each combo, count needed changes

Find Minimum

Return smallest operation count

Code -

solution.c — C

int minimumOperations(int* nums, int numsSize) {
    if (numsSize <= 1) return 0;
    
    int uniqueVals[100000];
    int uniqueCount = 0;
    
    // Find unique values
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (uniqueVals[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            uniqueVals[uniqueCount++] = nums[i];
        }
    }
    
    int minOps = INT_MAX;
    
    for (int i = 0; i < uniqueCount; i++) {
        for (int j = 0; j < uniqueCount; j++) {
            if (uniqueVals[i] != uniqueVals[j]) {
                int ops = 0;
                for (int k = 0; k < numsSize; k++) {
                    if (k % 2 == 0) {
                        if (nums[k] != uniqueVals[i]) ops++;
                    } else {
                        if (nums[k] != uniqueVals[j]) ops++;
                    }
                }
                if (ops < minOps) minOps = ops;
            }
        }
    }
    
    return minOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(k² × n)

k unique values, for each pair we scan n elements

✓ Linear Growth

Space Complexity

O(k)

Store unique values in a set

✓ Linear Space

32.0K Views

Medium Frequency

~18 min Avg. Time

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

🎯 Make the Array Alternating

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler