Task Scheduler - Practice Coding Problems

Task Scheduler - Problem

Array Hash Table Greedy Sorting Heap (Priority Queue) Counting Medium

🎯 CPU Task Scheduler

Imagine you're managing a CPU scheduler that needs to execute tasks efficiently while respecting cooling periods between similar operations. You have an array of tasks, each labeled with a letter from A to Z, and a cooldown number n.

Here's the challenge: identical tasks must be separated by at least n intervals. During each interval, the CPU can either:
• Execute one task, OR
• Remain idle (cooling down)

Your mission: Find the minimum number of intervals needed to complete all tasks.

Example: Tasks = ["A","A","A","B","B","B"], n = 2
Optimal schedule: A → B → idle → A → B → idle → A → B
Total intervals: 8

Input & Output

example_1.py — Basic Case

$ Input: tasks = ["A","A","A","B","B","B"], n = 2

› Output: 8

💡 Note: Optimal schedule: A -> B -> idle -> A -> B -> idle -> A -> B. The cooldown period forces idle time between identical tasks.

example_2.py — No Cooldown

$ Input: tasks = ["A","A","A","B","B","B"], n = 0

› Output: 6

💡 Note: With no cooldown required, all tasks can be executed consecutively in any order.

example_3.py — Diverse Tasks

$ Input: tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2

› Output: 16

💡 Note: Task A appears 6 times, creating the framework. Other tasks fill the cooling periods: A->B->C->A->D->E->A->F->G->A->B->C->A->D->E->A.

Visualization

Tap to expand

Understanding the Visualization

Inventory Count

Count how many items each machine type needs to process

Bottleneck Analysis

Identify the machine type with the most work (highest frequency)

Framework Design

The busiest machine creates time slots with cooling periods

Optimization

Other machines can work during cooling periods of the busiest machine

Key Takeaway

🎯 Key Insight: The most frequent task type creates the scheduling framework - other tasks can fill the cooling periods, making the solution mathematically predictable!

Time & Space Complexity

Time Complexity

⏱️

O(m)

Single pass to count tasks, O(26) to find max frequency

✓ Linear Growth

Space Complexity

O(1)

Only need to store 26 task counters (constant space)

✓ Linear Space

Constraints

1 ≤ tasks.length ≤ 10⁴
tasks[i] is an uppercase English letter
0 ≤ n ≤ 100
The number of unique tasks is at most 26

Asked in

f Facebook 45 a Amazon 38 G Google 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a mathematical formula based on the key insight that the most frequent task determines the minimum scheduling framework. Count task frequencies, find the maximum frequency, and calculate (max_freq - 1) × (n + 1) + max_count. The result is the maximum of this calculated minimum and the total number of tasks, achieving O(m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n * m²)	O(result)	Simulate the actual task execution with a timeline array
Greedy with Priority Queue	O(m log k)	O(k)	Use max heap to always schedule the most frequent remaining task
Mathematical Formula (Optimal)	O(m)	O(1)	Calculate result using mathematical formula based on task frequencies

Brute Force Simulation — Algorithm Steps

Create a timeline array to track task execution
For each task, scan the timeline to find the earliest valid slot
Check that no identical task exists within the previous n intervals
Place the task and continue until all tasks are scheduled

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty timeline

Place Task

Find earliest valid position for current task

Check Cooldown

Verify no conflicts within n intervals

Insert

Place task at valid position

Code -

solution.c — C

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

int leastInterval(char* tasks, int tasksSize, int n) {
    if (n == 0) return tasksSize;
    
    char* timeline = (char*)malloc(10000 * sizeof(char));
    int timelineSize = 0;
    
    for (int t = 0; t < tasksSize; t++) {
        char task = tasks[t];
        int pos = 0;
        int placed = 0;
        
        while (pos <= timelineSize) {
            int valid = 1;
            int start = (pos - n > 0) ? pos - n : 0;
            
            for (int i = start; i < pos; i++) {
                if (timeline[i] == task) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid) {
                // Insert at position pos
                for (int i = timelineSize; i > pos; i--) {
                    timeline[i] = timeline[i-1];
                }
                timeline[pos] = task;
                timelineSize++;
                placed = 1;
                break;
            }
            pos++;
        }
        
        if (!placed) {
            timeline[timelineSize++] = task;
        }
    }
    
    free(timeline);
    return timelineSize;
}

int main() {
    char tasks[] = {'A', 'A', 'A', 'B', 'B', 'B'};
    int n = 2;
    printf("%d\n", leastInterval(tasks, 6, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m²)

For each of m tasks, we might scan through all previous positions in worst case

✓ Linear Growth

Space Complexity

O(result)

Timeline array to store the final schedule

✓ Linear Space

Constraints

1 ≤ tasks.length ≤ 10⁴
tasks[i] is an uppercase English letter
0 ≤ n ≤ 100
The number of unique tasks is at most 26

62.0K Views

High Frequency

~25 min Avg. Time

1.5K 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler