Single-Threaded CPU - Practice Coding Problems

Single-Threaded CPU - Problem

Single-Threaded CPU Task Scheduler

Imagine you're managing a single-core CPU that needs to efficiently process multiple tasks. You have n tasks labeled from 0 to n - 1, where each task is represented by tasks[i] = [enqueueTime_i, processingTime_i].

The CPU follows these intelligent scheduling rules:
• Idle State: If no tasks are available, the CPU waits
• Task Selection: Among available tasks, pick the one with shortest processing time
• Tie-Breaking: If processing times are equal, choose the task with smallest original index
• Non-Preemptive: Once started, a task runs to completion
• Instant Switching: CPU can immediately start the next task

Goal: Return the order in which the CPU processes all tasks, demonstrating optimal task scheduling in action!

Input & Output

example_1.py — Basic Task Scheduling

$ Input: tasks = [[1,2],[2,4],[3,2],[4,1]]

› Output: [0,2,3,1]

💡 Note: At t=1, only task 0 is available (process for 2 units until t=3). At t=3, tasks 1 and 2 are available; choose task 2 (shorter processing time, process until t=5). At t=5, tasks 1 and 3 are available; choose task 3 (shorter processing time, process until t=6). Finally process task 1 from t=6 to t=10.

example_2.py — Tie-Breaking by Index

$ Input: tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]

› Output: [4,3,2,0,1]

💡 Note: All tasks become available at t=7. Since they all have the same enqueue time, we process them in order of processing time: task 4 (2 units), task 3 (4 units), task 2 (5 units), task 0 (10 units), task 1 (12 units).

example_3.py — CPU Idle Time

$ Input: tasks = [[5,2],[7,2]]

› Output: [0,1]

💡 Note: At t=0, no tasks are available so CPU is idle until t=5. Process task 0 from t=5 to t=7. At t=7, task 1 becomes available and is processed from t=7 to t=9.

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ enqueueTime_i, processingTime_i ≤ 10⁹
All task indices are unique and range from 0 to n-1

Visualization

Tap to expand

Sorting: O(n log n) - Organize tasks chronologically• Heap Operations: O(n log n) - Each task pushed/popped once• Total Time: O(n log n) - Optimal for this problem• Space: O(n) - Heap stores up to n tasks🎯 Key Insight: Priority Queue + Chronological ProcessingEfficiently manages task availability and selection using heap data structure

Understanding the Visualization

Sort by Arrival

Arrange all tasks chronologically by their enqueue time

Build Available Pool

Add all tasks that have arrived by current time to the priority queue

Select Optimal Task

Pick task with shortest processing time (break ties by original index)

Execute and Advance

Process the selected task and advance CPU time by processing duration

Repeat Until Complete

Continue until all tasks are processed, handling CPU idle time efficiently

Key Takeaway

🎯 Key Insight: The optimal solution combines chronological task processing (sorting) with efficient priority management (min-heap) to achieve O(n log n) time complexity while handling CPU idle time intelligently.

Asked in

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

The optimal solution uses sorting + priority queue approach. First, sort tasks by enqueue time to process chronologically. Then use a min-heap to efficiently select the task with shortest processing time among available tasks. This achieves O(n log n) time complexity, making it scalable for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Priority Queue (Optimal)	O(n log n)	O(n)	Sort tasks by enqueue time and use a min-heap to efficiently select the next task to process
Brute Force Simulation	O(n² × max_time)	O(n)	Simulate each time unit and scan all tasks to find the next one to process

Sorting + Priority Queue (Optimal) — Algorithm Steps

Create indexed tasks and sort by enqueue time
Initialize min-heap, current time, and result array
Process all tasks in chronological order:
Add all tasks that have arrived by current time to heap
If heap is empty but tasks remain, jump to next task's enqueue time
Pop the task with shortest processing time from heap
Process this task and update current time
Add processed task index to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Tasks

Sort all tasks by their enqueue time to process chronologically

Add Available

Add all tasks that have arrived by current time to min-heap

Pop Shortest

Extract task with shortest processing time from heap

Process & Advance

Execute task and advance current time by processing duration

Continue

Repeat until all tasks processed

Code -

solution.c — C

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

typedef struct {
    long long enqueue;
    long long process;
    int index;
} IndexedTask;

typedef struct {
    long long processTime;
    int origIndex;
} HeapTask;

typedef struct {
    HeapTask* data;
    int size;
    int capacity;
} MinHeap;

int compareIndexedTasks(const void* a, const void* b) {
    IndexedTask* taskA = (IndexedTask*)a;
    IndexedTask* taskB = (IndexedTask*)b;
    if (taskA->enqueue < taskB->enqueue) return -1;
    if (taskA->enqueue > taskB->enqueue) return 1;
    return 0;
}

MinHeap* createHeap(int capacity) {
    MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
    heap->data = (HeapTask*)malloc(capacity * sizeof(HeapTask));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[idx].processTime < heap->data[parent].processTime ||
            (heap->data[idx].processTime == heap->data[parent].processTime &&
             heap->data[idx].origIndex < heap->data[parent].origIndex)) {
            HeapTask temp = heap->data[idx];
            heap->data[idx] = heap->data[parent];
            heap->data[parent] = temp;
            idx = parent;
        } else {
            break;
        }
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    while (2 * idx + 1 < heap->size) {
        int minIdx = 2 * idx + 1;
        if (2 * idx + 2 < heap->size) {
            if (heap->data[2 * idx + 2].processTime < heap->data[minIdx].processTime ||
                (heap->data[2 * idx + 2].processTime == heap->data[minIdx].processTime &&
                 heap->data[2 * idx + 2].origIndex < heap->data[minIdx].origIndex)) {
                minIdx = 2 * idx + 2;
            }
        }
        if (heap->data[idx].processTime > heap->data[minIdx].processTime ||
            (heap->data[idx].processTime == heap->data[minIdx].processTime &&
             heap->data[idx].origIndex > heap->data[minIdx].origIndex)) {
            HeapTask temp = heap->data[idx];
            heap->data[idx] = heap->data[minIdx];
            heap->data[minIdx] = temp;
            idx = minIdx;
        } else {
            break;
        }
    }
}

void heapPush(MinHeap* heap, HeapTask task) {
    heap->data[heap->size] = task;
    heapifyUp(heap, heap->size);
    heap->size++;
}

HeapTask heapPop(MinHeap* heap) {
    HeapTask min = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

int* getOrder(int** tasks, int tasksSize, int* tasksColSize, int* returnSize) {
    IndexedTask* indexedTasks = (IndexedTask*)malloc(tasksSize * sizeof(IndexedTask));
    for (int i = 0; i < tasksSize; i++) {
        indexedTasks[i].enqueue = tasks[i][0];
        indexedTasks[i].process = tasks[i][1];
        indexedTasks[i].index = i;
    }
    
    qsort(indexedTasks, tasksSize, sizeof(IndexedTask), compareIndexedTasks);
    
    int* result = (int*)malloc(tasksSize * sizeof(int));
    MinHeap* minHeap = createHeap(tasksSize);
    long long currentTime = 0;
    int taskIndex = 0;
    *returnSize = tasksSize;
    
    for (int resultIndex = 0; resultIndex < tasksSize; resultIndex++) {
        while (taskIndex < tasksSize && indexedTasks[taskIndex].enqueue <= currentTime) {
            HeapTask heapTask = {indexedTasks[taskIndex].process, indexedTasks[taskIndex].index};
            heapPush(minHeap, heapTask);
            taskIndex++;
        }
        
        if (minHeap->size > 0) {
            HeapTask task = heapPop(minHeap);
            currentTime += task.processTime;
            result[resultIndex] = task.origIndex;
        } else {
            if (taskIndex < tasksSize) {
                currentTime = indexedTasks[taskIndex].enqueue;
                resultIndex--; // Don't increment result index
            }
        }
    }
    
    free(indexedTasks);
    free(minHeap->data);
    free(minHeap);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and each task is pushed/popped from heap once, giving O(n log n) total

⚡ Linearithmic

Space Complexity

O(n)

Space for the heap which can contain up to n tasks in worst case

⚡ Linearithmic Space

52.0K Views

High Frequency

~25 min Avg. Time

1.6K 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

Sorting + Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler