Process Scheduling

import java.util.*;

public class PreviousTasksAll {
    private static final int QUANTUM_TIME = 4;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        int numberOfProcesses = scanner.nextInt();

        //hardcodedPart
        int numberOfProcesses = 5;
        int[] pID = {1, 2, 3, 4, 5};
        int[] bt = {10, 1, 2, 7, 5};
        int[] priority = {3, 1, 3, 4, 2};
        int[] at = {3, 0, 1, 4, 5};
        //
        ProcessArr[] myProcesses = new ProcessArr[numberOfProcesses];

        for (int i = 0; i < numberOfProcesses; ++i) {
            myProcesses[i] = new ProcessArr(pID[i], at[i], bt[i], priority[i]);
        }

        ProcessArr[] myProcesses1 = new ProcessArr[numberOfProcesses];

        for (int i = 0; i < numberOfProcesses; ++i) {
            myProcesses1[i] = new ProcessArr(pID[i], at[i], bt[i], priority[i]);
        }

        ProcessArr[] myProcesses2 = new ProcessArr[numberOfProcesses];

        for (int i = 0; i < numberOfProcesses; ++i) {
            myProcesses2[i] = new ProcessArr(pID[i], at[i], bt[i], priority[i]);
        }

        ProcessArr[] myProcesses3 = new ProcessArr[numberOfProcesses];

        for (int i = 0; i < numberOfProcesses; ++i) {
            myProcesses3[i] = new ProcessArr(pID[i], at[i], bt[i], priority[i]);
        }

        ProcessArr[] myProcesses4 = new ProcessArr[numberOfProcesses];

        for (int i = 0; i < numberOfProcesses; ++i) {
            myProcesses4[i] = new ProcessArr(pID[i], at[i], bt[i], priority[i]);
        }


        roundRobin(myProcesses);
        preemptiveSJF(myProcesses1);
        non_preemptiveSJF(myProcesses2);
        preemptivePRIORITY(myProcesses3);
        non_preemptivePRIORITY(myProcesses4);
    }

    private static void non_preemptivePRIORITY(ProcessArr[] myProcesses) {
        Arrays.sort(myProcesses, Comparator.comparingInt(a -> a.arrivalTime));
        List<ProcessArr> queues = new ArrayList<>();
        int startTime = myProcesses[0].arrivalTime;
        for (ProcessArr p : myProcesses) if (p.arrivalTime <= startTime) queues.add(p);
        queues.sort(Comparator.comparingInt(a -> a.priority));

        List<Integer> sequence = new ArrayList<>();
        while (!queues.isEmpty()) {

            ProcessArr p = queues.remove(0);
            sequence.add(p.processID);


            if (p.startTime == Integer.MAX_VALUE) {
                p.startTime = startTime;
            }

//            startTime += p.burstTime;

            p.final_END_TIME = startTime + p.burstTime;
            p.turnaroundTime = p.final_END_TIME - p.arrivalTime;
            p.waitingTime = p.turnaroundTime - p.burstTime;
            p.responseTime = p.startTime - p.arrivalTime;

            startTime += p.burstTime;

            p.checked = true;

            for (ProcessArr process : myProcesses)
                if (!process.checked && process.arrivalTime <= startTime) {
                    queues.add(process);
                    process.checked = true;
                }
            queues.sort(Comparator.comparingInt(a -> a.priority));
        }

        int TOTAL_WAITING_TIME = 0;
        double AVERAGE_WAITING_TIME;

        int TOTAL_RESPONSE_TIME = 0;
        double AVERAGE_RESPONSE_TIME;

        for (ProcessArr p : myProcesses) {
            TOTAL_WAITING_TIME += p.waitingTime;
            TOTAL_RESPONSE_TIME += p.responseTime;
        }
        AVERAGE_WAITING_TIME = TOTAL_WAITING_TIME / (double) myProcesses.length;
        AVERAGE_RESPONSE_TIME = TOTAL_RESPONSE_TIME / (double) myProcesses.length;

//        Printing the whole part
        System.out.println("Non-PreemptivePRIORITY Scheduling : --------------------------- ");
        System.out.print("P" + sequence.remove(0));
        for (Integer in : sequence) {
            System.out.print(" --> P" + in);
        }
        System.out.println();

        System.out.println("ProcessName StartTime EndTime WaitingTime ResponseTime TurnAroundTime");
        for (ProcessArr p : myProcesses) {
            System.out.println("P" + p.processID + "           " + p.startTime + "          " + p.final_END_TIME + "         " + p.waitingTime + "        " + p.responseTime + "             " + p.turnaroundTime);
        }
        System.out.println("Average Waiting Time  : " + AVERAGE_WAITING_TIME);
        System.out.println("Average Response Time : " + AVERAGE_RESPONSE_TIME);
        System.out.println("\n\n\n\n");
    }

    private static void non_preemptiveSJF(ProcessArr[] myProcesses) {
        Arrays.sort(myProcesses, Comparator.comparingInt(a -> a.arrivalTime));
        ArrayList<ProcessArr> queues = new ArrayList<>();
        int startTime = myProcesses[0].arrivalTime;
        for (ProcessArr p : myProcesses) if (p.arrivalTime <= startTime) queues.add(p);
        queues.sort((a, b) -> Integer.compare(a.arrivalTime, b.arrivalTime));

        List<Integer> sequence = new ArrayList<>();

        while (!queues.isEmpty()) {

            ProcessArr p = queues.remove(0);
            sequence.add(p.processID);

            if (p.startTime == Integer.MAX_VALUE) {
                p.startTime = startTime;
            }

            p.final_END_TIME = startTime + p.burstTime;
            p.turnaroundTime = p.final_END_TIME - p.arrivalTime;
            p.waitingTime = p.turnaroundTime - p.burstTime;
            p.responseTime = p.startTime - p.arrivalTime;

            startTime += p.burstTime;

            p.checked = true;

            for (ProcessArr process : myProcesses)
                if (!process.checked && process.arrivalTime <= startTime) {
                    queues.add(process);
                    process.checked = true;
                }
            queues.sort(Comparator.comparingInt(a -> a.burstTime));
        }

        int TOTAL_WAITING_TIME = 0;
        double AVERAGE_WAITING_TIME;

        int TOTAL_RESPONSE_TIME = 0;
        double AVERAGE_RESPONSE_TIME;

        for (ProcessArr p : myProcesses) {
            TOTAL_WAITING_TIME += p.waitingTime;
            TOTAL_RESPONSE_TIME += p.responseTime;
        }
        AVERAGE_WAITING_TIME = TOTAL_WAITING_TIME / (double) myProcesses.length;
        AVERAGE_RESPONSE_TIME = TOTAL_RESPONSE_TIME / (double) myProcesses.length;

//        Printing the whole part
        System.out.println("Non-PreemptiveSJF Scheduling : --------------------------- ");
        System.out.print("P" + sequence.remove(0));
        for (Integer in : sequence) {
            System.out.print(" --> P" + in);
        }
        System.out.println();

        System.out.println("ProcessName StartTime EndTime WaitingTime ResponseTime TurnAroundTime");
        for (ProcessArr p : myProcesses) {
            System.out.println("P" + p.processID + "           " + p.startTime + "          " + p.final_END_TIME + "         " + p.waitingTime + "        " + p.responseTime + "             " + p.turnaroundTime);
        }
        System.out.println("Average Waiting Time  : " + AVERAGE_WAITING_TIME);
        System.out.println("Average Response Time : " + AVERAGE_RESPONSE_TIME);
        System.out.println("\n\n\n\n");
    }

    private static void preemptivePRIORITY(ProcessArr[] myProcesses) {
        Arrays.sort(myProcesses, Comparator.comparingInt(a -> a.arrivalTime));
        ArrayList<ProcessArr> queues = new ArrayList<>();
        int startTime = myProcesses[0].arrivalTime;
        for (ProcessArr p : myProcesses) if (p.arrivalTime <= startTime) queues.add(p);
        queues.sort((a, b) -> Integer.compare(a.arrivalTime, b.arrivalTime));

        List<Integer> sequence = new ArrayList<>();
        while (!queues.isEmpty()) {

            ProcessArr p = queues.get(0);
            sequence.add(p.processID);


            if (p.startTime == Integer.MAX_VALUE) {
                p.startTime = startTime;
            }

            startTime++;
            p.present_BURST_SIZE--;

            if (p.present_BURST_SIZE == 0) {
                p.final_END_TIME = startTime + p.present_BURST_SIZE;
                p.turnaroundTime = p.final_END_TIME - p.arrivalTime;
                p.waitingTime = p.turnaroundTime - p.burstTime;
                p.responseTime = p.startTime - p.arrivalTime;

                queues.remove(0);
            }

            p.checked = true;

            for (ProcessArr process : myProcesses)
                if (!process.checked && process.arrivalTime <= startTime) {
                    queues.add(process);
                    process.checked = true;
                }
            queues.sort(Comparator.comparingInt(a -> a.priority));
        }

        int TOTAL_WAITING_TIME = 0;
        double AVERAGE_WAITING_TIME;

        int TOTAL_RESPONSE_TIME = 0;
        double AVERAGE_RESPONSE_TIME;

        for (ProcessArr p : myProcesses) {
            TOTAL_WAITING_TIME += p.waitingTime;
            TOTAL_RESPONSE_TIME += p.responseTime;
        }
        AVERAGE_WAITING_TIME = TOTAL_WAITING_TIME / (double) myProcesses.length;
        AVERAGE_RESPONSE_TIME = TOTAL_RESPONSE_TIME / (double) myProcesses.length;

//        Printing the whole part
        System.out.println("PreemptivePRIORITY Scheduling : --------------------------- ");
        System.out.print("P" + sequence.remove(0));
        for (Integer in : sequence) {
            System.out.print(" --> P" + in);
        }
        System.out.println();

        System.out.println("ProcessName StartTime EndTime WaitingTime ResponseTime TurnAroundTime");
        for (ProcessArr p : myProcesses) {
            System.out.println("P" + p.processID + "           " + p.startTime + "          " + p.final_END_TIME + "         " + p.waitingTime + "        " + p.responseTime + "             " + p.turnaroundTime);
        }
        System.out.println("Average Waiting Time  : " + AVERAGE_WAITING_TIME);
        System.out.println("Average Response Time : " + AVERAGE_RESPONSE_TIME);
        System.out.println("\n\n\n\n");
    }

    private static void preemptiveSJF(ProcessArr[] myProcesses) {
        Arrays.sort(myProcesses, Comparator.comparingInt(a -> a.arrivalTime));
        ArrayList<ProcessArr> queues = new ArrayList<>();
        int startTime = myProcesses[0].arrivalTime;
        for (ProcessArr p : myProcesses) if (p.arrivalTime <= startTime) queues.add(p);
        queues.sort((a, b) -> Integer.compare(a.arrivalTime, b.arrivalTime));

        List<Integer> sequence = new ArrayList<>();
        while (!queues.isEmpty()) {

            ProcessArr p = queues.get(0);
            sequence.add(p.processID);


            if (p.startTime == Integer.MAX_VALUE) {
                p.startTime = startTime;
            }

            startTime++;
            p.present_BURST_SIZE--;

            if (p.present_BURST_SIZE == 0) {
                p.final_END_TIME = startTime + p.present_BURST_SIZE;
                p.turnaroundTime = p.final_END_TIME - p.arrivalTime;
                p.waitingTime = p.turnaroundTime - p.burstTime;
                p.responseTime = p.startTime - p.arrivalTime;

                queues.remove(0);
            }

            p.checked = true;

            for (ProcessArr process : myProcesses)
                if (!process.checked && process.arrivalTime <= startTime) {
                    queues.add(process);
                    process.checked = true;
                }
            queues.sort(Comparator.comparingInt(a -> a.burstTime));
        }

        int TOTAL_WAITING_TIME = 0;
        double AVERAGE_WAITING_TIME;

        int TOTAL_RESPONSE_TIME = 0;
        double AVERAGE_RESPONSE_TIME;

        for (ProcessArr p : myProcesses) {
            TOTAL_WAITING_TIME += p.waitingTime;
            TOTAL_RESPONSE_TIME += p.responseTime;
        }
        AVERAGE_WAITING_TIME = TOTAL_WAITING_TIME / (double) myProcesses.length;
        AVERAGE_RESPONSE_TIME = TOTAL_RESPONSE_TIME / (double) myProcesses.length;

//        Printing the whole part
        System.out.println("PreemptiveSJF Scheduling : --------------------------- ");
        System.out.print("P" + sequence.remove(0));
        for (Integer in : sequence) {
            System.out.print(" --> P" + in);
        }
        System.out.println();

        System.out.println("ProcessName StartTime EndTime WaitingTime ResponseTime TurnAroundTime");
        for (ProcessArr p : myProcesses) {
            System.out.println("P" + p.processID + "           " + p.startTime + "          " + p.final_END_TIME + "         " + p.waitingTime + "        " + p.responseTime + "             " + p.turnaroundTime);
        }
        System.out.println("Average Waiting Time  : " + AVERAGE_WAITING_TIME);
        System.out.println("Average Response Time : " + AVERAGE_RESPONSE_TIME);
        System.out.println("\n\n\n\n");
    }

    private static void roundRobin(ProcessArr[] myProcesses) {
        Arrays.sort(myProcesses, Comparator.comparingInt(a -> a.arrivalTime));
        ArrayList<ProcessArr> queues = new ArrayList<>();
        int startTime = myProcesses[0].arrivalTime;
        for (ProcessArr p : myProcesses) if (p.arrivalTime <= startTime) queues.add(p);
        queues.sort(Comparator.comparingInt(a -> a.arrivalTime));

        List<Integer> sequence = new ArrayList<>();

        while (!queues.isEmpty()) {

            ProcessArr p = queues.get(0);
            sequence.add(p.processID);

            boolean willBeAdded = false;

            if (p.startTime == Integer.MAX_VALUE) {
                p.startTime = startTime;
            }

            if (p.present_BURST_SIZE <= QUANTUM_TIME) {
                p.final_END_TIME = startTime + p.present_BURST_SIZE;
                p.turnaroundTime = p.final_END_TIME - p.arrivalTime;
                p.waitingTime = p.turnaroundTime - p.burstTime;
                p.responseTime = p.startTime - p.arrivalTime;

                startTime += p.present_BURST_SIZE;
                p.present_BURST_SIZE = 0;

                p.checked = true;
                queues.remove(0);
            } else {
                startTime += QUANTUM_TIME;
                p.checked = true;
                p.present_BURST_SIZE -= QUANTUM_TIME;
                willBeAdded = true;
            }

            ArrayList<ProcessArr> list = new ArrayList<>();
            for (ProcessArr process : myProcesses)
                if (!process.checked && process.arrivalTime <= startTime) {
                    list.add(process);
                    process.checked = true;
                }
//            list.sort(Comparator.comparingInt(a -> a.arrivalTime));

            queues.addAll(list);
            if (willBeAdded) queues.add(queues.remove(0));
        }

        int TOTAL_WAITING_TIME = 0;
        double AVERAGE_WAITING_TIME;

        int TOTAL_RESPONSE_TIME = 0;
        double AVERAGE_RESPONSE_TIME;

        for (ProcessArr p : myProcesses) {
            TOTAL_WAITING_TIME += p.waitingTime;
            TOTAL_RESPONSE_TIME += p.responseTime;
        }
        AVERAGE_WAITING_TIME = TOTAL_WAITING_TIME / (double) myProcesses.length;
        AVERAGE_RESPONSE_TIME = TOTAL_RESPONSE_TIME / (double) myProcesses.length;

//        Printing the whole part
        System.out.println("Round Robin (quantum=4) Scheduling : --------------------------- ");
        System.out.print("P" + sequence.remove(0));
        for (Integer in : sequence) {
            System.out.print(" --> P" + in);
        }
        System.out.println();

        System.out.println("ProcessName StartTime EndTime WaitingTime ResponseTime TurnAroundTime");
        for (ProcessArr p : myProcesses) {
            System.out.println("P" + p.processID + "           " + p.startTime + "          " + p.final_END_TIME + "         " + p.waitingTime + "        " + p.responseTime + "             " + p.turnaroundTime);
        }
        System.out.println("Average Waiting Time  : " + AVERAGE_WAITING_TIME);
        System.out.println("Average Response Time : " + AVERAGE_RESPONSE_TIME);
        System.out.println("\n\n\n\n");

    }

    private static class ProcessArr {
        public int startTime;
        public int present_BURST_SIZE;
        public int final_END_TIME;
        public int turnaroundTime;
        public int waitingTime;
        public int responseTime;
        public boolean checked;
        int processID;
        int arrivalTime;
        int burstTime;
        int priority;

        public ProcessArr(int processID, int arrivalTime, int burstTime, int priority) {
            this.processID = processID;
            this.arrivalTime = arrivalTime;
            this.burstTime = burstTime;
            this.priority = priority;
            this.startTime = Integer.MAX_VALUE;
            this.final_END_TIME = Integer.MAX_VALUE;
            this.present_BURST_SIZE = burstTime;
            this.checked = false;
        }
    }
}