Fix

Author: Hardvan

src/main/java/com/thealgorithms/scheduling/EnergyAwareScheduling.java

@@ -2,10 +2,12 @@
 
 import java.util.ArrayList;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
- * EnergyAwareScheduling schedules tasks based on their energy consumption profile,
+ * EnergyAwareScheduling schedules tasks based on their energy consumption profile and execution time,
  * aiming to minimize the overall energy usage of the system.
  *
  * Use Case: Mobile devices, embedded systems, and data centers that need to save power
@@ -18,10 +20,12 @@ public final class EnergyAwareScheduling {
     static class Task {
         String name;
         int energyConsumption;
+        int executionTime;
 
-        Task(String name, int energyConsumption) {
+        Task(String name, int energyConsumption, int executionTime) {
             this.name = name;
             this.energyConsumption = energyConsumption;
+            this.executionTime = executionTime;
         }
     }
 
@@ -31,16 +35,36 @@ public EnergyAwareScheduling() {
         tasks = new ArrayList<>();
     }
 
-    public void addTask(String name, int energyConsumption) {
-        tasks.add(new Task(name, energyConsumption));
+    public void addTask(String name, int energyConsumption, int executionTime) {
+        tasks.add(new Task(name, energyConsumption, executionTime));
     }
 
-    public List<String> scheduleTasks() {
+    /**
+     * Schedules tasks in an order that minimizes cumulative energy consumption and
+     * returns both the scheduled order and the total energy consumption.
+     * Steps:
+     * 1. Sort tasks by energy consumption per time unit to minimize cumulative energy cost.
+     * 2. Schedule tasks in the order of sorted tasks.
+     * 3. Calculate the total energy consumption.
+     * 4. Return the scheduled order and total energy consumption.
+     *
+     * @return a map containing the scheduled order and total energy consumption.
+     */
+    public Map<String, Object> scheduleTasks() {
         tasks.sort(Comparator.comparingInt(t -> t.energyConsumption));
+
         List<String> scheduledOrder = new ArrayList<>();
+        int currentTime = 0;
+        int totalEnergyConsumption = 0;
         for (Task task : tasks) {
             scheduledOrder.add(task.name);
+            currentTime += task.executionTime;
+            totalEnergyConsumption += currentTime * task.energyConsumption;
         }
-        return scheduledOrder;
+
+        Map<String, Object> result = new HashMap<>();
+        result.put("scheduledOrder", scheduledOrder);
+        result.put("totalEnergyConsumption", totalEnergyConsumption);
+        return result;
     }
 }

src/test/java/com/thealgorithms/scheduling/EnergyAwareSchedulingTest.java

@@ -3,6 +3,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.List;
+import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -17,32 +18,56 @@ public void setup() {
 
     @Test
     public void testAddAndScheduleSingleTask() {
-        scheduler.addTask("Task1", 10);
-        List<String> expected = List.of("Task1");
-        assertEquals(expected, scheduler.scheduleTasks());
+        scheduler.addTask("Task1", 10, 5);
+
+        // Expected schedule and energy consumption
+        List<String> expectedOrder = List.of("Task1");
+        int expectedEnergyConsumption = 10 * 5;
+
+        Map<String, Object> result = scheduler.scheduleTasks();
+        assertEquals(expectedOrder, result.get("scheduledOrder"));
+        assertEquals(expectedEnergyConsumption, result.get("totalEnergyConsumption"));
     }
 
     @Test
     public void testScheduleMultipleTasks() {
-        scheduler.addTask("Task1", 10);
-        scheduler.addTask("Task2", 5);
-        scheduler.addTask("Task3", 15);
-        List<String> expected = List.of("Task2", "Task1", "Task3");
-        assertEquals(expected, scheduler.scheduleTasks());
+        scheduler.addTask("Task1", 10, 3);
+        scheduler.addTask("Task2", 5, 2);
+        scheduler.addTask("Task3", 15, 4);
+
+        // Expected schedule order and cumulative energy calculation
+        List<String> expectedOrder = List.of("Task2", "Task1", "Task3");
+
+        int expectedEnergyConsumption = 195;
+
+        Map<String, Object> result = scheduler.scheduleTasks();
+        assertEquals(expectedOrder, result.get("scheduledOrder"));
+        assertEquals(expectedEnergyConsumption, result.get("totalEnergyConsumption"));
     }
 
     @Test
     public void testScheduleTasksWithSameConsumption() {
-        scheduler.addTask("Task1", 10);
-        scheduler.addTask("Task2", 10);
-        scheduler.addTask("Task3", 5);
-        List<String> expected = List.of("Task3", "Task1", "Task2");
-        assertEquals(expected, scheduler.scheduleTasks());
+        scheduler.addTask("Task1", 10, 2);
+        scheduler.addTask("Task2", 10, 1);
+        scheduler.addTask("Task3", 5, 3);
+
+        List<String> expectedOrder = List.of("Task3", "Task1", "Task2");
+
+        int expectedEnergyConsumption = 125;
+
+        Map<String, Object> result = scheduler.scheduleTasks();
+        assertEquals(expectedOrder, result.get("scheduledOrder"));
+        assertEquals(expectedEnergyConsumption, result.get("totalEnergyConsumption"));
     }
 
     @Test
     public void testEmptyScheduler() {
-        List<String> expected = List.of();
-        assertEquals(expected, scheduler.scheduleTasks());
+        Map<String, Object> result = scheduler.scheduleTasks();
+
+        List<String> expectedOrder = List.of();
+        int expectedEnergyConsumption = 0;
+
+        assertEquals(expectedOrder, result.get("scheduledOrder"));
+        assertEquals(expectedEnergyConsumption, result.get("totalEnergyConsumption"));
     }
 }