Count Alternating Subarrays - Practice Coding Problems

Count Alternating Subarrays - Problem

Array Math Medium

Given a binary array nums containing only 0s and 1s, your task is to count the number of alternating subarrays.

An alternating subarray is a contiguous subsequence where no two adjacent elements have the same value. In other words, the values must alternate between 0 and 1 throughout the subarray.

Examples of alternating patterns:

[0, 1] ✅ alternating
[1, 0, 1] ✅ alternating
[0, 0] ❌ not alternating
[1, 1, 0] ❌ not alternating

Return the total count of all possible alternating subarrays in the given array.

Note: Single elements are always considered alternating subarrays.

Input & Output

example_1.py — Basic alternating pattern

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

› Output: 5

💡 Note: The alternating subarrays are: [0], [1], [1], [1], [0,1]. Note that subarrays like [1,1] are not alternating since adjacent elements are the same.

example_2.py — Perfect alternating sequence

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

› Output: 10

💡 Note: All possible subarrays are alternating: [1], [0], [1], [0], [1,0], [0,1], [1,0], [1,0,1], [0,1,0], [1,0,1,0]. Total count = 10.

example_3.py — Single element array

$ Input: nums = [1]

› Output: 1

💡 Note: Only one subarray exists: [1], which is considered alternating by definition.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
The array contains only binary values

Visualization

Tap to expand

Understanding the Visualization

Identify Sequences

Find all maximal alternating sequences (like finding stretches of properly alternating traffic lights)

Apply Math Formula

For each sequence of length L, calculate L×(L+1)/2 total subarrays

Sum All Counts

Add up counts from all alternating sequences to get the final answer

Key Takeaway

🎯 Key Insight: By recognizing that each alternating sequence of length L contains exactly L×(L+1)/2 subarrays, we can solve this problem in linear time rather than cubic time.

Asked in

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

The optimal solution uses a sliding window approach with mathematical counting. Instead of checking every subarray individually, we find maximal alternating sequences in O(n) time. For each sequence of length L, we can calculate that it contains exactly L×(L+1)/2 subarrays using combinatorics. This reduces the time complexity from O(n³) brute force to O(n) optimal while maintaining O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray to see if it's alternating
One-Pass Sliding Window (Optimal)	O(n)	O(1)	Use sliding window to find alternating sequences and count subarrays mathematically

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through each possible starting position i
For each starting position, extend to each possible ending position j
Check if the subarray from i to j is alternating
Count valid alternating subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Check all subarrays starting from position 0

Validate Each

For each subarray, check if adjacent elements differ

Count Valid

Increment counter for alternating subarrays

Code -

solution.c — C

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

long long countAlternatingSubarrays(int* nums, int n) {
    long long count = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if subarray [i, j] is alternating
            int isAlternating = 1;
            for (int k = i; k < j; k++) {
                if (nums[k] == nums[k + 1]) {
                    isAlternating = 0;
                    break;
                }
            }
            
            if (isAlternating) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[,]\n");
    }
    
    printf("%lld\n", countAlternatingSubarrays(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all subarrays × O(n) to check each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and count

✓ Linear Space

42.4K Views

High Frequency

~15 min Avg. Time

1.8K 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 Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler