# Completion time of a given process in round robin

• Difficulty Level : Medium
• Last Updated : 30 Apr, 2021

We are given n-processes with their completion times in form of an array. We need to find the time instant when a given process p ends if the scheduling process is round robin and time slice is 1-sec.
note : Array index start with 0.
Examples :

```Input : arr[] = {3, 2, 4, 2}, p = 1
Output : Completion time = 6
Explanation : Snap of process for every second is as:
Time    |   Process Array
0       |   {3, 2, 4, 2}
1       |   {2, 2, 4, 2}
2       |   {2, 1, 4, 2}
3       |   {2, 1, 3, 2}
4       |   {2, 1, 3, 1}
5       |   {1, 1, 3, 1}
6       |   {1, 0, 3, 1}

Input : arr[] = {2, 4, 1, 3}, p = 2
Output :Completion time = 3
Explanation : Snap of process for every second is as:
Time    |   Process Array
0       |   {2, 4, 1, 3}
1       |   {1, 4, 1, 3}
2       |   {1, 3, 1, 3}
3       |   {1, 3, 0, 3}```

Brute Force :The basic approach for solving this problem is to apply round robin algorithm with time slice 1. But the time complexity of that approach will be O(Î£Ai) i.e. summation of all process’s time, which is quite high.
Efficient Approach: The idea is based on below observations.
1) All processes with CPU time less than arr[p] would complete before arr[p]. We simply need to add time of these processes.
2) We also need to add time of arr[p].
3) For every process x with CPU time more than arr[p], two cases arise :
…..(i) If x is on left of arr[p] (scheduled before arr[p]), then this process takes arr[p] time of CPU before p finishes.
…..(ii) If x is on right of arr[p] (scheduled after arr[p]), then this process takes arr[p]-1 time of CPU before p finishes.
Algorithm :

```time_req = 0;

// Add time for process on left of p
// (Scheduled before p in a round of
// 1 unit time slice)
for (int i=0; i<p; i++)
{
if (arr[i] < arr[p])
time_req += arr[i];
else
time_req += arr[p];
}

// step 2 : Add time of process p
time_req += arr[p];

// Add time for process on right
// of p (Scheduled after p in
// a round of 1 unit time slice)
for (int i=p+1; i<n; i++)
{
if (arr[i] < arr[p])
time_req += arr[i];
else
time_req += arr[p]-1;
}```

## C++

 `// Program to find end time of a process ` `// p in round robin scheduling with unit` `// time slice.` `#include ` `using` `namespace` `std;`   `// Returns completion time of p.` `int` `completionTime(``int` `arr[], ``int` `n, ``int` `p) {`   `  ``// Initialize result` `  ``int` `time_req = 0;`   `  ``// Step 1 : Add time of processes on left` `  ``//  of p (Scheduled before p)` `  ``for` `(``int` `i = 0; i < p; i++) {` `    ``if` `(arr[i] < arr[p])` `      ``time_req += arr[i];` `    ``else` `      ``time_req += arr[p];` `  ``}`   `  ``// Step 2 : Add time of p` `  ``time_req += arr[p];`   `  ``// Step 3 : Add time of processes on right` `  ``//  of p (Scheduled after p)` `  ``for` `(``int` `i = p + 1; i < n; i++) {` `    ``if` `(arr[i] < arr[p])` `      ``time_req += arr[i];` `    ``else` `      ``time_req += arr[p] - 1;` `  ``}`   `  ``return` `time_req;` `}`   `// driver program` `int` `main() {` `  ``int` `arr[] = {3, 5, 2, 7, 6, 1};` `  ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `  ``int` `p = 2;` `  ``cout << ``"Completion time = "` `       ``<< completionTime(arr, n, p);` `  ``return` `0;` `}`

## Java

 `// Program to find end time of a process ` `// p in round robin scheduling with unit` `// time slice.` `class` `GFG` `{` `    ``// Returns completion time of p.` `    ``static` `int` `completionTime(``int` `arr[], ``int` `n, ``int` `p) {` `        `  `        ``// Initialize result` `        ``int` `time_req = ``0``;` `        `  `        ``// Step 1 : Add time of processes on left` `        ``// of p (Scheduled before p)` `        ``for` `(``int` `i = ``0``; i < p; i++) {` `            ``if` `(arr[i] < arr[p])` `                ``time_req += arr[i];` `            ``else` `                ``time_req += arr[p];` `        ``}` `        `  `        ``// Step 2 : Add time of p` `        ``time_req += arr[p];` `        `  `        ``// Step 3 : Add time of processes on right` `        ``// of p (Scheduled after p)` `        ``for` `(``int` `i = p + ``1``; i < n; i++) {` `            ``if` `(arr[i] < arr[p])` `                ``time_req += arr[i];` `            ``else` `                ``time_req += arr[p] - ``1``;` `        ``}` `        `  `        ``return` `time_req;` `    ``}` `        `  `    ``// Driver code` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `arr[] = {``3``, ``5``, ``2``, ``7``, ``6``, ``1``};` `        ``int` `n =arr.length;;` `        ``int` `p = ``2``;` `        `  `        ``System.out.print(``"Completion time = "``+` `            ``completionTime(arr, n, p));` `    ``}` `}`   `// This code is contributed by Anant Agarwal.`

## Python

 `# Program to find end time of a process ` `# p in round robin scheduling with unit` `# time slice.`   `# Returns completion time of p.` `def` `completionTime(arr, n, p) :`   `    ``# Initialize result` `    ``time_req ``=` `0` `    `  `    ``# Step 1 : Add time of processes on` `    ``# left of p (Scheduled before p)` `    ``for` `i ``in` `range``(``0``, p): ` `        ``if` `(arr[i] < arr[p]):` `            ``time_req ``+``=` `arr[i]` `        ``else``:` `            ``time_req ``+``=` `arr[p]` `    `  `    `  `    ``# Step 2 : Add time of p` `    ``time_req ``+``=` `arr[p]` `    `  `    ``# Step 3 : Add time of processes on ` `    ``# right of p (Scheduled after p)` `    ``for` `i ``in` `range``(p ``+` `1``, n): ` `        ``if` `(arr[i] < arr[p]):` `            ``time_req ``+``=` `arr[i]` `        ``else``:` `            ``time_req ``+``=` `arr[p] ``-` `1` `    `  `    ``return` `time_req` `    `    `# driver program` `arr ``=` `[``3``, ``5``, ``2``, ``7``, ``6``, ``1``]` `n ``=` `len``(arr) ` `p ``=` `2` `print``(``"Completion time ="``, ` `        ``completionTime(arr, n, p))`     `# This code is contributed by ` `# Smitha Dinesh Semwal`

## C#

 `// C# program to find end time of a process ` `// p in round robin scheduling with unit` `// time slice.` `using` `System;`   `class` `GFG {` `    `  `    ``// Returns completion time of p.` `    ``static` `int` `completionTime(``int` `[]arr,` `                            ``int` `n, ``int` `p)` `    ``{` `        `  `        ``// Initialize result` `        ``int` `time_req = 0;` `        `  `        ``// Step 1 : Add time of processes` `        ``// on left of p (Scheduled before p)` `        ``for` `(``int` `i = 0; i < p; i++) {` `            ``if` `(arr[i] < arr[p])` `                ``time_req += arr[i];` `            ``else` `                ``time_req += arr[p];` `        ``}` `        `  `        ``// Step 2 : Add time of p` `        ``time_req += arr[p];` `        `  `        ``// Step 3 : Add time of processes on` `        ``// right of p (Scheduled after p)` `        ``for` `(``int` `i = p + 1; i < n; i++) {` `            ``if` `(arr[i] < arr[p])` `                ``time_req += arr[i];` `            ``else` `                ``time_req += arr[p] - 1;` `        ``}` `        `  `        ``return` `time_req;` `    ``}` `        `  `    ``// Driver code` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[]arr = {3, 5, 2, 7, 6, 1};` `        ``int` `n =arr.Length;;` `        ``int` `p = 2;` `        `  `        ``Console.WriteLine(``"Completion time = "``+` `                    ``completionTime(arr, n, p));` `    ``}` `}`   `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output :

`Completion time = 9`

Time Complexity : O(n)

My Personal Notes arrow_drop_up
Recommended Articles
Page :