Maximum Consecutive Floors Without Special Floors

Maximum Consecutive Floors Without Special Floors - Problem

Array Sorting Medium

Alice manages a company and has rented some floors of a building as office space. Alice has decided some of these floors should be special floors, used for relaxation only.

You are given two integers bottom and top, which denote that Alice has rented all the floors from bottom to top (inclusive). You are also given the integer array special, where special[i] denotes a special floor that Alice has designated for relaxation.

Return the maximum number of consecutive floors without a special floor.

Input & Output

Example 1 — 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 gaps are: floors 2-3 (2 consecutive), floors 5 (1 consecutive), floors 7-8-9 (3 consecutive). Maximum is 3.

Example 2 — No Special Floors

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

› Output: 3

💡 Note: No special floors exist, so all floors 6,7,8 are consecutive regular floors. Answer is 3.

Example 3 — All Special

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

› Output: 0

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

Constraints

1 ≤ special.length ≤ 10⁵
1 ≤ bottom ≤ special[i] ≤ top ≤ 10⁹
All the values of special are unique.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to find the maximum gap between consecutive special floors. The optimal approach sorts the special floors and checks gaps in O(s log s) time where s is the number of special floors. Best approach is Sort First: Time O(s log s), Space O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(s)

For each starting floor, expand the range until hitting a special floor. Track the maximum length found. This approach checks every possible consecutive sequence.

Sort and Check Gaps

⏱️ Time: O(s log s) Space: O(1)

Sort the special floors array and check gaps between consecutive special floors, including gaps from bottom boundary to first special floor and from last special floor to top boundary.

Brute Force — Algorithm Steps

Step 1: For each floor from bottom to top, start a consecutive sequence
Step 2: Expand sequence until hitting a special floor or boundary
Step 3: Track maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Floor 2

Start at floor 2, expand until hitting special floor

Check Floor 3

Start at floor 3, expand consecutively

Find Maximum

Track the longest sequence found

Code -

solution.c — C

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

int solution(int bottom, int top, int* special, int specialSize) {
    int maxConsecutive = 0;
    
    for (int start = bottom; start <= top; start++) {
        int isSpecial = 0;
        for (int i = 0; i < specialSize; i++) {
            if (special[i] == start) {
                isSpecial = 1;
                break;
            }
        }
        if (isSpecial) continue;
        
        int count = 0;
        int current = start;
        while (current <= top) {
            int currentIsSpecial = 0;
            for (int i = 0; i < specialSize; i++) {
                if (special[i] == current) {
                    currentIsSpecial = 1;
                    break;
                }
            }
            if (currentIsSpecial) break;
            
            count++;
            current++;
        }
        
        if (count > maxConsecutive) {
            maxConsecutive = count;
        }
    }
    
    return maxConsecutive;
}

int main() {
    int bottom, top;
    scanf("%d", &bottom);
    scanf("%d", &top);
    
    char line[10000];
    scanf(" %s", line);
    
    int special[1000];
    int specialSize = 0;
    
    if (strlen(line) > 2) {
        char* ptr = line + 1;
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            special[specialSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int result = solution(bottom, top, special, specialSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n floors, we might check up to n floors in the worst case

⚠ Quadratic Growth

Space Complexity

O(s)

Set to store special floors for O(1) lookup, where s is length of special array

✓ Linear Space

23.0K Views

Medium Frequency

~15 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler