refactor: cleanup BeadSort (#5269)

* cleanup: BeadSort and BeadSortTest, adding javadocs

* checkstyle: fix formatting

* checkstyle: fix import order

* cleanup: improving code readability

* cleanup: improving code readability using enum to represent beads

* checkstyle: fix enum formatting

* fix: enum should be compared using ==, according to maven bugs finder plugin

---------

Co-authored-by: Alex Klymenko <alx@alx.com>
Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>

src/main/java/com/thealgorithms/sorts/BeadSort.java

@@ -1,40 +1,59 @@
 package com.thealgorithms.sorts;
 
-// BeadSort Algorithm(wikipedia) : https://en.wikipedia.org/wiki/Bead_sort
-// BeadSort can't sort negative number, Character, String. It can sort positive number only
+import java.util.Arrays;
 
 public class BeadSort {
-    public int[] sort(int[] unsorted) {
-        int[] sorted = new int[unsorted.length];
-        int max = 0;
-        for (int i = 0; i < unsorted.length; i++) {
-            max = Math.max(max, unsorted[i]);
+    private enum BeadState { BEAD, EMPTY }
+
+    /**
+     * Sorts the given array using the BeadSort algorithm.
+     *
+     * @param array The array of non-negative integers to be sorted.
+     * @return The sorted array.
+     * @throws IllegalArgumentException If the array contains negative numbers.
+     */
+    public int[] sort(int[] array) {
+        allInputsMustBeNonNegative(array);
+        return extractSortedFromGrid(fillGrid(array));
+    }
+
+    private void allInputsMustBeNonNegative(final int[] array) {
+        if (Arrays.stream(array).anyMatch(s -> s < 0)) {
+            throw new IllegalArgumentException("BeadSort cannot sort negative numbers.");
         }
+    }
 
-        char[][] grid = new char[unsorted.length][max];
-        int[] count = new int[max];
+    private BeadState[][] fillGrid(final int[] array) {
+        final var maxValue = Arrays.stream(array).max().orElse(0);
+        var grid = getEmptyGrid(array.length, maxValue);
 
-        for (int i = 0; i < unsorted.length; i++) {
-            for (int j = 0; j < max; j++) {
-                grid[i][j] = '-';
-            }
-        }
-
-        for (int i = 0; i < max; i++) {
-            count[i] = 0;
-        }
-
-        for (int i = 0; i < unsorted.length; i++) {
+        int[] count = new int[maxValue];
+        for (int i = 0, arrayLength = array.length; i < arrayLength; i++) {
             int k = 0;
-            for (int j = 0; j < unsorted[i]; j++) {
-                grid[count[max - k - 1]++][k] = '*';
+            for (int j = 0; j < array[i]; j++) {
+                grid[count[maxValue - k - 1]++][k] = BeadState.BEAD;
                 k++;
             }
         }
+        return grid;
+    }
 
-        for (int i = 0; i < unsorted.length; i++) {
+    private BeadState[][] getEmptyGrid(final int arrayLength, final int maxValue) {
+        BeadState[][] grid = new BeadState[arrayLength][maxValue];
+        for (int i = 0; i < arrayLength; i++) {
+            for (int j = 0; j < maxValue; j++) {
+                grid[i][j] = BeadState.EMPTY;
+            }
+        }
+
+        return grid;
+    }
+
+    private int[] extractSortedFromGrid(final BeadState[][] grid) {
+        int[] sorted = new int[grid.length];
+        for (int i = 0; i < grid.length; i++) {
             int k = 0;
-            for (int j = 0; j < max && grid[unsorted.length - 1 - i][j] == '*'; j++) {
+            for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j] == BeadState.BEAD; j++) {
                 k++;
             }
             sorted[i] = k;

src/test/java/com/thealgorithms/sorts/BeadSortTest.java

@@ -1,42 +1,29 @@
 package com.thealgorithms.sorts;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 public class BeadSortTest {
-    // BeadSort can't sort negative number, Character, String. It can sort positive number only
-    private BeadSort beadSort = new BeadSort();
+    @ParameterizedTest
+    @MethodSource("provideArraysForBeadSort")
+    public void testBeadSort(int[] inputArray, int[] expectedArray) {
+        BeadSort beadSort = new BeadSort();
+        assertArrayEquals(expectedArray, beadSort.sort(inputArray));
+    }
 
-    @Test
-    public void beadSortEmptyArray() {
-        int[] inputArray = {};
-        int[] outputArray = beadSort.sort(inputArray);
-        int[] expectedOutput = {};
-        assertArrayEquals(outputArray, expectedOutput);
+    private static Stream<Arguments> provideArraysForBeadSort() {
+        return Stream.of(Arguments.of(new int[] {}, new int[] {}), Arguments.of(new int[] {4}, new int[] {4}), Arguments.of(new int[] {6, 1, 99, 27, 15, 23, 36}, new int[] {1, 6, 15, 23, 27, 36, 99}), Arguments.of(new int[] {6, 1, 27, 15, 23, 27, 36, 23}, new int[] {1, 6, 15, 23, 23, 27, 27, 36}),
+            Arguments.of(new int[] {5, 5, 5, 5, 5}, new int[] {5, 5, 5, 5, 5}), Arguments.of(new int[] {1, 2, 3, 4, 5}, new int[] {1, 2, 3, 4, 5}), Arguments.of(new int[] {5, 4, 3, 2, 1}, new int[] {1, 2, 3, 4, 5}));
     }
 
     @Test
-    public void beadSortSingleIntegerArray() {
-        int[] inputArray = {4};
-        int[] outputArray = beadSort.sort(inputArray);
-        int[] expectedOutput = {4};
-        assertArrayEquals(outputArray, expectedOutput);
-    }
-
-    @Test
-    public void bogoSortNonDuplicateIntegerArray() {
-        int[] inputArray = {6, 1, 99, 27, 15, 23, 36};
-        int[] outputArray = beadSort.sort(inputArray);
-        int[] expectedOutput = {1, 6, 15, 23, 27, 36, 99};
-        assertArrayEquals(outputArray, expectedOutput);
-    }
-
-    @Test
-    public void bogoSortDuplicateIntegerArray() {
-        int[] inputArray = {6, 1, 27, 15, 23, 27, 36, 23};
-        int[] outputArray = beadSort.sort(inputArray);
-        int[] expectedOutput = {1, 6, 15, 23, 23, 27, 27, 36};
-        assertArrayEquals(outputArray, expectedOutput);
+    public void testWithNegativeNumbers() {
+        assertThrows(IllegalArgumentException.class, () -> new BeadSort().sort(new int[] {3, 1, 4, 1, 5, -9}));
     }
 }