resolved errors

Author: Darshan-Baligeri

src/main/java/com/thealgorithms/searches/BinarySearch.java

@@ -25,6 +25,15 @@ class BinarySearch implements SearchAlgorithm {
      */
     @Override
     public <T extends Comparable<T>> int find(T[] array, T key) {
+        if (array == null) {
+            throw new NullPointerException("Input array cannot be null");
+        }
+        if (key == null) {
+            throw new NullPointerException("Key cannot be null");
+        }
+        if (array.length == 0) {
+            return -1; // Explicitly handle empty array
+        }
         return search(array, key, 0, array.length - 1);
     }
 
@@ -53,4 +62,4 @@ private <T extends Comparable<T>> int search(T[] array, T key, int left, int rig
             return search(array, key, median + 1, right);
         }
     }
-}
+}

src/main/java/com/thealgorithms/shufflealogrithm/UniquePairShuffle.java

@@ -2,9 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 public
 final class UniquePairShuffle {

src/main/java/com/thealgorithms/shufflealogrithm/WeightedShuffle.java

@@ -4,11 +4,9 @@
 import java.util.Comparator;
 import java.util.Random;
 
-public
-final class WeightedShuffle {
+public final class WeightedShuffle {
 
-    private
-    WeightedShuffle() {
+    private WeightedShuffle() {
         // Prevent instantiation
     }
 
@@ -19,10 +17,9 @@ final class WeightedShuffle {
      * @param array   the input array to shuffle
      * @param weights the weights for each corresponding element in the array
      */
-    public
-    static void weightedShuffle(int[] array, int[] weights) {
+    public static void weightedShuffle(int[] array, int[] weights) {
         // Edge case: Check if weights match the array size
-        if (array == null || weights == null || array.length != weights.length) {
+        if (array == null || weights == null || array.length!= weights.length) {
             return;
         }
 
@@ -34,8 +31,8 @@ static void weightedShuffle(int[] array, int[] weights) {
         Random random = new Random();
 
         // Sort indices by weights in descending order, prioritizing higher weights
-        Arrays.sort(indices, Comparator.comparingInt((Integer i)->- weights[i])
-                .thenComparingInt(i->random.nextInt()));
+        Arrays.sort(indices, Comparator.comparingInt((Integer i) -> -weights[i])
+                .thenComparingInt(i -> random.nextInt()));
 
         int[] result = new int[array.length];
         for (int i = 0; i < array.length; i++) {
@@ -45,8 +42,7 @@ static void weightedShuffle(int[] array, int[] weights) {
         System.arraycopy(result, 0, array, 0, array.length);
     }
 
-    public
-    static void main(String[] args) {
+    public static void main(String[] args) {
         int[] array = {10, 20, 30};
         int[] weights = {1, 3, 2};
         weightedShuffle(array, weights);
@@ -56,4 +52,4 @@ static void main(String[] args) {
             System.out.print(num + " ");
         }
     }
-}
+}

src/test/java/com/thealgorithms/searches/BinarySearchTest.java

@@ -1,9 +1,9 @@
 package com.thealgorithms.searches;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
 
 import java.util.stream.IntStream;
-import org.junit.jupiter.api.Test;
 
 /**
  * Unit tests for the BinarySearch class.
@@ -19,7 +19,7 @@ void testBinarySearchFound() {
         Integer[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
         int key = 7;
         int expectedIndex = 6; // Index of the key in the array
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the found element should be 6.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the found element should be 6.");
     }
 
     /**
@@ -31,7 +31,7 @@ void testBinarySearchNotFound() {
         Integer[] array = {1, 2, 3, 4, 5};
         int key = 6; // Element not present in the array
         int expectedIndex = -1; // Key not found
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The element should not be found in the array.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The element should not be found in the array.");
     }
 
     /**
@@ -43,7 +43,7 @@ void testBinarySearchFirstElement() {
         Integer[] array = {1, 2, 3, 4, 5};
         int key = 1; // First element
         int expectedIndex = 0; // Index of the key in the array
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the first element should be 0.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the first element should be 0.");
     }
 
     /**
@@ -55,7 +55,7 @@ void testBinarySearchLastElement() {
         Integer[] array = {1, 2, 3, 4, 5};
         int key = 5; // Last element
         int expectedIndex = 4; // Index of the key in the array
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the last element should be 4.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the last element should be 4.");
     }
 
     /**
@@ -67,7 +67,7 @@ void testBinarySearchSingleElementFound() {
         Integer[] array = {1};
         int key = 1; // Only element present
         int expectedIndex = 0; // Index of the key in the array
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the single element should be 0.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the single element should be 0.");
     }
 
     /**
@@ -79,7 +79,7 @@ void testBinarySearchSingleElementNotFound() {
         Integer[] array = {1};
         int key = 2; // Key not present
         int expectedIndex = -1; // Key not found
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The element should not be found in the array.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The element should not be found in the array.");
     }
 
     /**
@@ -91,7 +91,7 @@ void testBinarySearchEmptyArray() {
         Integer[] array = {}; // Empty array
         int key = 1; // Key not present
         int expectedIndex = -1; // Key not found
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The element should not be found in an empty array.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The element should not be found in an empty array.");
     }
 
     /**
@@ -103,6 +103,6 @@ void testBinarySearchLargeArray() {
         Integer[] array = IntStream.range(0, 10000).boxed().toArray(Integer[] ::new); // Array from 0 to 9999
         int key = 9999; // Last element
         int expectedIndex = 9999; // Index of the last element
-        assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the last element should be 9999.");
+        Assertions.assertEquals(expectedIndex, binarySearch.find(array, key), "The index of the last element should be 9999.");
     }
-}
+}

src/test/java/com/thealgorithms/shufflealgorithm/GroupShuffleTest.java

@@ -19,7 +19,8 @@ void testGroupShuffleBasic() {
         assertEquals(3, shuffledGroups.size()); // Expect 3 groups
         assertTrue(shuffledGroups.stream().allMatch(
                 group -> group.size() <= 3)); // All groups should have size <= 3
-        System.out.println("Shuffled Groups (Basic Test): " + shuffledGroups);
+        System.out.println("Shuffled Groups (Basic Test): "
+                + shuffledGroups);
     }
 
     // Test case to check when group size is larger than array length
@@ -32,8 +33,8 @@ void testGroupShuffleLargeGroupSize() {
         assertEquals(
                 Arrays.asList(1, 2, 3),
                 shuffledGroups.get(0)); // The group should contain all elements
-        System.out.println("Shuffled Groups (Large Group Size Test): " +
-                shuffledGroups);
+        System.out.println("Shuffled Groups (Large Group Size Test): "
+                + shuffledGroups);
     }
 
     // Test case to check when the array is null
@@ -42,7 +43,8 @@ void testGroupShuffleNullArray() {
         List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(null, 3);
 
         assertTrue(shuffledGroups.isEmpty()); // Expect empty list
-        System.out.println("Shuffled Groups (Null Array Test): " + shuffledGroups);
+        System.out.println("Shuffled Groups (Null Array Test): "
+                + shuffledGroups);
     }
 
     // Test case to check when group size is less than or equal to zero
@@ -56,8 +58,8 @@ void testGroupShuffleZeroOrNegativeGroupSize() {
         shuffledGroups = GroupShuffle.groupShuffle(array, -1);
         assertTrue(
                 shuffledGroups.isEmpty()); // Expect empty list for negative group size
-        System.out.println("Shuffled Groups (Zero or Negative Group Size Test): " +
-                shuffledGroups);
+        System.out.println("Shuffled Groups (Zero or Negative Group Size Test): "
+                + shuffledGroups);
     }
 
     // Test case to check when the array has fewer than 3 elements
@@ -70,7 +72,8 @@ void testGroupShuffleSmallArray() {
         assertEquals(
                 Arrays.asList(1, 2),
                 shuffledGroups.get(0)); // The group should contain all elements
-        System.out.println("Shuffled Groups (Small Array Test): " + shuffledGroups);
+        System.out.println("Shuffled Groups (Small Array Test): "
+                + shuffledGroups);
     }
 
     // Test case to check the behavior when the group size is 1
@@ -85,7 +88,7 @@ void testGroupShuffleGroupSizeOne() {
                     Arrays.asList(i + 1),
                     shuffledGroups.get(i)); // Each group should contain one element
         }
-        System.out.println("Shuffled Groups (Group Size One Test): " +
-                shuffledGroups);
+        System.out.println("Shuffled Groups (Group Size One Test): "
+                + shuffledGroups);
     }
-}
+}

src/test/java/com/thealgorithms/shufflealgorithm/ShuffleByRangeTest.java

@@ -1,9 +1,9 @@
 package com.thealgorithms.shufflealgorithm;
 
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
 
 import com.thealgorithms.shufflealogrithm.ShuffleByRange;
-import org.junit.jupiter.api.Test;
 
 public class ShuffleByRangeTest {
 
@@ -14,56 +14,56 @@ void testShuffleByRangeBasic() {
         ShuffleByRange.shuffleByRange(array, 1, 5);
 
         // Verify that elements outside the specified range remain unchanged
-        assertEquals(1, array[0], "First element should be unchanged");
-        assertEquals(6, array[5], "Last element should be unchanged");
+        Assertions.assertEquals(1, array[0], "First element should be unchanged");
+        Assertions.assertEquals(6, array[5], "Last element should be unchanged");
     }
 
     // Test case for an empty array
     @Test
     void testShuffleByRangeEmptyArray() {
         int[] array = {};
         ShuffleByRange.shuffleByRange(array, 0, 1);
-        assertArrayEquals(new int[] {}, array);
+        Assertions.assertArrayEquals(new int[] {}, array);
     }
 
     // Test case for a single element array
     @Test
     void testShuffleByRangeSingleElementArray() {
         int[] array = {1};
         ShuffleByRange.shuffleByRange(array, 0, 1);
-        assertArrayEquals(new int[] {1}, array);
+        Assertions.assertArrayEquals(new int[] {1}, array);
     }
 
     // Test case for invalid range: start index equal to end index
     @Test
     void testShuffleByRangeStartEqualsEnd() {
         int[] array = {1, 2, 3, 4, 5};
         ShuffleByRange.shuffleByRange(array, 2, 2);
-        assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
+        Assertions.assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
     }
 
     // Test case for invalid range: start index out of bounds
     @Test
     void testShuffleByRangeStartOutOfBounds() {
         int[] array = {1, 2, 3, 4, 5};
         ShuffleByRange.shuffleByRange(array, -1, 5);
-        assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
+        Assertions.assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
     }
 
     // Test case for invalid range: end index out of bounds
     @Test
     void testShuffleByRangeEndOutOfBounds() {
         int[] array = {1, 2, 3, 4, 5};
         ShuffleByRange.shuffleByRange(array, 1, 6);
-        assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
+        Assertions.assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
     }
 
     // Test case for invalid range: start index greater than end index
     @Test
     void testShuffleByRangeStartGreaterThanEnd() {
         int[] array = {1, 2, 3, 4, 5};
         ShuffleByRange.shuffleByRange(array, 3, 2);
-        assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
+        Assertions.assertArrayEquals(new int[] {1, 2, 3, 4, 5}, array);
     }
 
     // Test case for shuffling a large array
@@ -77,12 +77,12 @@ void testShuffleByRangeLargeArray() {
 
         // Verify that the first 250 and last 250 elements remain unchanged
         for (int i = 0; i < 250; i++) {
-            assertEquals(i + 1, array[i],
+            Assertions.assertEquals(i + 1, array[i],
                     "Elements at index " + i + " should be unchanged");
         }
         for (int i = 750; i < 1000; i++) {
-            assertEquals(i + 1, array[i],
+            Assertions.assertEquals(i + 1, array[i],
                     "Elements at index " + i + " should be unchanged");
         }
     }
-}
+}

src/test/java/com/thealgorithms/shufflealgorithm/UniquePairShuffleTest.java

@@ -61,7 +61,7 @@ void testPairShuffleSingleElementArray() {
         assertTrue(pairs.isEmpty());
     }
 
-    // Test case for two elements
+    // Test case for two elements, adjusted to not expect a specific order
     @Test
     void testPairShuffleTwoElements() {
         int[] array = {1, 2};
@@ -71,8 +71,15 @@ void testPairShuffleTwoElements() {
         assertEquals(1, pairs.size());
         int[] pair = pairs.get(0);
 
-        // Check that the pair contains both elements, regardless of order
+        // Check that the pair contains both elements, without specifying order
         assertTrue((pair[0] == 1 && pair[1] == 2) || (pair[0] == 2 && pair[1] == 1));
+
+        // Alternatively, for clarity and to directly address the error,
+        // you could assert the pair's elements without considering order:
+        int min = Math.min(pair[0], pair[1]);
+        int max = Math.max(pair[0], pair[1]);
+        assertEquals(1, min, "First element of the pair should be 1 when ordered");
+        assertEquals(2, max, "Second element of the pair should be 2 when ordered");
     }
 
     // Test case for larger even-length array