Merge branch 'master' into test/PrimeFactorizationTest

Author: siriak

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

@@ -1,39 +1,33 @@
 package com.thealgorithms.others;
 
-import java.util.Arrays;
-
 /**
- * The two pointer technique is a useful tool to utilize when searching for
+ * The two-pointer technique is a useful tool to utilize when searching for
  * pairs in a sorted array.
  *
  * <p>
- * link: https://www.geeksforgeeks.org/two-pointers-technique/
+ * Link: https://www.geeksforgeeks.org/two-pointers-technique/
  */
 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 key.
+     * 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.
      *
-     * @param arr the array contains elements
+     * @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.
+     * @return {@code true} if there exists a pair of elements, {@code false} otherwise.
      */
     public static boolean isPairedSum(int[] arr, int key) {
-        /* array sorting is necessary for this algorithm to function correctly */
-        Arrays.sort(arr);
-        int i = 0;
-        /* index of first element */
-        int j = arr.length - 1;
-        /* index of last element */
+        int i = 0; // index of the first element
+        int j = arr.length - 1; // index of the last element
 
         while (i < j) {
-            if (arr[i] + arr[j] == key) {
+            int sum = arr[i] + arr[j];
+            if (sum == key) {
                 return true;
-            } else if (arr[i] + arr[j] < key) {
+            } else if (sum < key) {
                 i++;
             } else {
                 j--;

src/test/java/com/thealgorithms/maths/ReverseNumberTest.java

@@ -3,27 +3,21 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import java.util.HashMap;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
 public class ReverseNumberTest {
 
-    @Test
-    public void testReverseNumber() {
-        HashMap<Integer, Integer> testCases = new HashMap<>();
-        testCases.put(0, 0);
-        testCases.put(1, 1);
-        testCases.put(10, 1);
-        testCases.put(123, 321);
-        testCases.put(7890, 987);
-
-        for (final var tc : testCases.entrySet()) {
-            assertEquals(ReverseNumber.reverseNumber(tc.getKey()), tc.getValue());
-        }
+    @ParameterizedTest
+    @CsvSource({"0, 0", "1, 1", "10, 1", "123, 321", "7890, 987"})
+    public void testReverseNumber(int input, int expected) {
+        assertEquals(expected, ReverseNumber.reverseNumber(input));
     }
 
-    @Test
-    public void testReverseNumberThrowsExceptionForNegativeInput() {
-        assertThrows(IllegalArgumentException.class, () -> ReverseNumber.reverseNumber(-1));
+    @ParameterizedTest
+    @ValueSource(ints = {-1, -123, -7890})
+    public void testReverseNumberThrowsExceptionForNegativeInput(int input) {
+        assertThrows(IllegalArgumentException.class, () -> ReverseNumber.reverseNumber(input));
     }
 }

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

@@ -8,37 +8,65 @@
 public class TwoPointersTest {
 
     @Test
-    void twoPointersFirstTestCase() {
+    void testPositivePairExists() {
         int[] arr = {2, 6, 9, 22, 121};
         int key = 28;
         assertTrue(TwoPointers.isPairedSum(arr, key));
     }
 
     @Test
-    void twoPointersSecondTestCase() {
-        int[] arr = {-1, -12, 12, 0, 8};
+    void testNegativePairExists() {
+        int[] arr = {-12, -1, 0, 8, 12};
         int key = 0;
         assertTrue(TwoPointers.isPairedSum(arr, key));
     }
 
     @Test
-    void twoPointersThirdTestCase() {
-        int[] arr = {12, 35, 12, 152, 0};
+    void testPairDoesNotExist() {
+        int[] arr = {0, 12, 12, 35, 152};
         int key = 13;
         assertFalse(TwoPointers.isPairedSum(arr, key));
     }
 
     @Test
-    void twoPointersFourthTestCase() {
-        int[] arr = {-2, 5, -1, 52, 31};
-        int key = -3;
+    void testNegativeSumPair() {
+        int[] arr = {-10, -3, 1, 2, 5, 9};
+        int key = -8;
         assertTrue(TwoPointers.isPairedSum(arr, key));
     }
 
     @Test
-    void twoPointersFiftiethTestCase() {
-        int[] arr = {25, 1, 0, 61, 21};
-        int key = 12;
+    void testPairDoesNotExistWithPositiveSum() {
+        int[] arr = {1, 2, 3, 4, 5};
+        int key = 10;
         assertFalse(TwoPointers.isPairedSum(arr, key));
     }
+
+    @Test
+    void testEmptyArray() {
+        int[] arr = {};
+        int key = 5;
+        assertFalse(TwoPointers.isPairedSum(arr, key));
+    }
+
+    @Test
+    void testSingleElementArray() {
+        int[] arr = {5};
+        int key = 5;
+        assertFalse(TwoPointers.isPairedSum(arr, key));
+    }
+
+    @Test
+    void testArrayWithDuplicateElements() {
+        int[] arr = {1, 1, 3, 5, 5};
+        int key = 6;
+        assertTrue(TwoPointers.isPairedSum(arr, key));
+    }
+
+    @Test
+    void testPairExistsAtEdges() {
+        int[] arr = {1, 3, 4, 7, 8};
+        int key = 9;
+        assertTrue(TwoPointers.isPairedSum(arr, key));
+    }
 }