Single-Threaded CPU solution and explanation

from heapq import heappop, heappush

def getOrder(tasks):
    indexed_tasks = sorted([(t[0], t[1], i) for i, t in enumerate(tasks)])
    result = []
    available_tasks = []
    time = 0
    i = 0
    while i < len(tasks) or available_tasks:
        if not available_tasks:
            time = max(time, indexed_tasks[i][0])
        while i < len(tasks) and indexed_tasks[i][0] <= time:
            heappush(available_tasks, (indexed_tasks[i][1], indexed_tasks[i][2]))
            i += 1
        processing_time, index = heappop(available_tasks)
        time += processing_time
        result.append(index)
    return result

function getOrder(tasks) {
    tasks = tasks.map((task, index) => [...task, index]);
    tasks.sort((a, b) => a[0] - b[0]);
    const result = [];
    const availableTasks = [];
    let time = 0, i = 0;
    while (i < tasks.length || availableTasks.length) {
        if (!availableTasks.length) {
            time = Math.max(time, tasks[i][0]);
        }
        while (i < tasks.length && tasks[i][0] <= time) {
            availableTasks.push(tasks[i]);
            i++;
        }
        availableTasks.sort((a, b) => {
            if (a[1] === b[1]) return a[2] - b[2];
            return a[1] - b[1];
        });
        const [_, processingTime, index] = availableTasks.shift();
        time += processingTime;
        result.push(index);
    }
    return result;
}

import java.util.*;

public class SingleThreadedCPU {
    public int[] getOrder(int[][] tasks) {
        int n = tasks.length;
        int[][] indexedTasks = new int[n][3];
        for (int i = 0; i < n; i++) {
            indexedTasks[i] = new int[] { tasks[i][0], tasks[i][1], i };
        }
        Arrays.sort(indexedTasks, (a, b) -> Integer.compare(a[0], b[0]));
        PriorityQueue<int[]> availableTasks = new PriorityQueue<>((a, b) -> a[1] == b[1] ? Integer.compare(a[2], b[2]) : Integer.compare(a[1], b[1]));
        int[] result = new int[n];
        int time = 0, taskIndex = 0, resultIndex = 0;
        while (taskIndex < n || !availableTasks.isEmpty()) {
            if (availableTasks.isEmpty()) {
                time = Math.max(time, indexedTasks[taskIndex][0]);
            }
            while (taskIndex < n && indexedTasks[taskIndex][0] <= time) {
                availableTasks.offer(new int[] { indexedTasks[taskIndex][0], indexedTasks[taskIndex][1], indexedTasks[taskIndex][2] });
                taskIndex++;
            }
            int[] task = availableTasks.poll();
            time += task[1];
            result[resultIndex++] = task[2];
        }
        return result;
    }
}

#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

vector<int> getOrder(vector<vector<int>>& tasks) {
    int n = tasks.size();
    vector<array<int, 3>> indexedTasks(n);
    for (int i = 0; i < n; ++i) {
        indexedTasks[i] = {tasks[i][0], tasks[i][1], i};
    }
    sort(indexedTasks.begin(), indexedTasks.end());
    priority_queue<array<int, 2>, vector<array<int, 2>>, greater<>> availableTasks;
    vector<int> result;
    long time = 0, taskIndex = 0;
    while (taskIndex < n || !availableTasks.empty()) {
        if (availableTasks.empty()) {
            time = max(time, static_cast<long>(indexedTasks[taskIndex][0]));
        }
        while (taskIndex < n && indexedTasks[taskIndex][0] <= time) {
            availableTasks.push({indexedTasks[taskIndex][1], indexedTasks[taskIndex][2]});
            taskIndex++;
        }
        auto [processingTime, index] = availableTasks.top(); availableTasks.pop();
        time += processingTime;
        result.push_back(index);
    }
    return result;
}

func getOrder(tasks [][]int) (ans []int) {
	for i := range tasks {
		tasks[i] = append(tasks[i], i)
	}
	sort.Slice(tasks, func(i, j int) bool { return tasks[i][0] < tasks[j][0] })
	q := hp{}
	i, t, n := 0, 0, len(tasks)
	for len(q) > 0 || i < n {
		if len(q) == 0 {
			t = max(t, tasks[i][0])
		}
		for i < n && tasks[i][0] <= t {
			heap.Push(&q, pair{tasks[i][1], tasks[i][2]})
			i++
		}
		p := heap.Pop(&q).(pair)
		ans = append(ans, p.i)
		t += p.t
	}
	return
}

type pair struct{ t, i int }
type hp []pair

func (h hp) Len() int           { return len(h) }
func (h hp) Less(i, j int) bool { return h[i].t < h[j].t || (h[i].t == h[j].t && h[i].i < h[j].i) }
func (h hp) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v any)        { *h = append(*h, v.(pair)) }
func (h *hp) Pop() any          { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }