Alternating Groups II

Alternating Groups II - Problem

There is a circle of red and blue tiles. You are given an array of integers colors and an integer k.

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

An alternating group is every k contiguous tiles in the circle with alternating colors (each tile in the group except the first and last one has a different color from its left and right tiles).

Return the number of alternating groups.

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

Input & Output

Example 1 — 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. Since it's circular, indices wrap around.

Example 2 — Partial Alternating

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

› Output: 0

💡 Note: No group of 4 consecutive tiles alternates. For example, [0,1,0,0] has two consecutive 0s, so it doesn't alternate.

Example 3 — All Same Color

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

› Output: 0

💡 Note: All tiles are the same color, so no alternating groups of any size exist.

Constraints

3 ≤ colors.length ≤ 10⁵
1 ≤ k ≤ colors.length
colors[i] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is to use a sliding window approach to track alternating segments efficiently. Instead of checking each position independently, we maintain the length of current alternating sequences. When a sequence of length L alternates, it can form max(0, L-k+1) groups of size k. Best approach is sliding window with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check Every Position

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

We iterate through each possible starting position in the circular array and manually verify if the k consecutive tiles starting from that position alternate in color. Since it's circular, we use modulo arithmetic to wrap around.

Optimized

⏱️ Time: N/A Space: N/A

Sliding Window - Track Alternating Segments

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

Instead of checking each position independently, we maintain a running count of consecutive alternating tiles. When we find a segment of length L that alternates, it can form max(0, L-k+1) groups of size k. We handle the circular nature by extending the array.

Brute Force - Check Every Position — Algorithm Steps

Iterate through each starting position
For each position, check k consecutive tiles
Verify alternating pattern using modulo for circular access
Count valid alternating groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Try each position as the start of a k-length group

Check k Tiles

Verify if k consecutive tiles alternate in color

Count Valid

Increment counter if pattern is alternating

Code -

solution.c — C

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

int countAlternatingGroups(int* colors, int n, int size) {
    if (size == 1) return n;
    if (size > n) return 0;
    
    int count = 0;
    for (int start = 0; start < n; start++) {
        int isAlternating = 1;
        for (int i = 1; i < size; i++) {
            int pos = (start + i) % n;
            int prevPos = (start + i - 1) % n;
            if (colors[pos] == colors[prevPos]) {
                isAlternating = 0;
                break;
            }
        }
        if (isAlternating) count++;
    }
    return count;
}

int* solution(int* colors, int colorsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    int resultIndex = 0;
    
    int* colorsCopy = (int*)malloc(colorsSize * sizeof(int));
    for (int i = 0; i < colorsSize; i++) {
        colorsCopy[i] = colors[i];
    }
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i][0] == 1) {
            result[resultIndex++] = countAlternatingGroups(colorsCopy, colorsSize, queries[i][1]);
        } else {
            colorsCopy[queries[i][1]] = queries[i][2];
        }
    }
    
    *returnSize = resultIndex;
    free(colorsCopy);
    return result;
}

int* parseArray(char* line, int* size) {
    *size = 0;
    if (strstr(line, "[]")) return NULL;
    
    int* result = (int*)malloc(1000 * sizeof(int));
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (isdigit(token[0]) || token[0] == '-') {
            result[(*size)++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    return result;
}

int** parseQueries(char* line, int* queryCount, int** queriesColSize) {
    *queryCount = 0;
    int** result = (int**)malloc(1000 * sizeof(int*));
    *queriesColSize = (int*)malloc(1000 * sizeof(int));
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[') {
            ptr++;
            int* query = (int*)malloc(10 * sizeof(int));
            int querySize = 0;
            
            while (*ptr && *ptr != ']') {
                if (isdigit(*ptr) || *ptr == '-') {
                    query[querySize++] = atoi(ptr);
                    while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                } else {
                    ptr++;
                }
            }
            
            result[*queryCount] = query;
            (*queriesColSize)[*queryCount] = querySize;
            (*queryCount)++;
        }
        ptr++;
    }
    return result;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int colorsSize;
    int* colors = parseArray(line1, &colorsSize);
    
    int queryCount;
    int* queriesColSize;
    int** queries = parseQueries(line2, &queryCount, &queriesColSize);
    
    int returnSize;
    int* result = solution(colors, colorsSize, queries, queryCount, queriesColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(colors);
    for (int i = 0; i < queryCount; i++) {
        free(queries[i]);
    }
    free(queries);
    free(queriesColSize);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

For each of n starting positions, we check k consecutive tiles

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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 Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler