Number of Adjacent Elements With the Same Color

Number of Adjacent Elements With the Same Color - Problem

Array Medium

Imagine you're painting a fence with n sections, initially all unpainted (represented by 0). You'll receive a series of painting instructions, and after each instruction, you need to count how many adjacent pairs of sections have the same color.

You start with an array colors of length n where all elements are initially 0 (unpainted). You're given a 2D array queries where queries[i] = [index, color] represents:

Paint section index with the given color
Count all adjacent pairs that now have matching colors

Goal: Return an array where each element is the count of matching adjacent pairs after processing each query.

Example: If sections [1,2,2,1] exist, there's 1 matching pair: the middle two 2's are adjacent and identical.

Input & Output

example_1.py — Basic Example

$ Input: n = 4, queries = [[0,2],[1,2],[3,1],[2,2]]

› Output: [0, 1, 1, 2]

💡 Note: Initially colors = [0,0,0,0]. After [0,2]: [2,0,0,0] → 0 matches. After [1,2]: [2,2,0,0] → 1 match (positions 0,1). After [3,1]: [2,2,0,1] → 1 match. After [2,2]: [2,2,2,1] → 2 matches (positions 0,1 and 1,2).

example_2.py — Single Element

$ Input: n = 1, queries = [[0,1]]

› Output: [0]

💡 Note: With only one element, there are no adjacent pairs possible, so the answer is always 0.

example_3.py — All Same Color

$ Input: n = 3, queries = [[0,1],[1,1],[2,1]]

› Output: [0, 1, 2]

💡 Note: After [0,1]: [1,0,0] → 0 matches. After [1,1]: [1,1,0] → 1 match. After [2,1]: [1,1,1] → 2 matches (all adjacent pairs match).

Constraints

1 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ index_i < n
1 ≤ color_i ≤ 10⁵
Adjacent pairs are only counted if both colors are non-zero

Visualization

Tap to expand

Understanding the Visualization

Initial Fence

Start with unpainted fence sections [0,0,0,0]

Paint Section

Paint section 1 with color 2: [0,2,0,0] → 0 matches

Paint Adjacent

Paint section 2 with color 2: [0,2,2,0] → 1 match found!

Efficient Checking

Only check neighbors of updated section for count changes

Key Takeaway

🎯 Key Insight: When painting one fence section, only its immediate neighbors matter for counting changes - this transforms an O(n) operation into O(1)!

Asked in

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

The optimal approach uses incremental counting by tracking only the local changes when updating each position. Instead of recounting all pairs, we check only the immediate neighbors of the updated position, achieving O(1) time per query and overall O(q) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Incremental Count Update (Optimal)	O(q)	O(n)	Track count changes by only checking neighbors of the updated position
Brute Force - Recount Everything	O(q * n)	O(1)	After each query, scan the entire array to count matching adjacent pairs

Incremental Count Update (Optimal) — Algorithm Steps

Initialize count to 0 and colors array
For each query, calculate count change before updating
Check if current position matches left neighbor (subtract if true)
Check if current position matches right neighbor (subtract if true)
Update the color at the position
Check new matches with neighbors and add to count
Update total count and store result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Old Matches

Remove count for old matches with neighbors

Update Color

Paint the section with new color

Check New Matches

Add count for new matches with neighbors

Code -

solution.c — C

int* solution(int n, int** queries, int queriesSize, int* returnSize) {
    int* colors = (int*)calloc(n, sizeof(int));
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    int count = 0;
    
    for (int q = 0; q < queriesSize; q++) {
        int index = queries[q][0];
        int color = queries[q][1];
        
        // Remove old matches involving this position
        if (index > 0 && colors[index] != 0 && colors[index] == colors[index - 1]) {
            count--;
        }
        if (index < n - 1 && colors[index] != 0 && colors[index] == colors[index + 1]) {
            count--;
        }
        
        // Update color
        colors[index] = color;
        
        // Add new matches involving this position
        if (index > 0 && colors[index] != 0 && colors[index] == colors[index - 1]) {
            count++;
        }
        if (index < n - 1 && colors[index] != 0 && colors[index] == colors[index + 1]) {
            count++;
        }
        
        result[q] = count;
    }
    
    free(colors);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q)

Each query only checks 2 neighbors, taking constant time

✓ Linear Growth

Space Complexity

O(n)

Need array to store colors of n positions

⚡ Linearithmic Space

23.6K Views

Medium Frequency

~15 min Avg. Time

894 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

Incremental Count Update (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler