Open In App

Power Set in Lexicographic order

Last Updated : 23 May, 2024
Improve
Improve
Like Article
Like
Save
Share
Report
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++
// CPP program to generate power set in
// lexicographic order.
#include <bits/stdc++.h>
using namespace std;

// str : Stores input string
// n : Length of str.
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
// Java program to generate power set in
// lexicographic order.
import java.util.*;

class GFG {

    // str : Stores input string
    // n : Length of str.
    // curr : Stores current permutation
    // index : Index in current permutation, curr
    static void permuteRec(String str, int n,
                           int index, String curr)
    {
        // base case
        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);

            // backtracking
            curr = curr.substring(0, curr.length() - 1);
        }
        return;
    }

    // Generates power set in lexicographic
    // order.
    static void powerSet(String str)
    {
        char[] arr = str.toCharArray();
        Arrays.sort(arr);
        permuteRec(new String(arr), str.length(), -1, "");
    }

    // Driver code
    public static void main(String[] args)
    {
        String str = "cab";
        powerSet(str);
    }
}

/* This code contributed by PrinciRaj1992 */
Python
# Python3 program to generate power
# set in lexicographic order.

# str : Stores input string
# n : Length of str.
# curr : Stores current permutation
# index : Index in current permutation, curr
def permuteRec(string, n, index = -1, curr = ""):

    # base case
    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)

        # backtracking
        curr = curr[:len(curr) - 1]

# Generates power set in lexicographic order
def powerSet(string):
    string = ''.join(sorted(string))
    permuteRec(string, len(string))

# Driver Code
if __name__ == "__main__":
    string = "cab"
    powerSet(string)

# This code is contributed by vibhu4agarwal
C#
// C# program to generate power set in
// lexicographic order.
using System;

class GFG {

    // str : Stores input string
    // n : Length of str.
    // curr : Stores current permutation
    // index : Index in current permutation, curr
    static void permuteRec(String str, int n,
                           int index, String curr)
    {
        // base case
        if (index == n) {
            return;
        }
        Console.WriteLine(curr);
        for (int i = index + 1; i < n; i++) {

            curr += str[i];
            permuteRec(str, n, i, curr);

            // backtracking
            curr = curr.Substring(0, curr.Length - 1);
        }
        return;
    }

    // Generates power set in lexicographic
    // order.
    static void powerSet(String str)
    {
        char[] arr = str.ToCharArray();
        Array.Sort(arr);
        permuteRec(new String(arr), str.Length, -1, "");
    }

    // Driver code
    public static void Main(String[] args)
    {
        String str = "cab";
        powerSet(str);
    }
}

// This code contributed by Rajput-Ji
Javascript
// javascript program to generate power set in
// lexicographic order.

    // str : Stores input string
    // n : Length of str.
    // curr : Stores current permutation
    // index : Index in current permutation, curr
    function permuteRec( str , n , index,  curr) {
        // base case
        if (index == n) {
            return;
        }
        console.log(curr+" ");
        for (var i = index + 1; i < n; i++) {

            curr += str[i];
            permuteRec(str, n, i, curr);

            // backtracking
            curr = curr.substring(0, curr.length - 1);
        }
        return;
    }

    // Generates power set in lexicographic
    // order.
    function powerSet(str) {
        var arr = str.split("");
        arr.sort();
        permuteRec(arr, str.length, -1, "");
    }

    // Driver code
    
        var str = "cab";
        powerSet(str);

// This code contributed by umadevi9616 
PHP
<?php
// PHP program to generate power 
// set in lexicographic order.

// str : Stores input string
// n : Length of str.
// curr : Stores current permutation
// index : Index in current permutation, curr
function permuteRec($str, $n, $index = -1, 
                              $curr = "")
{
    // base case
    if ($index == $n) 
        return;

    echo $curr."\n";
    for ($i = $index + 1; $i < $n; $i++) 
    {

        $curr=$curr.$str[$i];
        permuteRec($str, $n, $i, $curr);

        // backtracking
        $curr =""; 
    }
    return;
}

// Generates power set in lexicographic
// order.
function powerSet($str)
{

    $str = str_split($str);
    sort($str);
    permuteRec($str, sizeof($str));
}

// Driver code
$str = "cab";
powerSet($str);

// This code is contributed by Mithun Kumar
?>

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 the set in lexicographical order
    sort(s.begin(), s.end());

    int n = s.length();
    vector<string> subsets;

    // Generate all possible binary strings of length n
    for (int i = 0; i < (1 << n); i++) {
        string binary = "";
        int num = i;

        // Convert the integer i to a binary string of
        // length n
        for (int j = 0; j < n; j++) {
            binary = char('0' + num % 2) + binary;
            num /= 2;
        }

        // Generate the subset based on the binary string
        string subset = "";
        for (int j = 0; j < n; j++) {
            if (binary[j] == '1') {
                subset += s[j];
            }
        }
        subsets.push_back(subset);
    }

    // Sort the subsets in lexicographically order
    sort(subsets.begin(), subsets.end());

    // Print the subsets in sorted order
    for (auto& subset : subsets) {
        cout << subset << " ";
    }
    cout << endl;
}

int main()
{
    string s = "abc";
    generate_power_set(s);
    return 0;
}

// This code is contributed by abhinav_m22
Java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Program {
    // Function to generate the power set of a string
    static void generatePowerSet(String s) {
        // Convert the string to a character array
        char[] charArray = s.toCharArray();
        // Sort the character array
        Arrays.sort(charArray);
        String sortedString = new String(charArray);

        int n = sortedString.length();
        List<String> subsets = new ArrayList<>();

        // Generate all possible binary strings of length n
        for (int i = 0; i < (1 << n); i++) {
            StringBuilder binary = new StringBuilder();
            int num = i;

            // Convert the integer i to a binary string of length n
            for (int j = 0; j < n; j++) {
                binary.insert(0, num % 2);
                num /= 2;
            }

            // Generate the subset based on the binary string
            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());
        }

        // Sort the subsets in lexicographically order
        subsets.sort(null);

        // Print the subsets in sorted order
        for (String subset : subsets) {
            System.out.print(subset + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        String s = "abc";
        generatePowerSet(s);
    }
}
Python
def generate_power_set(s):
    # Sort the set in lexicographical order
    s = ''.join(sorted(s))

    n = len(s)
    subsets = []
    # Generate all possible binary strings of length n
    for i in range(2**n):
        # Convert the integer i to a binary string of length n
        binary = bin(i)[2:].zfill(n)
        # Generate the subset based on the binary string
        subset = ''.join([s[j] for j in range(n) if binary[j] == '1'])
        subsets.append(subset)
    # Sort the subsets in lexicographically order
    subsets.sort()
    # Print the subsets in sorted order
    for subset in subsets:
        print(subset)

# Example usage
s = 'abc'
generate_power_set(s)
C#
using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    // Function to generate the power set of a string
    static void GeneratePowerSet(string s)
    {
        // Sort the set in lexicographical order
        char[] charArray = s.ToCharArray();
        Array.Sort(charArray);
        string sortedString = new string(charArray);

        int n = sortedString.Length;
        List<string> subsets = new List<string>();

        // Generate all possible binary strings of length n
        for (int i = 0; i < (1 << n); i++) {
            string binary = "";
            int num = i;

            // Convert the integer i to a binary string of
            // length n
            for (int j = 0; j < n; j++) {
                binary = (num % 2) + binary;
                num /= 2;
            }

            // Generate the subset based on the binary
            // string
            string subset = "";
            for (int j = 0; j < n; j++) {
                if (binary[j] == '1') {
                    subset += sortedString[j];
                }
            }
            subsets.Add(subset);
        }

        // Sort the subsets in lexicographically order
        subsets.Sort();

        // Print the subsets in sorted order
        foreach(var subset in subsets)
        {
            Console.Write(subset + " ");
        }
        Console.WriteLine();
    }

    static void Main()
    {
        string s = "abc";
        GeneratePowerSet(s);
    }
}
Javascript
function generatePowerSet(s) {
    // Convert the string to an array of characters
    let charArray = Array.from(s);
    // Sort the character array
    charArray.sort();
    let sortedString = charArray.join('');

    let n = sortedString.length;
    let subsets = [];

    // Generate all possible binary strings of length n
    for (let i = 0; i < (1 << n); i++) {
        let binary = '';
        let num = i;

        // Convert the integer i to a binary string of length n
        for (let j = 0; j < n; j++) {
            binary = (num % 2) + binary;
            num = Math.floor(num / 2);
        }

        // Generate the subset based on the binary string
        let subset = '';
        for (let j = 0; j < n; j++) {
            if (binary.charAt(j) === '1') {
                subset += sortedString.charAt(j);
            }
        }
        subsets.push(subset);
    }

    // Sort the subsets in lexicographically order
    subsets.sort();

    // Print the subsets in sorted order
    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



Previous Article
Next Article

Similar Reads

Print a number as string of 'A' and 'B' in lexicographic order
Given a number N, the task is to print the string of 'A' and 'B' corresponding to that number.If we represent all numbers as a string of 'A' and 'B' as follows, 1 = A 2 = B 3 = AA 4 = AB 5 = BA 6 = BB 7 = AAA 8 = AAB 9 = ABA 10 = ABB ..... ..... 1000000 = BBBABAAAABAABAAAAAB Examples: Input: N = 30 Output: BBBB Input: N = 55 Output: BBAAA Input: N
10 min read
Find position of non-attacking Rooks in lexicographic order that can be placed on N*N chessboard
Given an integer N and an array arr[] of positions which denotes the positions of already placed non-attacking rooks, the task is to find the positions of non-attacking rooks in lexicographic order that can be placed on N*N chessboard.Movement of Rooks: Any rook can move horizontally or vertically by any number of unoccupied squares. Examples: Inpu
7 min read
Find all strings in lexicographic order possible by replacing digits with 'x', 'y' or 'z'
Given a string str, consisting of lower case English alphabets and digits(0-9), the task is to print all possible strings in lexicographic order that can be formed by replacing each occurrence of a digit with either 'x', 'y' or 'z'. Example: Input: str = "a1b2"Output: axbx axby axbz aybx ayby aybz azbx azby azbzExplanation: These string are the 9 p
6 min read
Print all permutations in sorted (lexicographic) order
Given a string, print all permutations of it in sorted order. For example, if the input string is "ABC", then output should be "ABC, ACB, BAC, BCA, CAB, CBA". We have discussed a program to print all permutations in this post, but here we must print the permutations in increasing order. Algorithm to print the permutations lexicographic-ally:Step 1.
23 min read
Generating distinct subsequences of a given string in lexicographic order
Given a string s, make a list of all possible combinations of letters of a given string S. If there are two strings with the same set of characters, print the lexicographically smallest arrangement of the two stringsFor string abc, the list in lexicographic order subsequences are, a ab abc ac b bc c Examples: Input : s = "ab" Output : a ab b Input
4 min read
Find a string in lexicographic order which is in between given two strings
Given two strings S and T, find a string of the same length which is lexicographically greater than S and smaller than T. Print "-1" if no such string is formed.(S &gt; T) Note: string S = s1s2... sn is said to be lexicographically smaller than string T = t1t2... tn, if there exists an i, such that s1 = t1, s2 = t2, ... si - 1 = ti - 1, si &lt; ti.
5 min read
Pre Order, Post Order and In Order traversal of a Binary Tree in one traversal | (Using recursion)
Given a binary tree, the task is to print all the nodes of the binary tree in Pre-order, Post-order, and In-order in one iteration. Examples: Input: [caption width="800"] [/caption] Output: Pre Order: 1 2 4 5 3 6 7 Post Order: 4 5 2 6 7 3 1 In Order: 4 2 5 1 6 3 7 Input: [caption width="800"] [/caption] Output: Pre Order: 1 2 4 8 12 5 9 3 6 7 10 11
9 min read
Largest lexicographic array with at-most K consecutive swaps
Given an array arr[], find the lexicographically largest array that can be obtained by performing at-most k consecutive swaps. Examples : Input : arr[] = {3, 5, 4, 1, 2} k = 3 Output : 5, 4, 3, 2, 1 Explanation : Array given : 3 5 4 1 2 After swap 1 : 5 3 4 1 2 After swap 2 : 5 4 3 1 2 After swap 3 : 5 4 3 2 1 Input : arr[] = {3, 5, 1, 2, 1} k = 3
9 min read
Length of String formed by repeating each character in range [L, R] of given string its lexicographic value times
Given a string S of length N, and a range [L, R] (1 &lt;= L, R &lt;= N). The task is to find the length of string formed by repeating each character in the range [L, R], to its lexicographical value times. Examples: Input: s = "cbbde", l = 2, r = 5Output: 13Explanation: Resultant String is formed after repeating each character in range [2, 5] as sh
9 min read
Find the N-th lexicographic permutation of string using Factoradic method
Given string str with unique characters and a number N, the task is to find the N-th lexicographic permutation of the string using Factoradic method. Examples: Input: str = "abc", N = 3 Output: bac Explanation: All possible permutations in sorted order: abc, acb, bac, bca, cab, cba 3rd permutation is bacInput: str = "aba", N = 2 Output: aba Explana
7 min read