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 2ⁿ 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

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 2ⁿ-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 2³-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 <bits/stdc++.h>
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 <stdio.h>
#include <math.h>

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))
            printf("%c", set[j]);
       }
       printf("\n");
    }
}

/*Driver program to test printPowerSet*/
int main()
{
    char set[] = {'a','b','c'};
    printPowerSet(set, 3);
    return 0;
}

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

<?php
// PHP program for power set

function printPowerSet($set, $set_size)
{

    // set_size of power set of
    // a set with set_size
    // n is (2**n -1)
    $pow_set_size = pow(2, $set_size);
    $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))
                echo $set[$j];
        }

    echo "\n";
    }
}

    // Driver Code
    $set = array('a','b','c');
    printPowerSet($set, 3);

// This code is contributed by Vishal Tripathi
?>

Javascript

<script>
// javascript program for power setpublic

    function printPowerSet(set, set_size)
    {

        /*
         * set_size of power set of a set with set_size n is (2**n -1)
         */
        var pow_set_size = parseInt(Math.pow(2, set_size));
        var 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)
                    document.write(set[j]);
            }
            document.write("<br/>");
        }
    }

    // Driver program to test printPowerSet
        let set = [ 'a', 'b', 'c' ];
        printPowerSet(set, 3);

// This code is contributed by shikhasingrajput
</script>

Output

a
b
ab
c
ac
bc
abc

Time Complexity: O(n2ⁿ)
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 <bits/stdc++.h>
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("<br>");
    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("<br>");

        } 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(n2ⁿ)
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 <iostream>
#include <vector>
#include <functional>
#include <string>

using namespace std;

// Function to generate all possible combinations of elements from an array
vector<vector<char>> combinations(const vector<char> &arr, int len) {

      // Stores the result
    vector<vector<char>> 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<List<Character> >
    combinations(char[] arr, int len)
  {
    List<List<Character> > a = new ArrayList<>();
    fn(new ArrayList<>(), arr, a, 0, len);
    return a;
  }

  // Helper function to generate the combinations
  private static void fn(List<Character> active,
                         char[] rest,
                         List<List<Character> > 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<Character> 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<List<char> > combinations(char[] arr,
                                               int len)
  {
    List<List<char> > a = new List<List<char> >();
    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<List<char> > 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('')+"<br>");
        }
    }
}

// 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((2ⁿ * n²)
Auxiliary Space: O(n2ⁿ)

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 <bits/stdc++.h>
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<Character> 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<Character> 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.