Alternating Groups II - Practice Coding Problems

Alternating Groups II - Problem

Imagine a circular necklace made of red and blue beads arranged in a perfect circle. Your task is to find all the alternating patterns of exactly k consecutive beads where no two adjacent beads have the same color!

You're given:

An array colors where colors[i] = 0 represents a red bead and colors[i] = 1 represents a blue bead
An integer k representing the length of each group to check

What makes a valid alternating group?
A group of k consecutive beads is alternating if each bead (except the first and last) has a different color from both its neighbors. Since the beads form a circle, the last bead connects back to the first bead.

Goal: Return the total number of valid alternating groups of size k.

Input & Output

example_1.py — Basic alternating pattern

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

› Output: 3

💡 Note: The alternating groups are [0,1,0] starting at index 0, [1,0,1] starting at index 1, and [0,1,0] starting at index 2 (wrapping around). Each group has exactly 3 elements with alternating colors.

example_2.py — Broken alternating sequence

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

› Output: 0

💡 Note: No group of 4 consecutive elements has alternating colors. The sequence breaks at positions 2-3 where we have [0,0], so no valid alternating group of length 4 exists.

example_3.py — Single element groups

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

› Output: 4

💡 Note: When k=1, every single element forms a valid alternating group by definition. There are 4 elements, so we have 4 groups.

Constraints

3 ≤ colors.length ≤ 10⁵
colors[i] is either 0 or 1
1 ≤ k ≤ colors.length
The array represents a circular arrangement

Visualization

Tap to expand

Understanding the Visualization

Walk around the circle

Start at any bead and walk around the circular necklace, comparing each bead with its neighbor

Track alternating streaks

Keep count of how many consecutive beads alternate in color - this is your 'streak length'

Identify valid patterns

Whenever your streak length reaches k or more, you've found locations where k-length alternating patterns exist

Count all possibilities

A streak of length L contains (L-k+1) different k-length alternating patterns starting at different positions

Key Takeaway

🎯 Key Insight: Instead of checking each k-window separately (O(nk)), track the alternating streak length in a single pass (O(n)). A streak of length L≥k contains exactly (L-k+1) valid k-windows!

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal sliding window approach solves this in O(n) time by tracking alternating streak lengths instead of checking each window independently. Key insight: a streak of length L ≥ k contains (L - k + 1) valid k-windows, and we handle circularity by processing n + k - 1 elements total.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Window)	O(n*k)	O(1)	Check each possible k-length window independently
Sliding Window (Optimal)	O(n)	O(1)	Track alternating streak lengths using a single pass with sliding window technique

Brute Force (Check Every Window) — Algorithm Steps

Iterate through each possible starting position (0 to n-1)
For each starting position, check the next k elements
Use modulo to handle circular wraparound
Verify that each adjacent pair has different colors
Count valid alternating groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check k consecutive elements starting from index 0

Move to position 1

Check k consecutive elements starting from index 1

Continue for all positions

Repeat for each starting position in the circular array

Count valid groups

Increment counter for each alternating group found

Code -

solution.c — C

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

int numberOfAlternatingGroups(int* colors, int n, int k) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        // Check if k consecutive elements starting at i form alternating group
        int isAlternating = 1;
        for (int j = 1; j < k; j++) {
            int currIdx = (i + j) % n;
            int prevIdx = (i + j - 1) % n;
            if (colors[currIdx] == colors[prevIdx]) {
                isAlternating = 0;
                break;
            }
        }
        
        if (isAlternating) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for JSON input
    int colors[100];
    int n = 0, k = 0;
    
    char* ptr = strstr(line, "[");
    if (ptr) {
        ptr++;
        char* endPtr = strstr(ptr, "]");
        *endPtr = '\0';
        
        char* token = strtok(ptr, ",");
        while (token != NULL) {
            colors[n++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    ptr = strstr(line, ":k":");
    if (ptr) {
        k = atoi(ptr + 3);
    }
    
    printf("%d\n", numberOfAlternatingGroups(colors, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We check n possible starting positions, and for each position we examine k elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

867 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 Every Window) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler