Find Latest Group of Size M - Practice Coding Problems

Find Latest Group of Size M - Problem

Imagine you have a binary string of length n that starts with all zeros: 000...000. You're given an array arr that represents a permutation of numbers from 1 to n. At each step i, you flip the bit at position arr[i] from 0 to 1.

Your mission: Find the latest step at which there exists a contiguous group of exactly m ones that cannot be extended in either direction (surrounded by zeros or string boundaries).

Example: If arr = [3,5,1,2,4] and m = 1, the binary string evolves like this:

Step 1: 00100 → group of size 1 at position 3
Step 2: 00101 → two groups of size 1
Step 3: 10101 → three groups of size 1
Step 4: 11101 → one group of size 3, one group of size 1
Step 5: 11111 → one group of size 5

The latest step with a group of size 1 is step 4, so return 4. If no group of size m ever exists, return -1.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: At step 4, the binary string is '11101' which has groups [3,1]. The group of size 1 exists at position 4, and this is the latest step where a group of size 1 exists.

example_2.py — No Valid Group

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

› Output: -1

💡 Note: We never get exactly a group of size 3. The groups evolve as: [1] → [1,1] → [1,1,1] → [1,4] → [5]. Size 3 appears momentarily but gets merged immediately.

example_3.py — Early Maximum

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

› Output: 5

💡 Note: At step 5, all bits are set creating one group of size 5: '11111'. This is the only time we have a group of exactly size 5.

Constraints

n == arr.length
1 ≤ n ≤ 10⁵
1 ≤ arr[i] ≤ n
All integers in arr are distinct
1 ≤ m ≤ n

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with all switches off: 00000

Turn on switch 3

Binary: 00100, one group of size 1

Turn on switch 5

Binary: 00101, two groups of size 1

Turn on switch 1

Binary: 10101, three groups of size 1

Turn on switch 2

Binary: 11101, groups merge to sizes [3,1]

Track latest valid step

Remember the last step where a group of size m existed

Key Takeaway

🎯 Key Insight: Instead of rebuilding the entire state each time, track intervals and group sizes incrementally. When a bit is set, check if it merges adjacent intervals and update the size frequency counter accordingly. This reduces time complexity from O(n²) to O(n).

Asked in

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

The optimal solution uses interval tracking with hash maps to achieve O(n) time complexity. Instead of scanning the entire binary string after each step, we maintain intervals of contiguous 1's and merge them efficiently when new bits are set. A frequency counter tracks group sizes, allowing O(1) queries for groups of size m.

Common Approaches

Approach	Time	Space	Notes
✓ Interval Tracking with Hash Map (Optimal)	O(n)	O(n)	Track contiguous intervals and their sizes using efficient data structures
Brute Force Simulation	O(n²)	O(n)	Simulate each step and scan the entire string to find groups

Interval Tracking with Hash Map (Optimal) — Algorithm Steps

Initialize interval set and size frequency counter
For each step, check left and right neighbors of the position
Merge adjacent intervals if they exist
Update the frequency counter for group sizes
Track the latest step where frequency[m] > 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Intervals

Maintain active intervals [start, end] and their sizes

Check Neighbors

When setting bit i, check if i-1 or i+1 end/start intervals

Merge Intervals

Combine adjacent intervals into one larger interval

Update Counts

Update frequency counter for group sizes

Code -

solution.c — C

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

#define MAX_N 1000

typedef struct {
    int start, end;
} Interval;

int findLatestStep(int* arr, int arrSize, int m) {
    Interval intervals[MAX_N];
    int intervalCount = 0;
    int sizeCount[MAX_N + 1] = {0};
    int latestStep = -1;
    
    for (int step = 0; step < arrSize; step++) {
        int pos = arr[step] - 1;
        
        int leftIdx = -1, rightIdx = -1;
        
        // Find adjacent intervals
        for (int i = 0; i < intervalCount; i++) {
            if (intervals[i].end == pos - 1) {
                leftIdx = i;
            } else if (intervals[i].start == pos + 1) {
                rightIdx = i;
            }
        }
        
        // Calculate new interval bounds
        int newStart = (leftIdx >= 0) ? intervals[leftIdx].start : pos;
        int newEnd = (rightIdx >= 0) ? intervals[rightIdx].end : pos;
        
        // Remove old intervals from size count
        if (leftIdx >= 0) {
            int oldSize = intervals[leftIdx].end - intervals[leftIdx].start + 1;
            sizeCount[oldSize]--;
        }
        if (rightIdx >= 0) {
            int oldSize = intervals[rightIdx].end - intervals[rightIdx].start + 1;
            sizeCount[oldSize]--;
        }
        
        // Remove intervals (shift array)
        int removed = 0;
        for (int i = 0; i < intervalCount; i++) {
            if (i == leftIdx || i == rightIdx) {
                removed++;
            } else {
                intervals[i - removed] = intervals[i];
            }
        }
        intervalCount -= removed;
        
        // Add new interval
        intervals[intervalCount].start = newStart;
        intervals[intervalCount].end = newEnd;
        intervalCount++;
        
        int newSize = newEnd - newStart + 1;
        sizeCount[newSize]++;
        
        // Check for groups of size m
        if (sizeCount[m] > 0) {
            latestStep = step + 1;
        }
    }
    
    return latestStep;
}

int main() {
    int arr[] = {3, 5, 1, 2, 4};
    int m = 1;
    printf("%d\n", findLatestStep(arr, 5, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is processed once, interval operations are amortized O(1)

✓ Linear Growth

Space Complexity

O(n)

Store intervals and frequency counter

⚡ Linearithmic Space

26.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Interval Tracking with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler