Maximum Consecutive Floors Without Special Floors

Maximum Consecutive Floors Without Special Floors - Problem

Array Sorting Medium

Alice manages a company and has rented a contiguous range of floors in a skyscraper for office space. She has designated some of these floors as "special floors" for relaxation and recreation only.

Given two integers bottom and top representing the inclusive range of floors Alice has rented, and an integer array special where special[i] represents a floor designated for relaxation, find the maximum number of consecutive regular office floors (floors that are NOT special).

Goal: Find the largest gap between special floors to maximize consecutive workspace.

Example: If Alice rented floors 2-9 and floors [4, 6] are special, the consecutive sequences are [2,3], [5], [7,8,9] with lengths 2, 1, 3 respectively. The answer is 3.

Input & Output

example_1.py — Basic case

$ Input: bottom = 2, top = 9, special = [4, 6]

› Output: 3

💡 Note: The floors are [2,3,4,5,6,7,8,9] where 4 and 6 are special. The consecutive sequences of regular floors are [2,3], [5], [7,8,9] with lengths 2, 1, 3. Maximum is 3.

example_2.py — No special floors

$ Input: bottom = 6, top = 8, special = []

› Output: 3

💡 Note: All floors [6,7,8] are regular, so the maximum consecutive count is 3.

example_3.py — All floors are special

$ Input: bottom = 1, top = 3, special = [1, 2, 3]

› Output: 0

💡 Note: All floors are special, so there are no consecutive regular floors.

Visualization

Tap to expand

Understanding the Visualization

Sort Reserved Spots

Arrange all special floors in ascending order to easily identify gaps

Check Beginning Gap

Count floors from the start (bottom) to the first special floor

Check Middle Gaps

For each pair of consecutive special floors, count the floors between them

Check Ending Gap

Count floors from the last special floor to the end (top)

Return Maximum

The largest gap represents the maximum consecutive regular floors

Key Takeaway

🎯 Key Insight: Instead of checking every possible range, we only need to examine the gaps between sorted special floors, making the solution much more efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the special floors array dominates the time complexity

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (excluding input)

✓ Linear Space

Constraints

1 ≤ bottom ≤ top ≤ 10⁹
0 ≤ special.length ≤ 10⁵
bottom ≤ special[i] ≤ top
All values in special are unique
special is given in any order (not necessarily sorted)

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 35 f Meta 28

The optimal approach sorts the special floors and analyzes the gaps: before the first special floor, between consecutive special floors, and after the last special floor. This achieves O(n log n) time complexity and efficiently finds the maximum consecutive regular floors by focusing on the gaps rather than checking every possible range.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Solution (Sorting + Gap Analysis)	O(n log n)	O(1)	Sort special floors and find maximum gap between consecutive special floors
Brute Force (Check Every Range)	O(n²)	O(1)	For each possible starting floor, count consecutive non-special floors

Optimal Solution (Sorting + Gap Analysis) — Algorithm Steps

Sort the special floors array
Calculate gap before first special floor: (first_special - bottom)
For each pair of consecutive special floors, calculate gap: (next - current - 1)
Calculate gap after last special floor: (top - last_special)
Return the maximum of all calculated gaps

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort special floors

Arrange special floors in ascending order

Check gap before first

Calculate floors from bottom to first special

Check gaps between

Find gaps between consecutive special floors

Check gap after last

Calculate floors from last special to top

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int maxConsecutive(int bottom, int top, int* special, int specialLen) {
    if (specialLen == 0) {
        return top - bottom + 1;
    }
    
    qsort(special, specialLen, sizeof(int), compare);
    int maxGap = 0;
    
    // Gap before first special floor
    int gap = special[0] - bottom;
    if (gap > maxGap) {
        maxGap = gap;
    }
    
    // Gaps between consecutive special floors
    for (int i = 1; i < specialLen; i++) {
        gap = special[i] - special[i-1] - 1;
        if (gap > maxGap) {
            maxGap = gap;
        }
    }
    
    // Gap after last special floor
    gap = top - special[specialLen - 1];
    if (gap > maxGap) {
        maxGap = gap;
    }
    
    return maxGap;
}

int main() {
    int bottom, top;
    scanf("%d %d", &bottom, &top);
    
    int special[1000];
    int specialLen = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        special[specialLen++] = num;
    }
    
    printf("%d\n", maxConsecutive(bottom, top, special, specialLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the special floors array dominates the time complexity

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (excluding input)

✓ Linear Space

Constraints

1 ≤ bottom ≤ top ≤ 10⁹
0 ≤ special.length ≤ 10⁵
bottom ≤ special[i] ≤ top
All values in special are unique
special is given in any order (not necessarily sorted)

42.4K Views

Medium 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal Solution (Sorting + Gap Analysis) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler