Longest Well-Performing Interval - Practice Coding Problems

Longest Well-Performing Interval - Problem

Array Hash Table Stack Monotonic Stack Prefix Sum Medium

You are a workplace efficiency analyst tracking employee work hours over a period of days. Given an array hours representing the number of hours worked each day by an employee, you need to find the longest well-performing interval.

Here's what makes this interesting:

A day is considered tiring if the employee works more than 8 hours (> 8)
A day is considered non-tiring if the employee works 8 hours or less (≤ 8)
A well-performing interval is any consecutive sequence of days where there are strictly more tiring days than non-tiring days

Your task is to return the length of the longest such interval.

Example: If hours = [9,9,6,0,6,6,9], the interval from index 0 to 2 has 2 tiring days and 1 non-tiring day, making it well-performing with length 3.

Input & Output

example_1.py — Standard Case

$ Input: [9,9,6,0,6,6,9]

› Output: 3

💡 Note: The longest well-performing interval is [9,9,6] from index 0 to 2. It has 2 tiring days (9,9) and 1 non-tiring day (6), so tiring > non-tiring with length 3.

example_2.py — Single Element

$ Input: [9]

› Output: 1

💡 Note: Single tiring day forms a well-performing interval of length 1 since 1 tiring day > 0 non-tiring days.

example_3.py — No Solution

$ Input: [6,6,6]

› Output: 0

💡 Note: All days are non-tiring (≤8 hours). No interval can have more tiring days than non-tiring days, so the answer is 0.

Visualization

Tap to expand

Understanding the Visualization

Energy Transformation

Convert work hours to energy: >8 hours = +1 energy, ≤8 hours = -1 energy

Running Energy Score

Keep track of cumulative energy at each day

Find Best Streak

Use hash map to remember when you first hit each energy level

Calculate Maximum

Find the longest period with positive net energy

Key Takeaway

🎯 Key Insight: Transform the problem into finding the longest subarray with positive sum using the +1/-1 conversion, then leverage prefix sums with hash map lookups for O(n) efficiency.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map can store at most n different prefix sum values

⚡ Linearithmic Space

Constraints

1 ≤ hours.length ≤ 10⁴
0 ≤ hours[i] ≤ 16
A tiring day is when hours[i] > 8
Well-performing means tiring days > non-tiring days in the interval

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 25

The optimal solution uses a prefix sum transformation combined with a hash map. Convert tiring days (>8 hours) to +1 and non-tiring days to -1, then find the longest subarray with positive sum. The hash map stores the first occurrence of each prefix sum, allowing O(n) time complexity to find the longest well-performing interval.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Intervals)	O(n³)	O(1)	Check every possible interval and count tiring vs non-tiring days
Prefix Sum + Hash Map (Optimal)	O(n)	O(n)	Transform to +1/-1 array, use prefix sums with hash map to find longest positive subarray

Brute Force (Check All Intervals) — Algorithm Steps

For each starting index i from 0 to n-1
For each ending index j from i to n-1
Count tiring days (hours > 8) and non-tiring days (hours ≤ 8) in interval [i,j]
If tiring days > non-tiring days, update maximum length
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with interval [0,0]

Check if first day alone is well-performing

Expand to [0,1], [0,2], etc.

Check all intervals starting from index 0

Move to [1,1], [1,2], etc.

Repeat for all possible starting positions

Track maximum length

Keep track of the longest well-performing interval found

Code -

solution.c — C

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

int longestWPI(int* hours, int hoursSize) {
    int maxLength = 0;
    
    // Try all possible intervals
    for (int i = 0; i < hoursSize; i++) {
        for (int j = i; j < hoursSize; j++) {
            int tiringDays = 0;
            int nonTiringDays = 0;
            
            // Count days in current interval
            for (int k = i; k <= j; k++) {
                if (hours[k] > 8) {
                    tiringDays++;
                } else {
                    nonTiringDays++;
                }
            }
            
            // Check if it's a well-performing interval
            if (tiringDays > nonTiringDays) {
                int length = j - i + 1;
                if (length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int hours[1000];
    int size = 0;
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        hours[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", longestWPI(hours, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n) for start, O(n) for end, O(n) for counting each interval

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and maximum length

✓ Linear Space

Constraints

1 ≤ hours.length ≤ 10⁴
0 ≤ hours[i] ≤ 16
A tiring day is when hours[i] > 8
Well-performing means tiring days > non-tiring days in the interval

89.3K Views

Medium Frequency

~15 min Avg. Time

2.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

Brute Force (Check All Intervals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler