GFG App
Open App
Browser
Continue

# Power Set

Power Set: Power set P(S) of a set S is the set of all subsets of S. For example S = {a, b, c} then P(s) = {{}, {a}, {b}, {c}, {a,b}, {a, c}, {b, c}, {a, b, c}}.
If S has n elements in it then P(s) will have 2n elements

Example:

Set  = [a,b,c]
power_set_size = pow(2, 3) = 8
Run for binary counter = 000 to 111

Value of Counter            Subset
000                    -> Empty set
001                    -> a
010                    -> b
011                    -> ab
100                    -> c
101                    -> ac
110                    -> bc
111                    -> abc

Recommended Practice

Algorithm:

Input: Set[], set_size
1. Get the size of power set
powet_set_size = pow(2, set_size)
2  Loop for counter from 0 to pow_set_size
(a) Loop for i = 0 to set_size
(i) If ith bit in counter is set
Print ith element from set for this subset
(b) Print separator for subsets i.e., newline

Method 1:
For a given set[] S, the power set can be found by generating all binary numbers between 0 and 2n-1, where n is the size of the set.
For example, for the set S {x, y, z}, generate all binary numbers from 0 to 23-1 and for each generated number, the corresponding set can be found by considering set bits in the number.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to print all the power set` `void` `printPowerSet(``char``* set, ``int` `set_size)` `{` `    ``// Set_size of power set of a set with set_size` `    ``// n is (2^n-1)` `    ``unsigned ``int` `pow_set_size = ``pow``(2, set_size);` `    ``int` `counter, j;`   `    ``// Run from counter 000..0 to 111..1` `    ``for` `(counter = 0; counter < pow_set_size; counter++) {` `        ``for` `(j = 0; j < set_size; j++) {` `            ``// Check if jth bit in the counter is set` `            ``// If set then print jth element from set` `            ``if` `(counter & (1 << j))` `                ``cout << set[j];` `        ``}` `        ``cout << endl;` `    ``}` `}`   `/*Driver code*/` `int` `main()` `{` `    ``char` `set[] = { ``'a'``, ``'b'``, ``'c'` `};` `    ``printPowerSet(set, 3);` `    ``return` `0;` `}`   `// This code is contributed by SoM15242`

## C

 `#include ` `#include `   `void` `printPowerSet(``char` `*set, ``int` `set_size)` `{` `    ``/*set_size of power set of a set with set_size` `      ``n is (2**n -1)*/` `    ``unsigned ``int` `pow_set_size = ``pow``(2, set_size);` `    ``int` `counter, j;`   `    ``/*Run from counter 000..0 to 111..1*/` `    ``for``(counter = 0; counter < pow_set_size; counter++)` `    ``{` `      ``for``(j = 0; j < set_size; j++)` `       ``{` `          ``/* Check if jth bit in the counter is set` `             ``If set then print jth element from set */` `          ``if``(counter & (1<

## Java

 `// Java program for power set` `import` `java .io.*;`   `public` `class` `GFG {` `    `  `    ``static` `void` `printPowerSet(``char` `[]set,` `                            ``int` `set_size)` `    ``{` `        `  `        ``/*set_size of power set of a set` `        ``with set_size n is (2**n -1)*/` `        ``long` `pow_set_size = ` `            ``(``long``)Math.pow(``2``, set_size);` `        ``int` `counter, j;` `    `  `        ``/*Run from counter 000..0 to` `        ``111..1*/` `        ``for``(counter = ``0``; counter < ` `                ``pow_set_size; counter++)` `        ``{` `            ``for``(j = ``0``; j < set_size; j++)` `            ``{` `                ``/* Check if jth bit in the ` `                ``counter is set If set then ` `                ``print jth element from set */` `                ``if``((counter & (``1` `<< j)) > ``0``)` `                    ``System.out.print(set[j]);` `            ``}` `            `  `            ``System.out.println();` `        ``}` `    ``}` `    `  `    ``// Driver program to test printPowerSet` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``char` `[]set = {``'a'``, ``'b'``, ``'c'``};` `        ``printPowerSet(set, ``3``);` `    ``}` `}`   `// This code is contributed by anuj_67.`

## Python3

 `# python3 program for power set`   `import` `math;`   `def` `printPowerSet(``set``,set_size):` `    `  `    ``# set_size of power set of a set` `    ``# with set_size n is (2**n -1)` `    ``pow_set_size ``=` `(``int``) (math.``pow``(``2``, set_size));` `    ``counter ``=` `0``;` `    ``j ``=` `0``;` `    `  `    ``# Run from counter 000..0 to 111..1` `    ``for` `counter ``in` `range``(``0``, pow_set_size):` `        ``for` `j ``in` `range``(``0``, set_size):` `            `  `            ``# Check if jth bit in the ` `            ``# counter is set If set then ` `            ``# print jth element from set ` `            ``if``((counter & (``1` `<< j)) > ``0``):` `                ``print``(``set``[j], end ``=` `"");` `        ``print``("");`   `# Driver program to test printPowerSet` `set` `=` `[``'a'``, ``'b'``, ``'c'``];` `printPowerSet(``set``, ``3``);`   `# This code is contributed by mits.`

## C#

 `// C# program for power set` `using` `System;`   `class` `GFG {` `    `  `    ``static` `void` `printPowerSet(``char` `[]``set``,` `                            ``int` `set_size)` `    ``{` `        ``/*set_size of power set of a set` `        ``with set_size n is (2**n -1)*/` `        ``uint` `pow_set_size = ` `              ``(``uint``)Math.Pow(2, set_size);` `        ``int` `counter, j;` `    `  `        ``/*Run from counter 000..0 to` `        ``111..1*/` `        ``for``(counter = 0; counter < ` `                   ``pow_set_size; counter++)` `        ``{` `            ``for``(j = 0; j < set_size; j++)` `            ``{` `                ``/* Check if jth bit in the ` `                ``counter is set If set then ` `                ``print jth element from set */` `                ``if``((counter & (1 << j)) > 0)` `                    ``Console.Write(``set``[j]);` `            ``}` `            `  `            ``Console.WriteLine();` `        ``}` `    ``}` `    `  `    ``// Driver program to test printPowerSet` `    ``public` `static` `void` `Main ()` `    ``{` `        ``char` `[]``set` `= {``'a'``, ``'b'``, ``'c'``};` `        ``printPowerSet(``set``, 3);` `    ``}` `}`   `// This code is contributed by anuj_67.`

## PHP

 ``

## Javascript

 ``

Output

```a
b
ab
c
ac
bc
abc```

Time Complexity: O(n2n)
Auxiliary Space: O(1)

Method 2: (sorted by cardinality)

In auxiliary array of bool set all elements to 0. That represent an empty set. Set first element of auxiliary array to 1 and generate all permutations to produce all subsets with one element. Then set the second element to 1 which will produce all subsets with two elements, repeat until all elements are included.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to print all the power set` `void` `printPowerSet(``char` `set[], ``int` `n)` `{` `    ``bool` `*contain = ``new` `bool``[n]{0};` `    `  `    ``// Empty subset` `    ``cout << ``""` `<< endl;` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``contain[i] = 1;` `        ``// All permutation` `        ``do` `        ``{` `            ``for``(``int` `j = 0; j < n; j++)` `                ``if``(contain[j])` `                    ``cout << set[j];` `            ``cout << endl;` `        ``} ``while``(prev_permutation(contain, contain + n));` `    ``}` `}`   `/*Driver code*/` `int` `main()` `{` `    ``char` `set[] = {``'a'``,``'b'``,``'c'``};` `    ``printPowerSet(set, 3);` `    ``return` `0;` `}`   `// This code is contributed by zlatkodamijanic`

## Java

 `// Java program for the above approach`   `import` `java.util.*;`   `class` `GFG` `{`   `  ``// A function to reverse only the indices in the` `  ``// range [l, r]` `  ``static` `int``[] reverse(``int``[] arr, ``int` `l, ``int` `r)` `  ``{` `    ``int` `d = (r - l + ``1``) / ``2``;` `    ``for` `(``int` `i = ``0``; i < d; i++) {` `      ``int` `t = arr[l + i];` `      ``arr[l + i] = arr[r - i];` `      ``arr[r - i] = t;` `    ``}` `    ``return` `arr;` `  ``}` `  ``// A function which gives previous` `  ``// permutation of the array` `  ``// and returns true if a permutation` `  ``// exists.` `  ``static` `boolean` `prev_permutation(``int``[] str)` `  ``{` `    ``// Find index of the last` `    ``// element of the string` `    ``int` `n = str.length - ``1``;`   `    ``// Find largest index i such` `    ``// that str[i - 1] > str[i]` `    ``int` `i = n;` `    ``while` `(i > ``0` `&& str[i - ``1``] <= str[i]) {` `      ``i--;` `    ``}`   `    ``// If string is sorted in` `    ``// ascending order we're` `    ``// at the last permutation` `    ``if` `(i <= ``0``) {` `      ``return` `false``;` `    ``}`   `    ``// Note - str[i..n] is sorted` `    ``// in ascending order Find` `    ``// rightmost element's index` `    ``// that is less than str[i - 1]` `    ``int` `j = i - ``1``;` `    ``while` `(j + ``1` `<= n && str[j + ``1``] < str[i - ``1``]) {` `      ``j++;` `    ``}`   `    ``// Swap character at i-1 with j` `    ``int` `temper = str[i - ``1``];` `    ``str[i - ``1``] = str[j];` `    ``str[j] = temper;`   `    ``// Reverse the substring [i..n]` `    ``str = reverse(str, i, str.length - ``1``);`   `    ``return` `true``;` `  ``}`   `  ``// Function to print all the power set` `  ``static` `void` `printPowerSet(``char``[] set, ``int` `n)` `  ``{`   `    ``int``[] contain = ``new` `int``[n];` `    ``for` `(``int` `i = ``0``; i < n; i++)` `      ``contain[i] = ``0``;`   `    ``// Empty subset` `    ``System.out.println();` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``contain[i] = ``1``;`   `      ``// To avoid changing original 'contain'` `      ``// array creating a copy of it i.e.` `      ``// "Contain"` `      ``int``[] Contain = ``new` `int``[n];` `      ``for` `(``int` `indx = ``0``; indx < n; indx++) {` `        ``Contain[indx] = contain[indx];` `      ``}`   `      ``// All permutation` `      ``do` `{` `        ``for` `(``int` `j = ``0``; j < n; j++) {` `          ``if` `(Contain[j] != ``0``) {` `            ``System.out.print(set[j]);` `          ``}` `        ``}` `        ``System.out.print(``"\n"``);`   `      ``} ``while` `(prev_permutation(Contain));` `    ``}` `  ``}`   `  ``/*Driver code*/` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``char``[] set = { ``'a'``, ``'b'``, ``'c'` `};` `    ``printPowerSet(set, ``3``);` `  ``}` `}`   `// This code is contributed by phasing17`

## Python3

 `# Python3 program for the above approach`   `# A function which gives previous` `# permutation of the array` `# and returns true if a permutation` `# exists.` `def` `prev_permutation(``str``):`   `    ``# Find index of the last` `    ``# element of the string` `    ``n ``=` `len``(``str``) ``-` `1`   `    ``# Find largest index i such` `    ``# that str[i - 1] > str[i]` `    ``i ``=` `n` `    ``while` `(i > ``0` `and` `str``[i ``-` `1``] <``=` `str``[i]):` `        ``i ``-``=` `1`   `    ``# If string is sorted in` `    ``# ascending order we're` `    ``# at the last permutation` `    ``if` `(i <``=` `0``):` `        ``return` `False`   `    ``# Note - str[i..n] is sorted` `    ``# in ascending order Find` `    ``# rightmost element's index` `    ``# that is less than str[i - 1]` `    ``j ``=` `i ``-` `1` `    ``while` `(j ``+` `1` `<``=` `n ``and` `str``[j ``+` `1``] < ``str``[i ``-` `1``]):` `        ``j ``+``=` `1`   `    ``# Swap character at i-1 with j` `    ``temper ``=` `str``[i ``-` `1``]` `    ``str``[i ``-` `1``] ``=` `str``[j]` `    ``str``[j] ``=` `temper`   `    ``# Reverse the substring [i..n]` `    ``size ``=` `n``-``i``+``1` `    ``for` `idx ``in` `range``(``int``(size ``/` `2``)):` `        ``temp ``=` `str``[idx ``+` `i]` `        ``str``[idx ``+` `i] ``=` `str``[n ``-` `idx]` `        ``str``[n ``-` `idx] ``=` `temp`   `    ``return` `True`   `# Function to print all the power set` `def` `printPowerSet(``set``, n):`   `    ``contain ``=` `[``0` `for` `_ ``in` `range``(n)]`   `    ``# Empty subset` `    ``print``()`   `    ``for` `i ``in` `range``(n):` `        ``contain[i] ``=` `1`   `        ``# To avoid changing original 'contain'` `        ``# array creating a copy of it i.e.` `        ``# "Contain"` `        ``Contain ``=` `contain.copy()`   `        ``# All permutation` `        ``while` `True``:` `            ``for` `j ``in` `range``(n):` `                ``if` `(Contain[j]):` `                    ``print``(``set``[j], end``=``"")` `            ``print``()` `            ``if` `not` `prev_permutation(Contain):` `                ``break`   `# Driver code` `set` `=` `[``'a'``, ``'b'``, ``'c'``]` `printPowerSet(``set``, ``3``)`   `# This code is contributed by phasing17`

## C#

 `// C# program for the above approach`   `using` `System;` `using` `System.Linq;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `  ``// A function which gives previous` `  ``// permutation of the array` `  ``// and returns true if a permutation` `  ``// exists.` `  ``static` `bool` `prev_permutation(``int``[] str)` `  ``{` `    ``// Find index of the last` `    ``// element of the string` `    ``int` `n = str.Length - 1;`   `    ``// Find largest index i such` `    ``// that str[i - 1] > str[i]` `    ``int` `i = n;` `    ``while` `(i > 0 && str[i - 1] <= str[i]) {` `      ``i--;` `    ``}`   `    ``// If string is sorted in` `    ``// ascending order we're` `    ``// at the last permutation` `    ``if` `(i <= 0) {` `      ``return` `false``;` `    ``}`   `    ``// Note - str[i..n] is sorted` `    ``// in ascending order Find` `    ``// rightmost element's index` `    ``// that is less than str[i - 1]` `    ``int` `j = i - 1;` `    ``while` `(j + 1 <= n && str[j + 1] < str[i - 1]) {` `      ``j++;` `    ``}`   `    ``// Swap character at i-1 with j` `    ``var` `temper = str[i - 1];` `    ``str[i - 1] = str[j];` `    ``str[j] = temper;`   `    ``// Reverse the substring [i..n]` `    ``int` `size = n - i + 1;` `    ``Array.Reverse(str, i, size);`   `    ``return` `true``;` `  ``}`   `  ``// Function to print all the power set` `  ``static` `void` `printPowerSet(``char``[] ``set``, ``int` `n)` `  ``{`   `    ``int``[] contain = ``new` `int``[n];` `    ``for` `(``int` `i = 0; i < n; i++)` `      ``contain[i] = 0;`   `    ``// Empty subset` `    ``Console.WriteLine();` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``contain[i] = 1;`   `      ``// To avoid changing original 'contain'` `      ``// array creating a copy of it i.e.` `      ``// "Contain"` `      ``int``[] Contain = ``new` `int``[n];` `      ``for` `(``int` `indx = 0; indx < n; indx++) {` `        ``Contain[indx] = contain[indx];` `      ``}`   `      ``// All permutation` `      ``do` `{` `        ``for` `(``int` `j = 0; j < n; j++) {` `          ``if` `(Contain[j] != 0) {` `            ``Console.Write(``set``[j]);` `          ``}` `        ``}` `        ``Console.Write(``"\n"``);`   `      ``} ``while` `(prev_permutation(Contain));` `    ``}` `  ``}`   `  ``/*Driver code*/` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``char``[] ``set` `= { ``'a'``, ``'b'``, ``'c'` `};` `    ``printPowerSet(``set``, 3);` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// JavaScript program for the above approach`   `// A function which gives previous ` `// permutation of the array` `// and returns true if a permutation ` `// exists. ` `function` `prev_permutation(str){    ` `    ``// Find index of the last` `    ``// element of the string` `    ``let n = str.length - 1;` ` `  `    ``// Find largest index i such` `    ``// that str[i - 1] > str[i]` `    ``let i = n;` `    ``while` `(i > 0 && str[i - 1] <= str[i]){` `        ``i--;` `    ``}   ` `      `  `    ``// If string is sorted in` `    ``// ascending order we're` `    ``// at the last permutation` `    ``if` `(i <= 0){` `        ``return` `false``;` `    ``}` ` `  `    ``// Note - str[i..n] is sorted` `    ``// in ascending order Find` `    ``// rightmost element's index` `    ``// that is less than str[i - 1]` `    ``let j = i - 1;` `    ``while` `(j + 1 <= n && str[j + 1] < str[i - 1]){` `        ``j++;` `    ``}` `    `  `    ``// Swap character at i-1 with j` `    ``const temper = str[i - 1];` `    ``str[i - 1] = str[j];` `    ``str[j] = temper;` `    `  `    ``// Reverse the substring [i..n]` `    ``let size = n-i+1;` `    ``for` `(let idx = 0; idx < Math.floor(size / 2); idx++) {` `        ``let temp = str[idx + i];` `        ``str[idx + i] = str[n - idx];` `        ``str[n - idx] = temp;` `    ``}` `    `  `    ``return` `true``;` `}`   `// Function to print all the power set` `function` `printPowerSet(set, n){   `   `    ``let contain = ``new` `Array(n).fill(0);`   `    ``// Empty subset` `    ``document.write(``"
"``);` `    ``for``(let i = 0; i < n; i++){` `        ``contain[i] = 1; ` `        `  `        ``// To avoid changing original 'contain' ` `        ``// array creating a copy of it i.e.` `        ``// "Contain"` `        ``let Contain = ``new` `Array(n);` `        ``for``(let indx = 0; indx < n; indx++){` `            ``Contain[indx] = contain[indx];` `        ``}`   `        ``// All permutation` `        ``do``{` `            ``for``(let j = 0; j < n; j++){                ` `                ``if``(Contain[j]){` `                    ``document.write(set[j]);` `                ``}  ` `            ``}` `            ``document.write(``"
"``);` `            `  `        ``} ``while``(prev_permutation(Contain));` `    ``}` `}`   `/*Driver code*/` `const set = [``'a'``,``'b'``,``'c'``];` `printPowerSet(set, 3);`   `// This code is contributed by Gautam goel (gautamgoel962)`

Output

```a
b
c
ab
ac
bc
abc```

Time Complexity: O(n2n)
Auxiliary Space: O(n)

Method 3:
This method is specific to the python programming language. We can iterate a loop over 0 to the length of the set to obtain and generate all possible combinations of that string with the iterable length. The program below will give the implementation of the above idea.

Below is the implementation of the above approach.

## C++

 `#include ` `#include ` `#include ` `#include `   `using` `namespace` `std;`   `// Function to generate all possible combinations of elements from an array` `vector> combinations(``const` `vector<``char``> &arr, ``int` `len) {` `  `  `      ``// Stores the result` `    ``vector> res;` `    `  `    ``// Helper lambda function to generate the combinations` `    ``function<``void``(vector<``char``>, vector<``char``>)> fn = ` `    ``[&](vector<``char``> active, vector<``char``> rest) {` `        ``if` `(active.size() == len) {` `            ``res.push_back(active);` `        ``} ``else` `{` `            ``for` `(``int` `i = 0; i < rest.size(); i++) {` `                ``auto` `active_copy = active;` `                ``active_copy.push_back(rest[i]);` `                ``auto` `rest_copy = vector<``char``>(rest.begin() + i + 1, rest.end());` `                ``fn(active_copy, rest_copy);` `            ``}` `        ``}` `    ``};` `    ``fn({}, arr);` `    ``return` `res;` `}`   `// Function to print all possible subsets of a given set (string)` `void` `print_powerset(``const` `string &str) {` `    ``for` `(``int` `i = 0; i <= str.length(); i++) {` `        `  `        ``// Generating the combinations` `        ``auto` `combos = combinations(vector<``char``>(str.begin(), str.end()), i);` `        `  `        ``// Displaying each combination` `        ``for` `(``const` `auto` `&combo : combos) {` `            ``for` `(``const` `auto` `&c : combo) {` `                ``cout << c;` `            ``}` `            ``cout << endl;` `        ``}` `    ``}` `}`   `// Driver code` `int` `main() {` `    ``string str = ``"abc"``;` `    ``print_powerset(str);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `class` `GFG {`   `  ``// Function to generate all possible combinations of` `  ``// elements from an array` `  ``public` `static` `List >` `    ``combinations(``char``[] arr, ``int` `len)` `  ``{` `    ``List > a = ``new` `ArrayList<>();` `    ``fn(``new` `ArrayList<>(), arr, a, ``0``, len);` `    ``return` `a;` `  ``}`   `  ``// Helper function to generate the combinations` `  ``private` `static` `void` `fn(List active,` `                         ``char``[] rest,` `                         ``List > a,` `                         ``int` `start, ``int` `len)` `  ``{` `    ``if` `(active.size() == len) {` `      ``a.add(``new` `ArrayList<>(active));` `    ``}` `    ``else` `{` `      ``for` `(``int` `i = start; i < rest.length; i++) {` `        ``active.add(rest[i]);` `        ``fn(active, rest, a, i + ``1``, len);` `        ``active.remove(active.size() - ``1``);` `      ``}` `    ``}` `  ``}`   `  ``// Function to print all possible subsets of a given set` `  ``// (string)` `  ``public` `static` `void` `printPowerset(``char``[] string)` `  ``{` `    ``for` `(``int` `i = ``0``; i <= string.length; i++) {`   `      ``// Displaying all the combinations` `      ``for` `(List combination :` `           ``combinations(string, i)) {` `        ``for` `(var letter : combination)` `          ``System.out.print(letter);` `        ``System.out.print(``"\n"``);` `      ``}` `    ``}` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``char``[] string = { ``'a'``, ``'b'``, ``'c'` `};` `    ``printPowerset(string);` `  ``}` `}`   `// This code is contributed by phasing17`

## Python3

 `#Python program to find powerset` `from` `itertools ``import` `combinations` `def` `print_powerset(string):` `    ``for` `i ``in` `range``(``0``,``len``(string)``+``1``):` `        ``for` `element ``in` `combinations(string,i):` `            ``print``(''.join(element))` `string``=``[``'a'``,``'b'``,``'c'``]` `print_powerset(string) `

## C#

 `// C# program to implement the approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {`   `  ``// Function to generate all possible combinations of` `  ``// elements from an array` `  ``public` `static` `List > combinations(``char``[] arr,` `                                               ``int` `len)` `  ``{` `    ``List > a = ``new` `List >();` `    ``fn(``new` `List<``char``>(), arr, a, 0, len);` `    ``return` `a;` `  ``}`   `  ``// Helper function to generate the combinations` `  ``private` `static` `void` `fn(List<``char``> active, ``char``[] rest,` `                         ``List > a, ``int` `start,` `                         ``int` `len)` `  ``{` `    ``if` `(active.Count == len) {` `      ``a.Add(``new` `List<``char``>(active));` `    ``}` `    ``else` `{` `      ``for` `(``int` `i = start; i < rest.Length; i++) {` `        ``active.Add(rest[i]);` `        ``fn(active, rest, a, i + 1, len);` `        ``active.RemoveAt(active.Count - 1);` `      ``}` `    ``}` `  ``}`   `  ``// Function to print all possible subsets of a given set` `  ``// (string)` `  ``public` `static` `void` `printPowerset(``char``[] str)` `  ``{` `    ``for` `(``int` `i = 0; i <= str.Length; i++) {`   `      ``// Displaying all the combinations` `      ``foreach``(List<``char``> combination ``in` `combinations(` `        ``str, i))` `      ``{` `        ``foreach``(``char` `letter ``in` `combination)` `          ``Console.Write(letter);` `        ``Console.WriteLine();` `      ``}` `    ``}` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``char``[] str = { ``'a'``, ``'b'``, ``'c'` `};` `    ``printPowerset(str);` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// Function to generate all possible combinations of elements from an array` `function` `combinations(arr, len) {` `    ``let fn = ``function``(active, rest, a) {` `        ``if` `(active.length === len) {` `            ``a.push(active);` `        ``} ``else` `{` `            ``for` `(let i = 0; i < rest.length; i++) {` `                ``fn(active.concat(rest[i]), rest.slice(i + 1), a);` `            ``}` `        ``}` `        ``return` `a;` `    ``}` `    ``return` `fn([], arr, []);` `}`   `// Function to print all possible subsets of a given set (string)` `function` `print_powerset(string) {` `    ``for` `(let i = 0; i <= string.length; i++) {` `        ``for` `(let element of combinations(string, i)) {` `            ``console.log(element.join(``''``)+``"
"``);` `        ``}` `    ``}` `}`   `// Example usage` `let string = [``'a'``, ``'b'``, ``'c'``];` `print_powerset(string);`   `// This code is contributed by lokeshpotta20`

Output

```a
b
c
ab
ac
bc
abc```

Time Complexity: O((2n * n2)
Auxiliary Space: O(n2n)

Method 4:

We can use backtrack here, we have two choices first consider that element then don’t consider that element.

Below is the implementation of the above approach.

## C++

 `#include ` `using` `namespace` `std;`   `void` `findPowerSet(``char``* s, vector<``char``> &res, ``int` `n){` `        ``if` `(n == 0) {` `            ``for` `(``auto` `i: res) ` `              ``cout << i;` `            ``cout << ``"\n"``;` `            ``return``;` `            `  `        ``}` `         ``res.push_back(s[n - 1]);` `         ``findPowerSet(s, res, n - 1);` `         ``res.pop_back();                    ` `         ``findPowerSet(s, res, n - 1);` `    ``}` `    `  `void` `printPowerSet(``char``* s, ``int` `n){` `    ``vector<``char``> ans;` `    ``findPowerSet(s, ans, n);` `}`     `int` `main()` `{` `    ``char` `set[] = { ``'a'``, ``'b'``, ``'c'` `};` `    ``printPowerSet(set, 3);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;` ` `  `class` `Main` `{` `    ``public` `static` `void` `findPowerSet(``char` `[]s, Deque res,``int` `n){` `        ``if` `(n == ``0``){` `          ``for` `(Character element : res)` `             ``System.out.print(element);` `          ``System.out.println();` `            ``return``;` `        ``}` `        ``res.addLast(s[n - ``1``]);` `        ``findPowerSet(s, res, n - ``1``);` `        ``res.removeLast();                    ` `        ``findPowerSet(s, res, n - ``1``);` `    ``}` ` `  `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``char` `[]set = {``'a'``, ``'b'``, ``'c'``};` `        ``Deque res = ``new` `ArrayDeque<>();` `        ``findPowerSet(set, res, ``3``);` `    ``}` `}`

## Python3

 `# Python3 program to implement the approach`   `# Function to build the power sets` `def` `findPowerSet(s, res, n):` `    ``if` `(n ``=``=` `0``):` `        ``for` `i ``in` `res:` `            ``print``(i, end``=``"")` `        ``print``()` `        ``return`   `    ``# append the subset to result` `    ``res.append(s[n ``-` `1``])` `    ``findPowerSet(s, res, n ``-` `1``)` `    ``res.pop()` `    ``findPowerSet(s, res, n ``-` `1``)`   `# Function to print the power set` `def` `printPowerSet(s, n):` `    ``ans ``=` `[]` `    ``findPowerSet(s, ans, n)`   `# Driver code` `set` `=` `[``'a'``, ``'b'``, ``'c'``]` `printPowerSet(``set``, ``3``)`   `# This code is contributed by phasing17`

## C#

 `// C# code to implement the approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{` `    ``// function to build the power set` `    ``public` `static` `void` `findPowerSet(``char``[] s,` `                                    ``List<``char``> res, ``int` `n)` `    ``{`   `        ``// if the end is reached` `        ``// display all elements of res` `        ``if` `(n == 0) {` `            ``foreach``(``var` `element ``in` `res)` `                ``Console.Write(element);` `            ``Console.WriteLine();` `            ``return``;` `        ``}`   `        ``// append the subset to res` `        ``res.Add(s[n - 1]);` `        ``findPowerSet(s, res, n - 1);` `        ``res.RemoveAt(res.Count - 1);` `        ``findPowerSet(s, res, n - 1);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``char``[] ``set` `= { ``'a'``, ``'b'``, ``'c'` `};` `        ``List<``char``> res = ``new` `List<``char``>();`   `        ``// Function call` `        ``findPowerSet(``set``, res, 3);` `    ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// JavaScript program to implement the approach`   `// Function to build the power sets` `function` `findPowerSet(s, res, n)` `{` `    ``if` `(n == 0)` `    ``{` `        ``for` `(``var` `i of res)` `            ``process.stdout.write(i + ``""``);` `        ``process.stdout.write(``"\n"``);` `        ``return``;` `    ``}`   `    ``// append the subset to result` `    ``res.push(s[n - 1]);` `    ``findPowerSet(s, res, n - 1);` `    ``res.pop();` `    ``findPowerSet(s, res, n - 1);` `}`   `// Function to print the power set` `function` `printPowerSet(s, n)` `{` `    ``let ans = [];` `    ``findPowerSet(s, ans, n);` `}`     `// Driver code` `let set = [``'a'``, ``'b'``, ``'c'``];` `printPowerSet(set, 3);`     `// This code is contributed by phasing17`

Output

```cba
cb
ca
c
ba
b
a```

Time Complexity: O(2^n)

Space Complexity: O(n)

Recursive program to generate power set
Refer Power Set in Java for implementation in Java and more methods to print power set.
References:
http://en.wikipedia.org/wiki/Power_set

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up