Adding class for generating all subsequences from a given List

Author: alxkm

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

@@ -0,0 +1,50 @@
+package com.thealgorithms.backtracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class generates all subsequences for a given list of elements using backtracking
+ */
+public class Subsequence {
+    /**
+     * Find all subsequences of given list using backtracking
+     *
+     * @param sequence a list of items on the basis of which we need to generate all subsequences
+     * @param <T> the type of elements in the array
+     * @return a list of all subsequences
+     */
+    public static <T> List<List<T>> generateAllSubsequences(List<T> sequence) {
+        List<List<T>> allSubSequences = new ArrayList<>();
+        if (sequence.isEmpty()) {
+            allSubSequences.add(new ArrayList<>());
+            return allSubSequences;
+        }
+        List<T> currentSubsequence = new ArrayList<>();
+        backtrack(sequence, currentSubsequence, 0, allSubSequences);
+        return allSubSequences;
+    }
+
+    /**
+     * Iterate through each branch of states
+     * We know that each state has exactly two branching
+     * It terminates when it reaches the end of the given sequence
+     *
+     * @param sequence all elements
+     * @param currentSubsequence current subsequence
+     * @param index current index
+     * @param allSubSequences contains all sequences
+     * @param <T> the type of elements which we generate
+     */
+    private static <T> void backtrack(List<T> sequence, List<T> currentSubsequence, int index, List<List<T>> allSubSequences) {
+        if (index == sequence.size()) {
+            allSubSequences.add(new ArrayList<>(currentSubsequence));
+            return;
+        }
+
+        backtrack(sequence, currentSubsequence, index + 1, allSubSequences);
+        currentSubsequence.add(sequence.get(index));
+        backtrack(sequence, currentSubsequence, index + 1, allSubSequences);
+        currentSubsequence.removeLast();
+    }
+}

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

@@ -0,0 +1,62 @@
+package com.thealgorithms.backtracking;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+
+public class SubsequenceTest {
+
+    @Test
+    void testNoElement() {
+        List<List<Object>> emptyResult = Subsequence.generateAllSubsequences(new ArrayList<>());
+        assertEquals(1, emptyResult.size());
+        assertEquals(0, emptyResult.get(0).size());
+    }
+
+    @Test
+    void testLengthOfTwo() {
+        List<List<Integer>> expected = List.of(
+                List.of(),
+                List.of(2),
+                List.of(1),
+                List.of(1, 2)
+        );
+        List<List<Object>> actual = Subsequence.generateAllSubsequences(List.of(1, 2));
+        assertIterableEquals(expected, actual);
+    }
+
+    @Test
+    void testLengthOfThree() {
+        List<List<String>> expected = List.of(
+                List.of(),
+                List.of("C"),
+                List.of("B"),
+                List.of("B", "C"),
+                List.of("A"),
+                List.of("A", "C"),
+                List.of("A", "B"),
+                List.of("A", "B", "C")
+        );
+        List<List<Object>> actual = Subsequence.generateAllSubsequences(List.of("A", "B", "C"));
+        assertIterableEquals(expected, actual);
+    }
+
+    @Test
+    void testLengthOfThreeInteger() {
+        List<List<Integer>> expected = List.of(
+                List.of(),
+                List.of(3),
+                List.of(2),
+                List.of(2, 3),
+                List.of(1),
+                List.of(1, 3),
+                List.of(1, 2),
+                List.of(1, 2, 3)
+        );
+        List<List<Object>> actual = Subsequence.generateAllSubsequences(List.of(1, 2, 3));
+        assertIterableEquals(expected, actual);
+    }
+}