refactor: LineSweep (#5398)

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

@@ -1,42 +1,49 @@
 package com.thealgorithms.others;
+
 import java.util.Arrays;
 import java.util.Comparator;
 
-/* Line Sweep algorithm can be used to solve range problems by first sorting the list of ranges
+/**
- * by the start value of the range in non-decreasing order and doing a "sweep" through the number
+ * The Line Sweep algorithm is used to solve range problems efficiently. It works by:
- * line(x-axis) by incrementing the start point by 1 and decrementing the end point+1 by 1 on the
+ * 1. Sorting a list of ranges by their start values in non-decreasing order.
- * number line.
+ * 2. Sweeping through the number line (x-axis) while updating a count for each point based on the ranges.
- * An overlapping range is defined as (StartA <= EndB) AND (EndA >= StartB)
+ *
- * References
+ * An overlapping range is defined as:
- * https://en.wikipedia.org/wiki/Sweep_line_algorithm
+ * - (StartA <= EndB) AND (EndA >= StartB)
- * https://en.wikipedia.org/wiki/De_Morgan%27s_laws>
+ *
+ * References:
+ * - https://en.wikipedia.org/wiki/Sweep_line_algorithm
+ * - https://en.wikipedia.org/wiki/De_Morgan%27s_laws
  */
 public final class LineSweep {
     private LineSweep() {
     }
 
     /**
-     * Find Maximum end point
+     * Finds the maximum endpoint from a list of ranges.
-     *   param = ranges : Array of range[start,end]
+     *
-     *   return Maximum Endpoint
+     * @param ranges a 2D array where each element is a range represented by [start, end]
+     * @return the maximum endpoint among all ranges
      */
     public static int findMaximumEndPoint(int[][] ranges) {
-        Arrays.sort(ranges, Comparator.comparingInt(a -> a[1]));
+        Arrays.sort(ranges, Comparator.comparingInt(range -> range[1]));
         return ranges[ranges.length - 1][1];
     }
 
     /**
-     * Find if any ranges overlap
+     * Determines if any of the given ranges overlap.
-     *   param = ranges : Array of range[start,end]
+     *
-     *   return true if overlap exists false otherwise.
+     * @param ranges a 2D array where each element is a range represented by [start, end]
+     * @return true if any ranges overlap, false otherwise
      */
     public static boolean isOverlap(int[][] ranges) {
+        if (ranges == null || ranges.length == 0) {
+            return false;
+        }
 
         int maximumEndPoint = findMaximumEndPoint(ranges);
-        Arrays.sort(ranges, Comparator.comparingInt(a -> a[0]));
         int[] numberLine = new int[maximumEndPoint + 2];
         for (int[] range : ranges) {
-
             int start = range[0];
             int end = range[1];
 
@@ -44,12 +51,12 @@ public final class LineSweep {
             numberLine[end + 1] -= 1;
         }
 
-        int current = 0;
+        int currentCount = 0;
-        int overlaps = 0;
+        int maxOverlaps = 0;
-        for (int num : numberLine) {
+        for (int count : numberLine) {
-            current += num;
+            currentCount += count;
-            overlaps = Math.max(overlaps, current);
+            maxOverlaps = Math.max(maxOverlaps, currentCount);
         }
-        return overlaps > 1;
+        return maxOverlaps > 1;
     }
 }

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

@@ -1,30 +1,37 @@
 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.assertTrue;
 
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
 public class LineSweepTest {
-
+    private record OverlapTestCase(int[][] ranges, boolean expected) {
-    @Test
-    void testForOverlap() {
-        int[][] arr = {{0, 10}, {7, 20}, {15, 24}};
-        assertTrue(LineSweep.isOverlap(arr));
     }
 
-    @Test
+    private record MaximumEndPointTestCase(int[][] ranges, int expected) {
-    void testForNoOverlap() {
-        int[][] arr = {{0, 10}, {11, 20}, {21, 24}};
-        assertFalse(LineSweep.isOverlap(arr));
     }
-    @Test
+
-    void testForOverlapWhenEndAEqualsStartBAndViceVersa() {
+    @ParameterizedTest
-        int[][] arr = {{0, 10}, {10, 20}, {21, 24}};
+    @MethodSource("provideOverlapTestData")
-        assertTrue(LineSweep.isOverlap(arr));
+    void testIsOverlap(OverlapTestCase testCase) {
+        assertEquals(testCase.expected(), LineSweep.isOverlap(testCase.ranges()));
     }
-    @Test
+
-    void testForMaximumEndPoint() {
+    private static Stream<Arguments> provideOverlapTestData() {
-        int[][] arr = {{10, 20}, {1, 100}, {14, 16}, {1, 8}};
+        return Stream.of(Arguments.of(new OverlapTestCase(new int[][] {{0, 10}, {7, 20}, {15, 24}}, true)), Arguments.of(new OverlapTestCase(new int[][] {{0, 10}, {11, 20}, {21, 24}}, false)), Arguments.of(new OverlapTestCase(new int[][] {{0, 10}, {10, 20}, {21, 24}}, true)),
-        assertEquals(100, LineSweep.findMaximumEndPoint(arr));
+            Arguments.of(new OverlapTestCase(new int[][] {{5, 10}}, false)), Arguments.of(new OverlapTestCase(new int[][] {{1, 5}, {1, 5}, {1, 5}}, true)), Arguments.of(new OverlapTestCase(new int[][] {{1, 1}, {2, 2}, {3, 3}}, false)), Arguments.of(new OverlapTestCase(new int[][] {}, false)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideMaximumEndPointTestData")
+    void testFindMaximumEndPoint(MaximumEndPointTestCase testCase) {
+        assertEquals(testCase.expected(), LineSweep.findMaximumEndPoint(testCase.ranges()));
+    }
+
+    private static Stream<Arguments> provideMaximumEndPointTestData() {
+        return Stream.of(Arguments.of(new MaximumEndPointTestCase(new int[][] {{10, 20}, {1, 100}, {14, 16}, {1, 8}}, 100)));
     }
 }