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 111Value 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 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++ 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 |
#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 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 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# 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. |
<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> |
<?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 ?> |
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++ 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 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 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# 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 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) |
a b c ab ac bc abc
Time Complexity: O(n2n)
Auxiliary Space: O(n)
Method 3:
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.
#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;
} |
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 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# 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 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 |
cba cb ca c ba b a
Time Complexity: O(2^n)
Auxiliary Space: 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