Alternating Groups I - Practice Coding Problems

Alternating Groups I - Problem

Imagine a beautiful circular mosaic made of red and blue tiles arranged in a perfect circle. You're tasked with finding all the alternating groups - special patterns where three consecutive tiles create a striking visual contrast.

Given an array colors representing the circular arrangement of tiles:

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

An alternating group is formed by any 3 consecutive tiles where the middle tile has a different color from both its neighbors. Since the tiles form a circle, the first and last tiles are considered adjacent.

Goal: Count how many alternating groups exist in this circular mosaic.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The alternating groups are: [0,1,0] at positions (0,1,2), [1,0,0] at positions (1,2,3), and [1,0,1] at positions (4,0,1) due to circular nature.

example_2.py — All Same Color

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

› Output: 0

💡 Note: No alternating groups exist since all tiles have the same color. No middle tile can differ from its neighbors.

example_3.py — Alternating Pattern

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

› Output: 4

💡 Note: All possible groups of 3 are alternating: [0,1,0], [1,0,1], [0,1,0], and [1,0,1] (circular wrapping).

Constraints

3 ≤ colors.length ≤ 100
colors[i] is either 0 or 1
Note: The array represents a circular arrangement

Visualization

Tap to expand

Understanding the Visualization

Circular Setup

Arrange tiles in a circle where first and last tiles are adjacent

Pattern Recognition

Look for groups where middle tile differs from both neighbors

Count Valid Groups

Each position can be the center of at most one alternating group

Handle Boundaries

Use modulo arithmetic to seamlessly handle circular wrapping

Key Takeaway

🎯 Key Insight: In a circular array, we can check each position as a potential middle tile of an alternating group, using modulo arithmetic to handle the circular boundary seamlessly.

Asked in

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

This problem is solved optimally with a single pass approach in O(n) time. The key insight is treating each tile as the potential middle of an alternating group and checking if it differs from both neighbors using modulo arithmetic for circular indexing.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Triplets)	O(n)	O(1)	Check every possible group of 3 consecutive tiles individually
Single Pass Optimization	O(n)	O(1)	Process each tile once as the middle of a potential alternating group

Brute Force (Check All Triplets) — Algorithm Steps

Iterate through each possible starting position (0 to n-1)
For each position, extract the triplet using modulo for circular indexing
Check if middle tile differs from both neighbors
Count valid alternating groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check triplet starting at index 0: tiles [0,1,2]

Move to position 1

Check triplet starting at index 1: tiles [1,2,3]

Handle circular wrapping

When reaching the end, wrap around using modulo arithmetic

Count valid groups

Increment counter when middle tile differs from both neighbors

Code -

solution.c — C

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

int numberOfAlternatingGroups(int* colors, int n) {
    if (n < 3) return 0;
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        // Get three consecutive tiles in circular array
        int left = colors[i];
        int middle = colors[(i + 1) % n];
        int right = colors[(i + 2) % n];
        
        // Check if middle tile differs from both neighbors
        if (middle != left && middle != right) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int colors[1000];
    int n = 0;
    int color;
    while (scanf("%d", &color) == 1) {
        colors[n++] = color;
    }
    printf("%d\n", numberOfAlternatingGroups(colors, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We check each of the n possible starting positions once, each check is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track count and indices

✓ Linear Space

24.6K Views

Medium Frequency

~12 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 (Check All Triplets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler