Related to TheAlgorithms#5164 (Redesign of ArrayCombination)

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

@@ -1,5 +1,6 @@
 package com.thealgorithms.backtracking;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.TreeSet;
 
@@ -8,25 +9,37 @@
  * @author TheClerici (<a href="https://github.com/TheClerici">git-TheClerici</a>)
  */
 public final class ArrayCombination {
-    private ArrayCombination() {
+      private ArrayCombination() {
     }
-    private static int length;
 
     /**
-     * Find all combinations of 1..n by creating an array and using backtracking in Combination.java
-     * @param n max value of the array.
-     * @param k length of combination
-     * @return a list of all combinations of length k. If k == 0, return null.
+     * Find all combinations of 1..n using backtracking.
+     *
+     * @param n Max value 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<TreeSet<Integer>> combination(int n, int k) {
-        if (n <= 0) {
-            return null;
+    public static List<List<Integer>> combination(int n, int k) {
+        if (k <= 0 || n < k) {
+            return new ArrayList<>(); // Return empty list for invalid input
         }
-        length = k;
-        Integer[] arr = new Integer[n];
-        for (int i = 1; i <= n; i++) {
-            arr[i - 1] = i;
+
+        List<List<Integer>> combinations = new ArrayList<>();
+        combine(combinations, new ArrayList<>(), 1, n, k);
+        return combinations;
+    }
+
+    private static void combine(List<List<Integer>> combinations, List<Integer> current, int start, int n, int k) {
+        if (current.size() == k) {  // Base case: combination found
+            combinations.add(new ArrayList<>(current)); // Copy to avoid modification
+            return;
+        }
+
+        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
         }
-        return Combination.combination(arr, length);
     }
 }

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

@@ -1,51 +1,49 @@
 package com.thealgorithms.backtracking;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
 
+import java.util.ArrayList;
 import java.util.List;
-import java.util.TreeSet;
-import org.junit.jupiter.api.Test;
+
+import org.junit.jupiter.api.Test; 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ArrayCombinationTest {
 
     @Test
-    void testNBeingZeroOrLess() {
-        List<TreeSet<Integer>> zeroResult = ArrayCombination.combination(0, 1);
-        List<TreeSet<Integer>> negativeResult = ArrayCombination.combination(-1, 1);
-        assertNull(zeroResult);
-        assertNull(negativeResult);
+    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);
     }
 
     @Test
-    void testNoLengthElement() {
-        List<TreeSet<Integer>> result = ArrayCombination.combination(2, 0);
-        assertNull(result);
-    }
+    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);
 
-    @Test
-    void testLengthOne() {
-        List<TreeSet<Integer>> result = ArrayCombination.combination(2, 1);
-        assert result != null;
-        assertEquals(1, result.get(0).iterator().next());
-        assertEquals(2, result.get(1).iterator().next());
+        assertEquals(expected, actual);
     }
 
     @Test
-    void testLengthTwo() {
-        List<TreeSet<Integer>> result = ArrayCombination.combination(2, 2);
-        assert result != null;
-        Integer[] arr = result.get(0).toArray(new Integer[2]);
-        assertEquals(1, arr[0]);
-        assertEquals(2, arr[1]);
-    }
+    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));
 
-    @Test
-    void testLengthFive() {
-        List<TreeSet<Integer>> result = ArrayCombination.combination(10, 5);
-        assert result != null;
-        Integer[] arr = result.get(0).toArray(new Integer[5]);
-        assertEquals(1, arr[0]);
-        assertEquals(5, arr[4]);
+        List<List<Integer>> actual = ArrayCombination.combination(3, 1);
+
+        assertEquals(expected, actual);
     }
-}
+}