Task Scheduler

Problem

Given a characters array tasks representing the tasks a CPU needs to do, and a cooldown interval n such that there must be at least n units of time between two same tasks, return the least number of units of time that the CPU will take to finish all the given tasks.

Examples

The brute-force approach

Simulate the scheduler. At each step, choose the most frequent task whose cooldown has expired. If none is available, insert an idle interval.

freq = Counter(tasks)
time = 0
cooldown = {}  # task -> next available time
while any freq > 0:
    available = [task for task in freq if cooldown.get(task, 0) <= time]
    if available:
        task = max(available, key=lambda t: freq[t])
        freq[task] -= 1
        cooldown[task] = time + n + 1
        if freq[task] == 0: del freq[task]
    time += 1
return time

O(tasks × unique_tasks) — at every time step you scan all unique tasks.

Spotting the pattern

This is a Greedy problem. The key question to ask yourself:

If the most frequent task appears max_freq times, and n=2 so cycles have size 3, how many total intervals does the structure need if no other tasks exist?

Answering that is where it clicks, and it's exactly what the guided walkthrough below builds with you: the pattern reasoning, a progressive hint ladder that never spoils the answer, a row-by-row dry run, the optimized solution, and an in-browser editor to run your code against real test cases.