Refactor PowerSet: return lists, add overflow guard, add tests

Replace print-based void methods with generic List-returning methods.
Use incremental backtracking list instead of boolean[] used array.
Add overflow guard for n > 30 in the binary method. Update README
complexity from O(2^n) to O(n · 2^n). Add 9 JUnit 5 tests.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: williamfiset

README.md

@@ -258,7 +258,7 @@ $ java -cp classes com.williamfiset.algorithms.search.BinarySearch
 
 - [Bit manipulations](src/main/java/com/williamfiset/algorithms/other/BitManipulations.java) **- O(1)**
 - [List permutations](src/main/java/com/williamfiset/algorithms/other/Permutations.java) **- O(n!)**
-- [:movie_camera:](https://www.youtube.com/watch?v=RnlHPR0lyOE) [Power set (set of all subsets)](src/main/java/com/williamfiset/algorithms/other/PowerSet.java) **- O(2<sup>n</sup>)**
+- [:movie_camera:](https://www.youtube.com/watch?v=RnlHPR0lyOE) [Power set (set of all subsets)](src/main/java/com/williamfiset/algorithms/other/PowerSet.java) **- O(n · 2<sup>n</sup>)**
 - [Set combinations](src/main/java/com/williamfiset/algorithms/other/Combinations.java) **- O(n choose r)**
 - [Set combinations with repetition](src/main/java/com/williamfiset/algorithms/other/CombinationsWithRepetition.java) **- O((n+r-1) choose r)**
 - [Sliding Window Minimum/Maximum](src/main/java/com/williamfiset/algorithms/other/SlidingWindowMaximum.java) **- O(1)**

src/main/java/com/williamfiset/algorithms/other/BUILD

@@ -35,13 +35,6 @@ java_binary(
     runtime_deps = [":other"],
 )
 
-# bazel run //src/main/java/com/williamfiset/algorithms/other:PowerSet
-java_binary(
-    name = "PowerSet",
-    main_class = "com.williamfiset.algorithms.other.PowerSet",
-    runtime_deps = [":other"],
-)
-
 # bazel run //src/main/java/com/williamfiset/algorithms/other:SquareRootDecomposition
 java_binary(
     name = "SquareRootDecomposition",

src/main/java/com/williamfiset/algorithms/other/PowerSet.java

@@ -1,84 +1,63 @@
 /**
- * This code snippet shows how to generate the powerset of a set which is the set of all subsets of
- * a set. There are two common ways of doing this which are to use the binary representation of
- * numbers on a computer or to do it recursively. Both methods are shown here, pick your flavor!
+ * Generates the power set of a set, which is the set of all subsets.
  *
- * <p>Time Complexity: O( 2^n )
+ * Two approaches are provided: an iterative method using binary representation of numbers, and a
+ * recursive backtracking method. Both produce the same result.
+ *
+ * Time Complexity: O(n * 2^n)
  *
  * @author William Fiset, william.alexandre.fiset@gmail.com
  */
 package com.williamfiset.algorithms.other;
 
-public class PowerSet {
-
-  // Use the fact that numbers represented in binary can be
-  // used to generate all the subsets of an array
-  static void powerSetUsingBinary(int[] set) {
+import java.util.*;
 
-    final int N = set.length;
-    final int MAX_VAL = 1 << N;
+public class PowerSet {
 
-    for (int subset = 0; subset < MAX_VAL; subset++) {
-      System.out.print("{ ");
-      for (int i = 0; i < N; i++) {
-        int mask = 1 << i;
-        if ((subset & mask) == mask) System.out.print(set[i] + " ");
+  /**
+   * Generates the power set using binary representation. Each integer from 0 to 2^n - 1 represents
+   * a subset, where bit i indicates whether element i is included.
+   */
+  public static <T> List<List<T>> powerSetBinary(List<T> set) {
+    int n = set.size();
+    if (n > 30)
+      throw new IllegalArgumentException("Set too large: n=" + n + " (max 30)");
+    int total = 1 << n;
+    List<List<T>> result = new ArrayList<>(total);
+
+    for (int mask = 0; mask < total; mask++) {
+      List<T> subset = new ArrayList<>();
+      for (int i = 0; i < n; i++) {
+        if ((mask & (1 << i)) != 0)
+          subset.add(set.get(i));
       }
-      System.out.println("}");
+      result.add(subset);
     }
+    return result;
   }
 
-  // Recursively generate the powerset (set of all subsets) of an array by maintaining
-  // a boolean array used to indicate which element have been selected
-  static void powerSetRecursive(int at, int[] set, boolean[] used) {
-
-    if (at == set.length) {
-
-      // Print found subset!
-      System.out.print("{ ");
-      for (int i = 0; i < set.length; i++) if (used[i]) System.out.print(set[i] + " ");
-      System.out.println("}");
-
-    } else {
-
-      // Include this element
-      used[at] = true;
-      powerSetRecursive(at + 1, set, used);
-
-      // Backtrack and don't include this element
-      used[at] = false;
-      powerSetRecursive(at + 1, set, used);
-    }
+  /**
+   * Generates the power set using recursive backtracking. At each element, branches into including
+   * or excluding it.
+   */
+  public static <T> List<List<T>> powerSetRecursive(List<T> set) {
+    List<List<T>> result = new ArrayList<>();
+    recurse(0, set, new ArrayList<>(), result);
+    return result;
   }
 
-  public static void main(String[] args) {
-
-    // Example usage:
-    int[] set = {1, 2, 3};
-
-    powerSetUsingBinary(set);
-    // prints:
-    // { }
-    // { 1 }
-    // { 2 }
-    // { 1 2 }
-    // { 3 }
-    // { 1 3 }
-    // { 2 3 }
-    // { 1 2 3 }
-
-    System.out.println();
-
-    powerSetRecursive(0, set, new boolean[set.length]);
-    // prints:
-    // { 1 2 3 }
-    // { 1 2 }
-    // { 1 3 }
-    // { 1 }
-    // { 2 3 }
-    // { 2 }
-    // { 3 }
-    // { }
+  private static <T> void recurse(int at, List<T> set, List<T> current, List<List<T>> result) {
+    if (at == set.size()) {
+      // Snapshot the current subset — must copy since 'current' is mutated during backtracking
+      result.add(new ArrayList<>(current));
+      return;
+    }
+    // Include set[at] and explore all subsets of the remaining elements
+    current.add(set.get(at));
+    recurse(at + 1, set, current, result);
 
+    // Backtrack: undo the inclusion of set[at], then explore without it
+    current.remove(current.size() - 1);
+    recurse(at + 1, set, current, result);
   }
 }

src/test/java/com/williamfiset/algorithms/other/BUILD

@@ -46,3 +46,14 @@ java_test(
     runtime_deps = JUNIT5_RUNTIME_DEPS,
     deps = TEST_DEPS,
 )
+
+# bazel test //src/test/java/com/williamfiset/algorithms/other:PowerSetTest
+java_test(
+    name = "PowerSetTest",
+    srcs = ["PowerSetTest.java"],
+    main_class = "org.junit.platform.console.ConsoleLauncher",
+    use_testrunner = False,
+    args = ["--select-class=com.williamfiset.algorithms.other.PowerSetTest"],
+    runtime_deps = JUNIT5_RUNTIME_DEPS,
+    deps = TEST_DEPS,
+)

src/test/java/com/williamfiset/algorithms/other/PowerSetTest.java

@@ -0,0 +1,88 @@
+package com.williamfiset.algorithms.other;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.*;
+
+public class PowerSetTest {
+
+  /** Converts a power set to a set of sorted string representations for easy comparison. */
+  private static <T extends Comparable<T>> Set<String> normalize(List<List<T>> powerSet) {
+    return powerSet.stream()
+        .map(subset -> {
+          List<T> sorted = new ArrayList<>(subset);
+          Collections.sort(sorted);
+          return sorted.toString();
+        })
+        .collect(Collectors.toSet());
+  }
+
+  @Test
+  public void emptySet_binary() {
+    List<List<Integer>> result = PowerSet.powerSetBinary(List.of());
+    assertThat(result).hasSize(1);
+    assertThat(result.get(0)).isEmpty();
+  }
+
+  @Test
+  public void emptySet_recursive() {
+    List<List<Integer>> result = PowerSet.powerSetRecursive(List.of());
+    assertThat(result).hasSize(1);
+    assertThat(result.get(0)).isEmpty();
+  }
+
+  @Test
+  public void singleElement_binary() {
+    List<List<Integer>> result = PowerSet.powerSetBinary(List.of(42));
+    assertThat(normalize(result)).containsExactly("[]", "[42]");
+  }
+
+  @Test
+  public void singleElement_recursive() {
+    List<List<Integer>> result = PowerSet.powerSetRecursive(List.of(42));
+    assertThat(normalize(result)).containsExactly("[]", "[42]");
+  }
+
+  @Test
+  public void threeElements_binary() {
+    List<List<Integer>> result = PowerSet.powerSetBinary(List.of(1, 2, 3));
+    assertThat(result).hasSize(8);
+    assertThat(normalize(result))
+        .containsExactly("[]", "[1]", "[2]", "[3]", "[1, 2]", "[1, 3]", "[2, 3]", "[1, 2, 3]");
+  }
+
+  @Test
+  public void threeElements_recursive() {
+    List<List<Integer>> result = PowerSet.powerSetRecursive(List.of(1, 2, 3));
+    assertThat(result).hasSize(8);
+    assertThat(normalize(result))
+        .containsExactly("[]", "[1]", "[2]", "[3]", "[1, 2]", "[1, 3]", "[2, 3]", "[1, 2, 3]");
+  }
+
+  @Test
+  public void bothMethodsProduceSameSubsets() {
+    List<Integer> set = List.of(5, 10, 15, 20);
+    Set<String> binary = normalize(PowerSet.powerSetBinary(set));
+    Set<String> recursive = normalize(PowerSet.powerSetRecursive(set));
+    assertThat(binary).isEqualTo(recursive);
+  }
+
+  @Test
+  public void correctSize() {
+    for (int n = 0; n <= 5; n++) {
+      List<Integer> set = new ArrayList<>();
+      for (int i = 0; i < n; i++)
+        set.add(i);
+      assertThat(PowerSet.powerSetBinary(set)).hasSize(1 << n);
+      assertThat(PowerSet.powerSetRecursive(set)).hasSize(1 << n);
+    }
+  }
+
+  @Test
+  public void worksWithStrings() {
+    List<List<String>> result = PowerSet.powerSetBinary(List.of("a", "b"));
+    assertThat(normalize(result)).containsExactly("[]", "[a]", "[b]", "[a, b]");
+  }
+}