Alternating Groups I

Alternating Groups I - Problem

There is a circle of red and blue tiles. You are given an array of integers colors. The color of tile i is represented by colors[i]:

colors[i] == 0 means that tile i is red
colors[i] == 1 means that tile i is blue

Every 3 contiguous tiles in the circle with alternating colors (the middle tile has a different color from its left and right tiles) is called an alternating group.

Return the number of alternating groups.

Note: Since colors represents a circle, the first and the last tiles are considered to be next to each other.

Input & Output

Example 1 — Basic Circle

$ Input: colors = [0,1,0,0,1]

› Output: 2

💡 Note: Position 1: colors[0,1,2] = [0,1,0] - middle 1 differs from both 0s ✓. Position 4: colors[3,4,0] = [0,1,0] - middle 1 differs from both 0s ✓. Total: 2 groups.

Example 2 — No Alternating

$ Input: colors = [0,1,1,0,1]

› Output: 1

💡 Note: Only position 3 forms alternating group: colors[2,3,4] = [1,0,1] - middle 0 differs from both 1s ✓. Other positions don't form alternating patterns.

Example 3 — All Same Color

$ Input: colors = [1,1,1]

› Output: 0

💡 Note: All tiles are same color (blue), so no middle tile can differ from its neighbors. No alternating groups possible.

Constraints

3 ≤ colors.length ≤ 100
0 ≤ colors[i] ≤ 1

Visualization

Tap to expand

Asked in

f Meta 15 G Google 12

The key insight is to check each position as the middle of a potential alternating group using modular arithmetic for circular array access. Best approach is single pass checking each position. Time: O(n), Space: O(1)

Common Approaches

✓ Single Pass Check

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

Iterate through each position and check if it forms an alternating group with its neighbors. Use modular arithmetic to handle the circular nature.

Sliding Window

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

Maintain a sliding window of 3 consecutive elements and check if the middle element differs from both neighbors. Handle circular array by extending the array conceptually.

Single Pass Check — Algorithm Steps

Iterate through each position i
Check if colors[i] differs from both neighbors
Use modulo to wrap around for circular array

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position

Examine each position as potential middle

Compare Neighbors

Check if middle differs from both neighbors

Count Groups

Increment counter for valid alternating groups

Code -

solution.c — C

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

int solution(int* colors, int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        int left = colors[(i - 1 + n) % n];
        int middle = colors[i];
        int right = colors[(i + 1) % n];
        
        if (middle != left && middle != right) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int colors[1000];
    int n = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token) {
            colors[n++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int result = solution(colors, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through all n positions

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

450 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

Single Pass Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler