Minimum Operations to Make the Array Alternating

Minimum Operations to Make the Array Alternating - Problem

You are given a 0-indexed array nums consisting of n positive integers.

The array nums is called alternating if:

nums[i - 2] == nums[i], where 2 <= i <= n - 1.
nums[i - 1] != nums[i], where 1 <= i <= n - 1.

In one operation, you can choose an index i and change nums[i] into any positive integer.

Return the minimum number of operations required to make the array alternating.

Input & Output

Example 1 — Basic Alternating Pattern

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

› Output: 3

💡 Note: Even positions [0,2,4]: values [3,3,4] → keep 3 (appears twice), change position 4. Odd positions [1,3,5]: values [1,2,3] → keep any value, change others. Total: 1 + 2 = 3 operations.

Example 2 — Short Array

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

› Output: 2

💡 Note: Even positions [0,2,4]: values [1,2,2] → use 2, change position 0. Odd positions [1,3]: values [2,2] → use different value like 1, change both. Total: 1 + 2 = 3, but we can use 1 for odd positions: 1 + 0 = 1. Actually 1 + 1 = 2.

Example 3 — Already Alternating

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

› Output: 0

💡 Note: Array is already alternating: positions alternate between 1 and 2. No operations needed.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Meta 12 M Microsoft 15

The key insight is that an alternating array has two independent subsequences: even positions and odd positions. We count frequencies at each position type and choose the most frequent non-conflicting values. Best approach uses frequency counting in O(n) time and O(n) space.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(k^n) Space: O(n)

For each position, try all possible positive integer values and recursively check if the resulting array can be made alternating. This explores all possible combinations.

Frequency Count - Optimal Solution

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

Since alternating means even positions have same values and odd positions have same values (but different from even), we can solve this by finding the most frequent values at even and odd positions separately.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: For each position, try all possible values
Step 2: Recursively solve for remaining positions
Step 3: Return minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Try all possible values at first position

Position 1

For each choice at pos 0, try all values at pos 1

Continue

Recursively solve remaining positions

Code -

solution.c — C

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

int solve(int* nums, int n, int pos, int prevVal, int operations, int* uniqueVals, int uniqueCount) {
    if (pos == n) return operations;
    
    int minOps = INT_MAX;
    
    // Try keeping current value
    int valid = 1;
    if (pos >= 1 && nums[pos-1] == nums[pos]) valid = 0;
    if (pos >= 2 && nums[pos-2] != nums[pos]) valid = 0;
    
    if (valid || pos <= 1) {
        int result = solve(nums, n, pos + 1, nums[pos], operations, uniqueVals, uniqueCount);
        if (result < minOps) minOps = result;
    }
    
    // Try changing to each unique value
    for (int i = 0; i < uniqueCount; i++) {
        int val = uniqueVals[i];
        if (val != nums[pos]) {
            int temp = nums[pos];
            nums[pos] = val;
            
            int validChange = 1;
            if (pos >= 1 && nums[pos-1] == nums[pos]) validChange = 0;
            if (pos >= 2 && nums[pos-2] != nums[pos]) validChange = 0;
            
            if (validChange || pos <= 1) {
                int result = solve(nums, n, pos + 1, val, operations + 1, uniqueVals, uniqueCount);
                if (result < minOps) minOps = result;
            }
            
            nums[pos] = temp;
        }
    }
    
    return minOps;
}

int solution(int* nums, int n) {
    if (n <= 1) return 0;
    
    int uniqueVals[n];
    int uniqueCount = 0;
    
    for (int i = 0; i < n; 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];
        }
    }
    
    return solve(nums, n, 0, -1, 0, uniqueVals, uniqueCount);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int n = 0;
    
    char* ptr = line + 1; // Skip '['
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

For each of n positions, we try k different values, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to array length

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler