Number of Equal Numbers Blocks - Practice Coding Problems

Number of Equal Numbers Blocks - Problem

Imagine you have a massive array where identical values are always grouped together - like sorted books on a shelf! 📚 Your job is to count how many distinct blocks of identical numbers exist.

You're given access to a BigArray class with two methods:

at(index) - Returns the value at position index
size() - Returns the total length of the array

Key Property: All occurrences of any value are adjacent. If nums[i] == nums[j] and i < j, then every element between them has the same value!

Goal: Count the number of maximal blocks where each block contains only equal values.

Example: [1,1,3,3,3,2,2] has 3 blocks: [1,1], [3,3,3], and [2,2]

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,3,3,3,2,2]

› Output: 3

💡 Note: Array has 3 distinct blocks: [1,1] (indices 0-1), [3,3,3] (indices 2-4), and [2,2] (indices 5-6). Each block contains only equal values and is maximal.

example_2.py — Single Element

$ Input: nums = [5]

› Output: 1

💡 Note: Array contains only one element, forming exactly one block [5].

example_3.py — All Different

$ Input: nums = [1,2,3,4,5]

› Output: 5

💡 Note: Each element forms its own block since all elements are different: [1], [2], [3], [4], [5].

Visualization

Tap to expand

Understanding the Visualization

Start Reading

Begin with the first book, initialize block count to 1

Compare Titles

Compare each book title with the previous one

Count Transitions

When title changes, increment the block counter

Repeat until all books are processed

Key Takeaway

🎯 Key Insight: Since identical values are guaranteed to be grouped together, we only need to detect transitions between adjacent elements to count all blocks efficiently in one pass!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must read every element once to identify all blocks

✓ Linear Growth

Space Complexity

O(n)

Potentially stores all elements in memory

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10¹⁵
-10⁹ ≤ nums[i] ≤ 10⁹
All occurrences of any value are adjacent (grouped together)
For testing purposes, arrays with length > 10 have undefined behavior

Asked in

G Google 28 f Facebook 22 a Amazon 18 ⊞ Microsoft 15 Apple 12

The optimal approach is to iterate through the array once, comparing each element with the previous one. When values change, increment the block counter. This achieves O(n) time complexity with O(1) space. For very large blocks, binary search optimization can reduce the number of array accesses by jumping to block boundaries efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Elements)	O(n)	O(n)	Access every element and group them by comparing with all others
Binary Search Optimization	O(B log n)	O(1)	Use binary search to efficiently find block boundaries

Brute Force (Check All Elements) — Algorithm Steps

Read all elements from the BigArray
Group consecutive equal elements together
Count the number of distinct groups
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first element, set block count to 1

Compare Adjacent

Compare each element with the previous one

Count Transitions

Increment counter when values change

Code -

solution.c — C

int countBlocks(BigArray* arr) {
    if (arr->size == 0) {
        return 0;
    }
    
    int blocks = 1;
    int prevVal = arr->at(arr, 0);
    
    for (long long i = 1; i < arr->size; i++) {
        int currentVal = arr->at(arr, i);
        if (currentVal != prevVal) {
            blocks++;
            prevVal = currentVal;
        }
    }
    
    return blocks;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must read every element once to identify all blocks

✓ Linear Growth

Space Complexity

O(n)

Potentially stores all elements in memory

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10¹⁵
-10⁹ ≤ nums[i] ≤ 10⁹
All occurrences of any value are adjacent (grouped together)
For testing purposes, arrays with length > 10 have undefined behavior

28.4K Views

Medium Frequency

~15 min Avg. Time

1.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Elements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler