Can you please help me with this assignment by 11 /21 and the folder name...

Question

Can you please help me with this assignment by 11 /21 and the folder name 2150_data_structure_katelyn_nolanAssignment_3.pdf CSCI 2125: Assignment 3    Problem Description     In this homework, you will use the priority queue to simulate scheduling of tasks.     1.1. Input and Output     Startup.java works as the starting point of the program, which takes as argument  the name of an input file. So, the program can be executed using commands as follows:        java Startup input.txt     java Startup in.txt    Each non-blank line in the input file contains a comment or specification of a  task. If a line starts with //, the line should be interpreted as a comment line. A task’s  specification is composed of three parts, separated by a space, and looks like as follows:         task-name deadline duration    A task-name is represented using String, while the deadline and duration are long  values. Table 1 presents content of a sample input file. It doesn’t really matter what the  units of time are in this file. If it helps, you may consider the unit to be second. The  execution of the tasks starts at 00 time (can be interpreted as midnight). The deadline is  the unit elapsed time since 00 time.                             Each task-specification line tells your program to insert the corresponding item  into the priority queue, where priority corresponds to its deadline. Tasks with earlier  (smaller) deadlines have higher priorities, and should be executed first – this is called  Earliest Deadline First scheduling, and is often used in real-time systems. You can read  about it in wikipedia  (http://en.wikipedia.org/wiki/Earliest_deadline_first_scheduling), if interested.     The first task (i.e., highest priority task) starts executing at 00 time. Tasks  execute sequentially one after another (not in parallel) from highest priority to the  lowest priority. As a task completes, it is considered that the time required for that task  has also elapsed.     A task finishing after its prescribed deadline produces a lag, which is the  difference between the task completion time and its prescribed deadline. The program  computes and reports the total lag over all tasks, which is the summation of lags for all  the late-completed tasks. There is no negative lag if a task completes before its deadline.  As each task completes, its start-time, completion time, and any produced lag is  reported to the terminal. A sample output (corresponding to the input in Table 1) is  presented in Table 2.     1.2. Source Files     Majority of the source code necessary for this homework is already written for  you. You need to download the following java source files from moodle.     • Startup.java: starting point of the program.   • FileInputReader.java: reads input file.   • Task.java: represents a task.   • Scheduler.java: schedules the tasks.   • HardWorker.java: actually performs a task.     A necessary implementation of UnboundedPriorityQueue is missing. You have to  provide a clean implementation of an UnboundedPriorityQueue, for which you will use  (by composition) a MinHeap. Your Implementation of UnboundedPri- orityQueue must  NOT be restricted/fixed in a particular size/capacity and it must seamlessly work with  rest of the program provided. You must NOT modify any source code other than your  own implementation of UnboundedPriorityQueue, Min- Heap, and corresponding test  code.   The relationships among the classes and their contents/members are shown in the UML  diagram in Figure 1. Notice that MinHeap is described to have a number of overloaded  constructors. You don’t have to provide all those constructors. It will be sufficient to  have only the constructors necessary for the entire simulation program (and your test  code) to work.     1.3. Test Code     Your implementation of MinHeap and UnboundedPriorityQueue must be  accompanied by JUnit test code written in source files exactly named as  TestMinHeap.java and TestUnboundedPriorityQueue.java respectively. Consider all  corner cases, in which your implementation may fail, and deal with them in your tests.  Include enough test cases to make sure that your UnboundedPriorityQueue and  MinHeap function correctly. For more about JUnit testing, please see the instructions available on moodle:     https://moodle.uno.edu/pluginfile.php/2431551/mod_resource/content/1/Junit_testin g.pdf    1.4. ReadMe.txt     When the description of the assignment does not explicitly specify something,  you have the liberty to make your choices in those scenarios. Please mention any design  choices you made including any reasoning behind your choices in a ReadMe.txt file. If  you could not complete a certain part correctly, mention it in ReadMe.txt. If you did not  find anything to include in the file, simply put your name and email address.                                                           2. Clean Code  Make sure you have produced clean code as discussed in the first class. Please see the  general guidelines for producing clean code available on moodle:   https://moodle.uno.edu/pluginfile.php/2431549/mod_resource/content/1/CleanCodeI nstructions_java.pdf  3. Deadline  November 22nd 2020 midnight (Hard Deadline)  *Late submission is permitted till 25th November midnight with a penalty of losing 25%  every day. After that, submission will be locked. 4. Submission  Keep all your files in a folder and zip it with the following format –   Firstname_Lastname.zip  Upload the zipped file in moodle before the deadline.    • Please be advised that, there is no option of new file submission after the final  deadline. Also, no update is permitted in graded work. Make sure you have  submitted the right source file. srcForStudents.zip __MACOSX/._srcForStudents srcForStudents/Scheduler.java srcForStudents/Scheduler.java import java.util.List; public class Scheduler{     UnboundedPriorityQueue queue;     public Scheduler(){         queue = new UnboundedPriorityQueue();     }     public void scheduleTasks(List taskList){              for(Task task: taskList){             queue.enqueue(task);         }     }     public long dispatchTasks(){         long startTime = 0;         long completionTime = 0;         long totalLag = 0;         Task task = null;         while(!queue.isEmpty()){             task = queue.dequeue();             completionTime = HardWorker.completeTask(task, startTime);             if(completionTime > task.getDeadline()){                 totalLag += completionTime - task.getDeadline();             }             startTime = completionTime;         }         return totalLag;     } } __MACOSX/srcForStudents/._Scheduler.java srcForStudents/HardWorker.java srcForStudents/HardWorker.java public class HardWorker{     public static long completeTask(Task task, long startTime){         long endTime = startTime + task.getDuration();                  System.out.printf("[%4d] %s STARTED
", startTime, task.getName());         System.out.printf("[%4d] %s ENDED", endTime, task.getName());                  if(endTime > task.getDeadline()){             System.out.println(", behind schedule by " + (endTime - task.getDeadline()));         }else{             System.out.println(", completed in time");         }         return startTime + task.getDuration();     } } __MACOSX/srcForStudents/._HardWorker.java srcForStudents/input.txt // task-name deadline duration build-project 1220 20 unit-tests 1230 2300 integration-test 1359 300 regression-test 1410 20 __MACOSX/srcForStudents/._input.txt srcForStudents/Task.java srcForStudents/Task.java public class Task implements Comparable{       private String name;     private Long duration;     private Long deadline;     public Task(String name, long deadline, long duration){         this.name = name;                this.duration = duration;         this.deadline = deadline;     }     public long getDeadline(){         return this.deadline.longValue();     }     public long getDuration(){         return this.duration.longValue();     }     public String getName(){         return this.name;     }     @Override     public int compareTo(Task other){         return this.deadline.compareTo(other.getDeadline());     }     @Override     public String toString(){         return "Name:" + name + ", duration:" + duration                          + ", deadline:" + deadline;      } } __MACOSX/srcForStudents/._Task.java srcForStudents/FileInputReader.java srcForStudents/FileInputReader.java import java.util.List; import java.util.ArrayList; import java.io.*; public class FileInputReader{     private static final String COMMENT_LINE_MARKER = "//";     public static List readTasksInfo(String filePath){         BufferedReader reader = null;         List taskList = new ArrayList();         try{             reader = new BufferedReader(new FileReader(new File(filePath)));         }catch(FileNotFoundException e){             e.printStackTrace();         }         try{             String line = null;             while((line = reader.readLine())!= null){                                if(line.startsWith(COMMENT_LINE_MARKER)) continue;                 //System.out.println(line);                 Task task = parseLine(line.trim());                              taskList.add(task);                          }             // close the file             reader.close();         }catch(IOException e){             e.printStackTrace();         }         return taskList;     }     private static Task parseLine(String line){         String[] values = line.split(" ");         if(values.length  tasksList = FileInputReader.readTasksInfo(args[0]);                  Scheduler scheduler = new Scheduler();         scheduler.scheduleTasks(tasksList);         long totalLag = scheduler.dispatchTasks();         System.out.println("Total lag (behind expected schedule): " + totalLag);     } } __MACOSX/srcForStudents/._Startup.java

Abr Writing · Accepted Answer

src/FileInputReader.java
src/FileInputReader.java
import java.util.List;
import java.util.ArrayList;
import java.io.*;
public class FileInputReader{
    private static final String COMMENT_LINE_MARKER = "//";
    public static List readTasksInfo(String filePath){
        BufferedReader reader = null;
        List taskList = new ArrayList();
        try{
            reader = new BufferedReader(new FileReader(new File(filePath)));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        try{
            String line = null;
            while((line = reader.readLine())!= null){               
                if(line.startsWith(COMMENT_LINE_MARKER)) continue;
                //System.out.println(line);
                Task task = parseLine(line.trim());             
                taskList.add(task);             
            }
            // close the file
            reader.close();
        }catch(IOException e){
            e.printStackTrace();
        }
        return taskList;
    }
    private static Task parseLine(String line){
        String[] values = line.split(" ");
        if(values.length  task.getDeadline()){
            System.out.println(", behind schedule by " + (endTime - task.getDeadline()));
        }else{
            System.out.println(", completed in time");
        }
        return startTime + task.getDuration();
    }
}
src/input.txt
// task-name deadline duration
build-project 1220 20
unit-tests 1230 2300
integration-test 1359 300
regression-test 1410 20
src/MinHeap.java
src/MinHeap.java
/*
 * A heap must be a complete binary tree where all
 *  nodes must be filled and last level must be filled
 *  as far left as possible.
 * A min-heap means that for each non-leaf node, V,
 *  the value in V is smaller than the value of its
 *  children.
 */
import java.util.ArrayList;
import java.util.NoSuchElementException;
public class MinHeap> {
    private ArrayList list;
    /*
     * Default constructor. */
    public MinHeap() {
        this.list = new ArrayList();
    }
    /*
     * Insert the given T value to the end of the list. */
    public void insert(T value) {
        this.list.add(value);   // add value to end of list
        int pos = this.list.size()-1;   // current location of value
        int parent = (pos-1)/2; // location of value's parent
        while(pos > 0 && this.list.get(parent).compareTo(this.list.get(pos)) > 0) { // if parent is greater than value
            /*  swap value and parent */
            T tmp = this.list.get(parent);  // store parent temporarily
            this.list.set(parent, this.list.get(pos));  // place value where parent is
            this.list.set(pos, tmp);    // place parent where value was
            pos = parent;   // point to new location of value
            parent = (pos-1)/2; // point to value's new parent
        }
    }
    /*
     * Remove the element at front of the list (root node)
     *  and return the removed element.
     *
     * @return the removed element */
    public T remove() {
        if(isEmpty()) { // if the tree is empty
            throw new NoSuchElementException(); // throw exception
        }
        T ret = this.list.get(0);
        if(this.list.size() == 1) {
            ret = this.list.remove(0);
            return ret;
        }
        else if(this.list.size() >= 3) {    // else tree is not empty
            ret = this.list.get(0); // store the root node that will be removed
            this.list.set(0, this.list.get(this.list.size()-1));    // place the last node to the root position
            this.list.remove(this.list.size()-1);   // remove the last node's previous position
            if(this.list.size() == 2) {
                return ret;
            }
//          if(this.list.size() >= 3) { 
                int pos = 0;    // point to the current position (root)
                int left = 2*pos+1; // point to the current's left
                int right = 2*pos+2;    // point to the current's right
                while(this.list.get(pos).compareTo(this.list.get(left)) > 0 ||  // is current greater than its left?
                         this.list.get(pos).compareTo(this.list.get(right)) > 0) {  //  or is current greater than its right?
                    if(this.list.get(left).compareTo(this.list.get(right)) = this.list.size() || 2*pos+2 >= this.list.size()) {    // if current's children are greater than itself
                            break;  // break out
                        }
                        else {  // else continue loop
                            left = 2*pos+1; // update current's left
                            right = 2*pos+2;    // update current's right
                        }
                    }
                    else {  // else current's right is less than its left
                        /* swap current with its right */
                        T tmpRight = this.list.get(right);  // temporarily store current's right
                        this.list.set(right, this.list.get(pos));   // place current into right's position
                        this.list.set(pos, tmpRight);   // place right into current's previous position
                        pos = right;    // point to new current position
                        if(2*pos+1 >= this.list.size() || 2*pos+2 >= this.list.size()) {    // if current's children are greater than itself
                            break;  // break out
                        }
                        else {  // else continue loop
                            left = 2*pos+1;

Assignment_3.pdf CSCI 2125: Assignment 3 Problem Description In this homework, you will use the priority queue to simulate scheduling of tasks. 1.1. Input and Output Startup.java works as the starting...

Answer To: Assignment_3.pdf CSCI 2125: Assignment 3 Problem Description In this homework, you will use the...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment