This article is about generating Power set in lexicographical order.
Examples :
Input : abc
Output : a ab abc ac b bc c
The idea is to sort array first. After sorting, one by one fix characters and recursively generates all subsets starting from them. After every recursive call, we remove last character so that next permutation can be generated.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void func(string s, vector<string>& str, int n, int pow_set)
{
int i, j;
for (i = 0; i < pow_set; i++) {
string x;
for (j = 0; j < n; j++) {
if (i & 1 << j) {
x = x + s[j];
}
}
if (i != 0)
str.push_back(x);
}
}
int main()
{
int n;
string s;
vector<string> str;
s = "cab" ;
n = s.length();
int pow_set = pow (2, n);
func(s, str, n, pow_set);
sort(str.begin(), str.end());
for ( int i = 0; i < str.size(); i++)
cout << str[i] << " " ;
cout << endl;
return 0;
}
|
Java
import java.util.*;
class GFG {
static void permuteRec(String str, int n,
int index, String curr)
{
if (index == n) {
return ;
}
System.out.println(curr);
for ( int i = index + 1 ; i < n; i++) {
curr += str.charAt(i);
permuteRec(str, n, i, curr);
curr = curr.substring( 0 , curr.length() - 1 );
}
return ;
}
static void powerSet(String str)
{
char [] arr = str.toCharArray();
Arrays.sort(arr);
permuteRec( new String(arr), str.length(), - 1 , "" );
}
public static void main(String[] args)
{
String str = "cab" ;
powerSet(str);
}
}
|
Python3
def permuteRec(string, n, index = - 1 , curr = ""):
if index = = n:
return
if len (curr) > 0 :
print (curr)
for i in range (index + 1 , n):
curr + = string[i]
permuteRec(string, n, i, curr)
curr = curr[: len (curr) - 1 ]
def powerSet(string):
string = ''.join( sorted (string))
permuteRec(string, len (string))
if __name__ = = "__main__" :
string = "cab"
powerSet(string)
|
C#
using System;
class GFG {
static void permuteRec(String str, int n,
int index, String curr)
{
if (index == n) {
return ;
}
Console.WriteLine(curr);
for ( int i = index + 1; i < n; i++) {
curr += str[i];
permuteRec(str, n, i, curr);
curr = curr.Substring(0, curr.Length - 1);
}
return ;
}
static void powerSet(String str)
{
char [] arr = str.ToCharArray();
Array.Sort(arr);
permuteRec( new String(arr), str.Length, -1, "" );
}
public static void Main(String[] args)
{
String str = "cab" ;
powerSet(str);
}
}
|
Javascript
<script>
function permuteRec( str , n , index, curr) {
if (index == n) {
return ;
}
document.write(curr+ " " );
for ( var i = index + 1; i < n; i++) {
curr += str[i];
permuteRec(str, n, i, curr);
curr = curr.substring(0, curr.length - 1);
}
return ;
}
function powerSet(str) {
var arr = str.split( "" );
arr.sort();
permuteRec(arr, str.length, -1, "" );
}
var str = "cab" ;
powerSet(str);
</script>
|
PHP
<?php
function permuteRec( $str , $n , $index = -1,
$curr = "" )
{
if ( $index == $n )
return ;
echo $curr . "\n" ;
for ( $i = $index + 1; $i < $n ; $i ++)
{
$curr = $curr . $str [ $i ];
permuteRec( $str , $n , $i , $curr );
$curr = "" ;
}
return ;
}
function powerSet( $str )
{
$str = str_split ( $str );
sort( $str );
permuteRec( $str , sizeof( $str ));
}
$str = "cab" ;
powerSet( $str );
?>
|
Output
a ab b c ca cab cb
Time Complexity: O(n*2n)
Auxiliary Space: O(1)
Method (binary numbers)
The idea is to use binary numbers to generate the power set of a given set of elements in lexicographical order
- Sort the given set in lexicographical order.
- Define a variable “n” to represent the size of the set.
- Use a loop to generate all possible binary numbers of length “n”.
- For each binary number, convert it to a string of 0s and 1s,
- Add the current subset to the output list.
- Sort the output list in lexicographical order.
- Print the sorted list of subsets.
C++
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void generate_power_set(string s)
{
sort(s.begin(), s.end());
int n = s.length();
vector<string> subsets;
for ( int i = 0; i < (1 << n); i++) {
string binary = "" ;
int num = i;
for ( int j = 0; j < n; j++) {
binary = char ( '0' + num % 2) + binary;
num /= 2;
}
string subset = "" ;
for ( int j = 0; j < n; j++) {
if (binary[j] == '1' ) {
subset += s[j];
}
}
subsets.push_back(subset);
}
sort(subsets.begin(), subsets.end());
for ( auto & subset : subsets) {
cout << subset << " " ;
}
cout << endl;
}
int main()
{
string s = "abc" ;
generate_power_set(s);
return 0;
}
|
Java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class Program {
static void generatePowerSet(String s) {
char [] charArray = s.toCharArray();
Arrays.sort(charArray);
String sortedString = new String(charArray);
int n = sortedString.length();
List<String> subsets = new ArrayList<>();
for ( int i = 0 ; i < ( 1 << n); i++) {
StringBuilder binary = new StringBuilder();
int num = i;
for ( int j = 0 ; j < n; j++) {
binary.insert( 0 , num % 2 );
num /= 2 ;
}
StringBuilder subset = new StringBuilder();
for ( int j = 0 ; j < n; j++) {
if (binary.charAt(j) == '1' ) {
subset.append(sortedString.charAt(j));
}
}
subsets.add(subset.toString());
}
subsets.sort( null );
for (String subset : subsets) {
System.out.print(subset + " " );
}
System.out.println();
}
public static void main(String[] args) {
String s = "abc" ;
generatePowerSet(s);
}
}
|
Python3
def generate_power_set(s):
s = ''.join( sorted (s))
n = len (s)
subsets = []
for i in range ( 2 * * n):
binary = bin (i)[ 2 :].zfill(n)
subset = ' '.join([s[j] for j in range(n) if binary[j] == ' 1 '])
subsets.append(subset)
subsets.sort()
for subset in subsets:
print (subset)
s = 'abc'
generate_power_set(s)
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
class Program {
static void GeneratePowerSet( string s)
{
char [] charArray = s.ToCharArray();
Array.Sort(charArray);
string sortedString = new string (charArray);
int n = sortedString.Length;
List< string > subsets = new List< string >();
for ( int i = 0; i < (1 << n); i++) {
string binary = "" ;
int num = i;
for ( int j = 0; j < n; j++) {
binary = (num % 2) + binary;
num /= 2;
}
string subset = "" ;
for ( int j = 0; j < n; j++) {
if (binary[j] == '1' ) {
subset += sortedString[j];
}
}
subsets.Add(subset);
}
subsets.Sort();
foreach ( var subset in subsets)
{
Console.Write(subset + " " );
}
Console.WriteLine();
}
static void Main()
{
string s = "abc" ;
GeneratePowerSet(s);
}
}
|
Javascript
function generatePowerSet(s) {
let charArray = Array.from(s);
charArray.sort();
let sortedString = charArray.join( '' );
let n = sortedString.length;
let subsets = [];
for (let i = 0; i < (1 << n); i++) {
let binary = '' ;
let num = i;
for (let j = 0; j < n; j++) {
binary = (num % 2) + binary;
num = Math.floor(num / 2);
}
let subset = '' ;
for (let j = 0; j < n; j++) {
if (binary.charAt(j) === '1' ) {
subset += sortedString.charAt(j);
}
}
subsets.push(subset);
}
subsets.sort();
console.log(subsets.join( ' ' ));
}
let s = 'abc' ;
generatePowerSet(s);
|
Output
a
ab
abc
ac
b
bc
c
Time complexity :O(2^n * n), where n is the length of the input set.
Space complexity :O(2^n * n), since the output list of subsets can potentially contain 2^n elements
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!
Last Updated :
28 Oct, 2023
Like Article
Save Article