C# || Single-Threaded CPU – How To Find The Order CPU Will Process Tasks Using C#

January 27, 2023 admin No comments

The following is a module with functions which demonstrates how to find the order CPU will process tasks using C#.

1. Get Order – Problem Statement

You are given n tasks labeled from 0 to n – 1 represented by a 2D integer array tasks, where tasks[i] = [enqueueTime_i, processingTime_i] means that the i^th task will be available to process at enqueueTime_i and will take processingTime_ito finish processing.

You have a single-threaded CPU that can process at most one task at a time and will act in the following way:

If the CPU is idle and there are no available tasks to process, the CPU remains idle.
If the CPU is idle and there are available tasks, the CPU will choose the one with the shortest processing time. If multiple tasks have the same shortest processing time, it will choose the task with the smallest index.
Once a task is started, the CPU will process the entire task without stopping.
The CPU can finish a task then start a new one instantly.

Return the order in which the CPU will process the tasks.

Example 1:

Input: tasks = [[1,2],[2,4],[3,2],[4,1]] Output: [0,2,3,1] Explanation: The events go as follows: - At time = 1, task 0 is available to process. Available tasks = {0}. - Also at time = 1, the idle CPU starts processing task 0. Available tasks = {}. - At time = 2, task 1 is available to process. Available tasks = {1}. - At time = 3, task 2 is available to process. Available tasks = {1, 2}. - Also at time = 3, the CPU finishes task 0 and starts processing task 2 as it is the shortest. Available tasks = {1}. - At time = 4, task 3 is available to process. Available tasks = {1, 3}. - At time = 5, the CPU finishes task 2 and starts processing task 3 as it is the shortest. Available tasks = {1}. - At time = 6, the CPU finishes task 3 and starts processing task 1. Available tasks = {}. - At time = 10, the CPU finishes task 1 and becomes idle.

Example 2:

Input: tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]] Output: [4,3,2,0,1] Explanation: The events go as follows: - At time = 7, all the tasks become available. Available tasks = {0,1,2,3,4}. - Also at time = 7, the idle CPU starts processing task 4. Available tasks = {0,1,2,3}. - At time = 9, the CPU finishes task 4 and starts processing task 3. Available tasks = {0,1,2}. - At time = 13, the CPU finishes task 3 and starts processing task 2. Available tasks = {0,1}. - At time = 18, the CPU finishes task 2 and starts processing task 0. Available tasks = {1}. - At time = 28, the CPU finishes task 0 and starts processing task 1. Available tasks = {}. - At time = 40, the CPU finishes task 1 and becomes idle.

2. Get Order – Solution

The following is a solution which demonstrates how to find the order CPU will process tasks.





		
		
			2. Get Order - Solution
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jan 27, 2023
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find the order CPU will process tasks
// ============================================================================
public class Solution {
    private const int ENQUEUE_TIME = 0;
    private const int PROCESSING_TIME = 1;
    private const int INDEX = 2;

    public int[] GetOrder(int[][] tasks) {
        // Sort based on min task processing time or min task index.
        // Store enqueue time, processing time, task index.
        var nextTask = new PriorityQueue<int[], int[]>(Comparer<int[]>.Create((a, b) => (a[PROCESSING_TIME] != b[PROCESSING_TIME] ? (a[PROCESSING_TIME] - b[PROCESSING_TIME]) : (a[INDEX] - b[INDEX]))));

        // Store task enqueue time, processing time, index.
        int[][] sortedTasks = new int[tasks.Length][];
        for (int index = 0; index < sortedTasks.Length; ++index) {
            sortedTasks[index] = new int[3];
        }
        for (int index = 0; index < tasks.Length; ++index) {
            sortedTasks[index][ENQUEUE_TIME] = tasks[index][ENQUEUE_TIME];
            sortedTasks[index][PROCESSING_TIME] = tasks[index][PROCESSING_TIME];
            sortedTasks[index][INDEX] = index;
        }

        Array.Sort(sortedTasks, (a, b) => a[ENQUEUE_TIME] - b[ENQUEUE_TIME]);
        int[] tasksProcessingOrder = new int[tasks.Length];

        long currentTime = 0;
        int taskIndex = 0;
        int ansIndex = 0;

        // Stop when no tasks are left in array and heap.
        while (taskIndex < tasks.Length || nextTask.Count > 0) {
            if (nextTask.Count == 0 && currentTime < sortedTasks[taskIndex][ENQUEUE_TIME]) {
                // When the heap is empty, try updating currentTime to next task's enqueue time.
                currentTime = sortedTasks[taskIndex][ENQUEUE_TIME];
            }

            // Push all the tasks whose enqueueTime <= currtTime into the heap.
            while (taskIndex < tasks.Length && currentTime >= sortedTasks[taskIndex][ENQUEUE_TIME]) {
                nextTask.Enqueue(sortedTasks[taskIndex], sortedTasks[taskIndex]);
                ++taskIndex;
            }

            int[] task = nextTask.Dequeue();
            int processTime = task[PROCESSING_TIME];
            int index = task[INDEX];

            // Complete this task and increment currentTime.
            currentTime += processTime;
            tasksProcessingOrder[ansIndex++] = index;
        }

        return tasksProcessingOrder;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jan 27, 2023
//    Taken From: http://programmingnotes.org/
//    File:  Solution.cs
//    Description: Demonstrates how to find the order CPU will process tasks
// ============================================================================
public class Solution {
    private const int ENQUEUE_TIME = 0;
    private const int PROCESSING_TIME = 1;
    private const int INDEX = 2;
 
    public int[] GetOrder(int[][] tasks) {
        // Sort based on min task processing time or min task index.
        // Store enqueue time, processing time, task index.
        var nextTask = new PriorityQueue<int[], int[]>(Comparer<int[]>.Create((a, b) => (a[PROCESSING_TIME] != b[PROCESSING_TIME] ? (a[PROCESSING_TIME] - b[PROCESSING_TIME]) : (a[INDEX] - b[INDEX]))));
 
        // Store task enqueue time, processing time, index.
        int[][] sortedTasks = new int[tasks.Length][];
        for (int index = 0; index < sortedTasks.Length; ++index) {
            sortedTasks[index] = new int[3];
        }
        for (int index = 0; index < tasks.Length; ++index) {
            sortedTasks[index][ENQUEUE_TIME] = tasks[index][ENQUEUE_TIME];
            sortedTasks[index][PROCESSING_TIME] = tasks[index][PROCESSING_TIME];
            sortedTasks[index][INDEX] = index;
        }
 
        Array.Sort(sortedTasks, (a, b) => a[ENQUEUE_TIME] - b[ENQUEUE_TIME]);
        int[] tasksProcessingOrder = new int[tasks.Length];
 
        long currentTime = 0;
        int taskIndex = 0;
        int ansIndex = 0;
 
        // Stop when no tasks are left in array and heap.
        while (taskIndex < tasks.Length || nextTask.Count > 0) {
            if (nextTask.Count == 0 && currentTime < sortedTasks[taskIndex][ENQUEUE_TIME]) {
                // When the heap is empty, try updating currentTime to next task's enqueue time.
                currentTime = sortedTasks[taskIndex][ENQUEUE_TIME];
            }
 
            // Push all the tasks whose enqueueTime <= currtTime into the heap.
            while (taskIndex < tasks.Length && currentTime >= sortedTasks[taskIndex][ENQUEUE_TIME]) {
                nextTask.Enqueue(sortedTasks[taskIndex], sortedTasks[taskIndex]);
                ++taskIndex;
            }
 
            int[] task = nextTask.Dequeue();
            int processTime = task[PROCESSING_TIME];
            int index = task[INDEX];
 
            // Complete this task and increment currentTime.
            currentTime += processTime;
            tasksProcessingOrder[ansIndex++] = index;
        }
 
        return tasksProcessingOrder;
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output for the example cases:

[0,2,3,1] [4,3,2,0,1]

Was this article helpful?

👍 YesNo

Posted in: C#, Console Tags: c-sharp, leetcode, priority queue

C# || Single-Threaded CPU – How To Find The Order CPU Will Process Tasks Using C#

Related

Leave a ReplyCancel reply

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories