refactor: cleanup

Author: vil02

src/main/java/com/thealgorithms/backtracking/ArrayCombination.java

@@ -4,28 +4,26 @@
 import java.util.List;
 
 /**
- * Finds all permutations of 1...n of length k
- * @author TheClerici (<a href="https://github.com/TheClerici">git-TheClerici</a>)
+ * Finds all combinations of 0...n-1 of length k
  */
 public final class ArrayCombination {
     private ArrayCombination() {
     }
 
     /**
-     * Find all combinations of 1..n using backtracking.
+     * Finds all combinations of length k of 0..n-1 using backtracking.
      *
-     * @param n Max value of the elements.
+     * @param n Number of the elements.
      * @param k Length of the combination.
      * @return A list of all combinations of length k.
-     *         Returns an empty list if k is 0 or n is less than k.
      */
     public static List<List<Integer>> combination(int n, int k) {
-        if (k <= 0 || n < k) {
-            return new ArrayList<>(); // Return empty list for invalid input
+        if (n < 0 || k < 0 || k > n) {
+            throw new IllegalArgumentException("Wrong input.");
         }
 
         List<List<Integer>> combinations = new ArrayList<>();
-        combine(combinations, new ArrayList<>(), 1, n, k);
+        combine(combinations, new ArrayList<>(), 0, n, k);
         return combinations;
     }
 
@@ -35,10 +33,10 @@ private static void combine(List<List<Integer>> combinations, List<Integer> curr
             return;
         }
 
-        for (int i = start; i <= n; i++) {
+        for (int i = start; i < n; i++) {
             current.add(i);
-            combine(combinations, current, i + 1, n, k); // Recursive call
-            current.remove(current.size() - 1); // Backtrack
+            combine(combinations, current, i + 1, n, k);
+            current.removeLast(); // Backtrack
         }
     }
 }

src/test/java/com/thealgorithms/backtracking/ArrayCombinationTest.java

@@ -1,48 +1,36 @@
 package com.thealgorithms.backtracking;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import com.thealgorithms.maths.BinomialCoefficient;
 import java.util.ArrayList;
 import java.util.List;
-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 ArrayCombinationTest {
-
-    @Test
-    public void testCombination() {
-        // Test case 1: n = 4, k = 2
-        List<List<Integer>> expected = new ArrayList<>();
-        expected.add(List.of(1, 2));
-        expected.add(List.of(1, 3));
-        expected.add(List.of(1, 4));
-        expected.add(List.of(2, 3));
-        expected.add(List.of(2, 4));
-        expected.add(List.of(3, 4));
-
-        List<List<Integer>> actual = ArrayCombination.combination(4, 2);
-
-        assertEquals(expected, actual);
+    @ParameterizedTest
+    @MethodSource("regularInputs")
+    void testCombination(int n, int k, List<List<Integer>> expected) {
+        assertEquals(expected.size(), BinomialCoefficient.binomialCoefficient(n, k));
+        assertEquals(expected, ArrayCombination.combination(n, k));
     }
 
-    @Test
-    public void testEmptyCombination() {
-        // Test case 2: n = 4, k = 0 (invalid input)
-        List<List<Integer>> expected = new ArrayList<>();
-        List<List<Integer>> actual = ArrayCombination.combination(4, 0);
-
-        assertEquals(expected, actual);
+    @ParameterizedTest
+    @MethodSource("wrongInputs")
+    void testCombinationThrows(int n, int k) {
+        assertThrows(IllegalArgumentException.class, () -> ArrayCombination.combination(n, k));
     }
 
-    @Test
-    public void testSingleElementCombinations() {
-        // Test case 3: n = 3, k = 1
-        List<List<Integer>> expected = new ArrayList<>();
-        expected.add(List.of(1));
-        expected.add(List.of(2));
-        expected.add(List.of(3));
-
-        List<List<Integer>> actual = ArrayCombination.combination(3, 1);
+    private static Stream<Arguments> regularInputs() {
+        return Stream.of(Arguments.of(0, 0, List.of(new ArrayList<Integer>())), Arguments.of(1, 0, List.of(new ArrayList<Integer>())), Arguments.of(1, 1, List.of(List.of(0))), Arguments.of(3, 0, List.of(new ArrayList<Integer>())), Arguments.of(3, 1, List.of(List.of(0), List.of(1), List.of(2))),
+            Arguments.of(4, 2, List.of(List.of(0, 1), List.of(0, 2), List.of(0, 3), List.of(1, 2), List.of(1, 3), List.of(2, 3))));
+    }
 
-        assertEquals(expected, actual);
+    private static Stream<Arguments> wrongInputs() {
+        return Stream.of(Arguments.of(-1, 0), Arguments.of(0, -1), Arguments.of(2, 100));
     }
 }