Merge remote-tracking branch 'origin/refactor/ceil' into refactor/ceil

Author: alxkm

src/main/java/com/thealgorithms/others/TwoPointers.java

@@ -7,30 +7,37 @@
  * <p>
  * Link: https://www.geeksforgeeks.org/two-pointers-technique/
  */
-final class TwoPointers {
+public final class TwoPointers {
+
     private TwoPointers() {
     }
 
     /**
-     * Given a sorted array arr (sorted in ascending order), find if there exists
-     * any pair of elements such that their sum is equal to the key.
+     * Checks whether there exists a pair of elements in a sorted array whose sum equals the specified key.
      *
-     * @param arr the array containing elements (must be sorted in ascending order)
-     * @param key the number to search
-     * @return {@code true} if there exists a pair of elements, {@code false} otherwise.
+     * @param arr a sorted array of integers in ascending order (must not be null)
+     * @param key the target sum to find
+     * @return {@code true} if there exists at least one pair whose sum equals {@code key}, {@code false} otherwise
+     * @throws IllegalArgumentException if {@code arr} is {@code null}
      */
     public static boolean isPairedSum(int[] arr, int key) {
-        int i = 0; // index of the first element
-        int j = arr.length - 1; // index of the last element
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array must not be null.");
+        }
+
+        int left = 0;
+        int right = arr.length - 1;
+
+        while (left < right) {
+            int sum = arr[left] + arr[right];
 
-        while (i < j) {
-            int sum = arr[i] + arr[j];
             if (sum == key) {
                 return true;
-            } else if (sum < key) {
-                i++;
+            }
+            if (sum < key) {
+                left++;
             } else {
-                j--;
+                right--;
             }
         }
         return false;

src/main/java/com/thealgorithms/recursion/GenerateSubsets.java

@@ -1,36 +1,52 @@
 package com.thealgorithms.recursion;
 
-// program to find power set of a string
-
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * Utility class to generate all subsets (power set) of a given string using recursion.
+ *
+ * <p>For example, the string "ab" will produce: ["ab", "a", "b", ""]
+ */
 public final class GenerateSubsets {
 
     private GenerateSubsets() {
-        throw new UnsupportedOperationException("Utility class");
     }
 
+    /**
+     * Generates all subsets (power set) of the given string using recursion.
+     *
+     * @param str the input string to generate subsets for
+     * @return a list of all subsets of the input string
+     */
     public static List<String> subsetRecursion(String str) {
-        return doRecursion("", str);
+        return generateSubsets("", str);
     }
 
-    private static List<String> doRecursion(String p, String up) {
-        if (up.isEmpty()) {
-            List<String> list = new ArrayList<>();
-            list.add(p);
-            return list;
+    /**
+     * Recursive helper method to generate subsets by including or excluding characters.
+     *
+     * @param current the current prefix being built
+     * @param remaining the remaining string to process
+     * @return list of subsets formed from current and remaining
+     */
+    private static List<String> generateSubsets(String current, String remaining) {
+        if (remaining.isEmpty()) {
+            List<String> result = new ArrayList<>();
+            result.add(current);
+            return result;
         }
 
-        // Taking the character
-        char ch = up.charAt(0);
-        // Adding the character in the recursion
-        List<String> left = doRecursion(p + ch, up.substring(1));
-        // Not adding the character in the recursion
-        List<String> right = doRecursion(p, up.substring(1));
+        char ch = remaining.charAt(0);
+        String next = remaining.substring(1);
+
+        // Include the character
+        List<String> withChar = generateSubsets(current + ch, next);
 
-        left.addAll(right);
+        // Exclude the character
+        List<String> withoutChar = generateSubsets(current, next);
 
-        return left;
+        withChar.addAll(withoutChar);
+        return withChar;
     }
 }

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

@@ -2,78 +2,62 @@
 
 import com.thealgorithms.devutils.entities.ProcessDetails;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
 import java.util.List;
 
 /**
- * Implementation of Shortest Job First Algorithm: The algorithm allows the waiting process with the
- * minimal burst time to be executed first. see more here:
- * https://www.guru99.com/shortest-job-first-sjf-scheduling.html
+ * Shortest Job First (SJF) Scheduling Algorithm:
+ * Executes processes with the shortest burst time first among the ones that have arrived.
  */
-
 public class SJFScheduling {
-    protected ArrayList<ProcessDetails> processes;
-    protected ArrayList<String> schedule;
-
-    private static void sortProcessesByArrivalTime(List<ProcessDetails> processes) {
-        for (int i = 0; i < processes.size(); i++) {
-            for (int j = i + 1; j < processes.size() - 1; j++) {
-                if (processes.get(j).getArrivalTime() > processes.get(j + 1).getArrivalTime()) {
-                    final var temp = processes.get(j);
-                    processes.set(j, processes.get(j + 1));
-                    processes.set(j + 1, temp);
-                }
-            }
-        }
-    }
+    private final List<ProcessDetails> processes;
+    private final List<String> schedule;
 
-    /**
-     * a simple constructor
-     * @param processes a list of processes the user wants to schedule
-     *  it also sorts the processes based on the time of their arrival
-     */
-    SJFScheduling(final ArrayList<ProcessDetails> processes) {
-        this.processes = processes;
-        schedule = new ArrayList<>();
+    public SJFScheduling(final List<ProcessDetails> processes) {
+        this.processes = new ArrayList<>(processes);
+        this.schedule = new ArrayList<>();
         sortProcessesByArrivalTime(this.processes);
     }
-    protected void sortByArrivalTime() {
-        sortProcessesByArrivalTime(processes);
+
+    private static void sortProcessesByArrivalTime(List<ProcessDetails> processes) {
+        processes.sort(Comparator.comparingInt(ProcessDetails::getArrivalTime));
     }
 
     /**
-     * this functions returns the order of the executions
+     * Executes the SJF scheduling algorithm and builds the execution order.
      */
-
     public void scheduleProcesses() {
-        ArrayList<ProcessDetails> ready = new ArrayList<>();
-
+        List<ProcessDetails> ready = new ArrayList<>();
         int size = processes.size();
-        int runtime;
         int time = 0;
         int executed = 0;
-        int j;
-        int k = 0;
-        ProcessDetails running;
 
-        if (size == 0) {
-            return;
+        Iterator<ProcessDetails> processIterator = processes.iterator();
+
+        // This will track the next process to be checked for arrival time
+        ProcessDetails nextProcess = null;
+        if (processIterator.hasNext()) {
+            nextProcess = processIterator.next();
         }
 
         while (executed < size) {
-            while (k < size && processes.get(k).getArrivalTime() <= time) // here we find the processes that have arrived.
-            {
-                ready.add(processes.get(k));
-                k++;
+            // Load all processes that have arrived by current time
+            while (nextProcess != null && nextProcess.getArrivalTime() <= time) {
+                ready.add(nextProcess);
+                if (processIterator.hasNext()) {
+                    nextProcess = processIterator.next();
+                } else {
+                    nextProcess = null;
+                }
             }
 
-            running = findShortestJob(ready);
+            ProcessDetails running = findShortestJob(ready);
             if (running == null) {
                 time++;
             } else {
-                runtime = running.getBurstTime();
-                for (j = 0; j < runtime; j++) {
-                    time++;
-                }
+                time += running.getBurstTime();
                 schedule.add(running.getProcessId());
                 ready.remove(running);
                 executed++;
@@ -82,30 +66,23 @@ public void scheduleProcesses() {
     }
 
     /**
-     * this function evaluates the shortest job of all the ready processes (based on  a process
-     * burst time)
+     * Finds the process with the shortest job of all the ready processes (based on  a process
      * @param readyProcesses an array list of ready processes
      * @return returns the process' with the shortest burst time OR NULL if there are no ready
      *     processes
      */
-    private ProcessDetails findShortestJob(List<ProcessDetails> readyProcesses) {
-        if (readyProcesses.isEmpty()) {
-            return null;
-        }
-        int i;
-        int size = readyProcesses.size();
-        int minBurstTime = readyProcesses.get(0).getBurstTime();
-        int temp;
-        int positionOfShortestJob = 0;
+    private ProcessDetails findShortestJob(Collection<ProcessDetails> readyProcesses) {
+        return readyProcesses.stream().min(Comparator.comparingInt(ProcessDetails::getBurstTime)).orElse(null);
+    }
 
-        for (i = 1; i < size; i++) {
-            temp = readyProcesses.get(i).getBurstTime();
-            if (minBurstTime > temp) {
-                minBurstTime = temp;
-                positionOfShortestJob = i;
-            }
-        }
+    /**
+     * Returns the computed schedule after calling scheduleProcesses().
+     */
+    public List<String> getSchedule() {
+        return schedule;
+    }
 
-        return readyProcesses.get(positionOfShortestJob);
+    public List<ProcessDetails> getProcesses() {
+        return List.copyOf(processes);
     }
 }

src/test/java/com/thealgorithms/others/TwoPointersTest.java

@@ -1,6 +1,8 @@
 package com.thealgorithms.others;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
@@ -69,4 +71,10 @@ void testPairExistsAtEdges() {
         int key = 9;
         assertTrue(TwoPointers.isPairedSum(arr, key));
     }
+
+    @Test
+    void isPairedSumShouldThrowExceptionWhenArrayIsNull() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> TwoPointers.isPairedSum(null, 10));
+        assertEquals("Input array must not be null.", exception.getMessage());
+    }
 }