Process Tasks Using Servers solution and explanation

from heapq import heappop, heappush

def assign_tasks(servers, tasks):
    n = len(servers)
    m = len(tasks)
    free_servers = [(servers[i], i) for i in range(n)]
    busy_servers = []  # (free_time, weight, index)
    result = [-1] * m
    queue = []  # task indices
    current_time = 0

    for time in range(m):
        while busy_servers and busy_servers[0][0] <= time:
            free_time, weight, server_index = heappop(busy_servers)
            heappush(free_servers, (weight, server_index))

        queue.append(time)

        while free_servers and queue:
            task_index = queue.pop(0)
            weight, server_index = heappop(free_servers)
            result[task_index] = server_index
            heappush(busy_servers, (time + tasks[task_index], weight, server_index))

        current_time += 1

    return result

import java.util.*;

public class TaskAssigner {
    public int[] assignTasks(int[] servers, int[] tasks) {
        int n = servers.length;
        int m = tasks.length;
        PriorityQueue<int[]> freeServers = new PriorityQueue<>((a, b) -> a[0] == b[0] ? Integer.compare(a[1], b[1]) : Integer.compare(a[0], b[0]));
        PriorityQueue<int[]> busyServers = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
        int[] result = new int[m];

        for (int i = 0; i < n; i++) {
            freeServers.offer(new int[]{servers[i], i});
        }

        Queue<Integer> taskQueue = new ArrayDeque<>();
        int currentTime = 0;

        for (int time = 0; time < m; time++) {
            while (!busyServers.isEmpty() && busyServers.peek()[0] <= time) {
                int[] server = busyServers.poll();
                freeServers.offer(new int[]{server[1], server[2]});
            }

            taskQueue.offer(time);

            while (!freeServers.isEmpty() && !taskQueue.isEmpty()) {
                int taskIdx = taskQueue.poll();
                int[] server = freeServers.poll();
                result[taskIdx] = server[1];
                busyServers.offer(new int[]{time + tasks[taskIdx], server[0], server[1]});
            }

            currentTime++;
        }

        return result;
    }
}

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

vector<int> assignTasks(vector<int>& servers, vector<int>& tasks) {
    int n = servers.size();
    int m = tasks.size();
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> free_servers;
    priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, greater<>> busy_servers;
    vector<int> result(m);
    queue<int> q;
    int time = 0;

    for (int i = 0; i < n; ++i) {
        free_servers.emplace(servers[i], i);
    }

    for (int j = 0; j < m; ++j) {
        while (!busy_servers.empty() && get<0>(busy_servers.top()) <= time) {
            auto [free_time, weight, idx] = busy_servers.top();
            busy_servers.pop();
            free_servers.emplace(weight, idx);
        }

        q.push(j);

        while (!free_servers.empty() && !q.empty()) {
            int task_idx = q.front(); q.pop();
            auto [weight, server_idx] = free_servers.top(); free_servers.pop();
            result[task_idx] = server_idx;
            busy_servers.emplace(time + tasks[task_idx], weight, server_idx);
        }

        time++;
    }

    return result;
}

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

typedef struct {
    int weight;
    int index;
} Server;

typedef struct {
    int time;
    int weight;
    int index;
} BusyServer;

int cmpServers(const void* a, const void* b) {
    Server* serverA = (Server*)a;
    Server* serverB = (Server*)b;
    if (serverA->weight == serverB->weight) {
        return serverA->index - serverB->index;
    }
    return serverA->weight - serverB->weight;
}

int cmpBusyServers(const void* a, const void* b) {
    BusyServer* busyA = (BusyServer*)a;
    BusyServer* busyB = (BusyServer*)b;
    return busyA->time - busyB->time;
}

int* assignTasks(int* servers, int serversSize, int* tasks, int tasksSize, int* returnSize) {
    Server* freeServers = malloc(sizeof(Server) * serversSize);
    BusyServer* busyServers = malloc(sizeof(BusyServer) * tasksSize);
    int* res = malloc(sizeof(int) * tasksSize);
    int currentTime = 0;
    int busyCount = 0;
    int taskQueue[tasksSize];
    int queueStart = 0, queueEnd = 0;

    for (int i = 0; i < serversSize; i++) {
        freeServers[i] = (Server){servers[i], i};
    }

    qsort(freeServers, serversSize, sizeof(Server), cmpServers);

    for (int time = 0; time < tasksSize; time++) {
        while (busyCount > 0 && busyServers[0].time <= time) { // Free servers
            Server server = {busyServers[0].weight, busyServers[0].index};
            memmove(busyServers, busyServers + 1, (--busyCount) * sizeof(BusyServer));
            int insertPos = serversSize - busyCount - 1;
            memmove(freeServers + insertPos + 1, freeServers + insertPos, busyCount * sizeof(Server));
            freeServers[insertPos] = server;
            qsort(freeServers, serversSize, sizeof(Server), cmpServers);
        }

        taskQueue[queueEnd++] = time;

        while (queueStart < queueEnd && serversSize - busyCount > 0) {
            int taskIndex = taskQueue[queueStart++];
            Server server = freeServers[serversSize - busyCount - 1];
            busyServers[busyCount++] = (BusyServer){time + tasks[taskIndex], server.weight, server.index};
            server.index = -1; // Mark as used
            qsort(busyServers, busyCount, sizeof(BusyServer), cmpBusyServers);
            res[taskIndex] = server.index;
        }

        currentTime++;
    }

    *returnSize = tasksSize;
    free(freeServers);
    free(busyServers);
    return res;
}

function assignTasks(servers: number[], tasks: number[]): number[] {
    const idle = new PriorityQueue({
        compare: (a, b) => (a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]),
    });
    const busy = new PriorityQueue({
        compare: (a, b) =>
            a[0] === b[0] ? (a[1] === b[1] ? a[2] - b[2] : a[1] - b[1]) : a[0] - b[0],
    });
    for (let i = 0; i < servers.length; ++i) {
        idle.enqueue([servers[i], i]);
    }
    const ans: number[] = [];
    for (let j = 0; j < tasks.length; ++j) {
        const t = tasks[j];
        while (busy.size() > 0 && busy.front()![0] <= j) {
            const [_, s, i] = busy.dequeue()!;
            idle.enqueue([s, i]);
        }
        if (idle.size() > 0) {
            const [s, i] = idle.dequeue()!;
            busy.enqueue([j + t, s, i]);
            ans.push(i);
        } else {
            const [w, s, i] = busy.dequeue()!;
            busy.enqueue([w + t, s, i]);
            ans.push(i);
        }
    }
    return ans;
}

func assignTasks(servers []int, tasks []int) (ans []int) {
	idle := hp{}
	busy := hp2{}
	for i, x := range servers {
		heap.Push(&idle, pair{x, i})
	}
	for j, t := range tasks {
		for len(busy) > 0 && busy[0].w <= j {
			p := heap.Pop(&busy).(tuple)
			heap.Push(&idle, pair{p.s, p.i})
		}
		if idle.Len() > 0 {
			p := heap.Pop(&idle).(pair)
			ans = append(ans, p.i)
			heap.Push(&busy, tuple{j + t, p.s, p.i})
		} else {
			p := heap.Pop(&busy).(tuple)
			ans = append(ans, p.i)
			heap.Push(&busy, tuple{p.w + t, p.s, p.i})
		}
	}
	return
}

type pair struct {
	s int
	i int
}

type hp []pair

func (h hp) Len() int { return len(h) }
func (h hp) Less(i, j int) bool {
	a, b := h[i], h[j]
	return a.s < b.s || a.s == b.s && a.i < b.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 }

type tuple struct {
	w int
	s int
	i int
}

type hp2 []tuple

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