 Open in App
Not now

# Print all subsequences of a string | Iterative Method

• Difficulty Level : Medium
• Last Updated : 18 Jan, 2023

Given a string s, print all possible subsequences of the given string in an iterative manner. We have already discussed Recursive method to print all subsequences of a string

Examples:

```Input : abc
Output : a, b, c, ab, ac, bc, abc

Input : aab
Output : a, b, aa, ab, aab```

Approach 1 :
Here, we discuss much easier and simpler iterative approach which is similar to Power Set. We use bit pattern from binary representation of 1 to 2^length(s) – 1.

input = “abc”
Binary representation to consider 1 to (2^3-1), i.e 1 to 7.
Start from left (MSB) to right (LSB) of binary representation and append characters from input string which corresponds to bit value 1 in binary representation to Final subsequence string sub.

Example:

```001 => abc . Only c corresponds to bit 1. So, subsequence = c.
101 => abc . a and c corresponds to bit 1. So, subsequence = ac.
binary_representation (1) = 001 => c
binary_representation (2) = 010 => b
binary_representation (3) = 011 => bc
binary_representation (4) = 100 => a
binary_representation (5) = 101 => ac
binary_representation (6) = 110 => ab
binary_representation (7) = 111 => abc```

Below is the implementation of above approach:

## C++

 `// C++ program to print all Subsequences``// of a string in iterative manner``#include ``using` `namespace` `std;` `// function to find subsequence``string subsequence(string s, ``int` `binary, ``int` `len)``{``    ``string sub = ``""``;``    ``for` `(``int` `j = 0; j < len; j++)` `        ``// check if jth bit in binary is 1``        ``if` `(binary & (1 << j))` `            ``// if jth bit is 1, include it``            ``// in subsequence``            ``sub += s[j];` `    ``return` `sub;``}` `// function to print all subsequences``void` `possibleSubsequences(string s){` `    ``// map to store subsequence``    ``// lexicographically by length``    ``map<``int``, set > sorted_subsequence;` `    ``int` `len = s.size();``    ` `    ``// Total number of non-empty subsequence``    ``// in string is 2^len-1``    ``int` `limit = ``pow``(2, len);``    ` `    ``// i=0, corresponds to empty subsequence``    ``for` `(``int` `i = 1; i <= limit - 1; i++) {``        ` `        ``// subsequence for binary pattern i``        ``string sub = subsequence(s, i, len);``        ` `        ``// storing sub in map``        ``sorted_subsequence[sub.length()].insert(sub);``    ``}` `    ``for` `(``auto` `it : sorted_subsequence) {``        ` `        ``// it.first is length of Subsequence``        ``// it.second is set``        ``cout << ``"Subsequences of length = "``             ``<< it.first << ``" are:"` `<< endl;``             ` `        ``for` `(``auto` `ii : it.second)``            ` `            ``// ii is iterator of type set``            ``cout << ii << ``" "``;``        ` `        ``cout << endl;``    ``}``}` `// driver function``int` `main()``{``    ``string s = ``"aabc"``;``    ``possibleSubsequences(s);``    ``return` `0;``}`

## Java

 `// Java program to print all Subsequences``// of a String in iterative manner``import` `java.util.ArrayList;``import` `java.util.Arrays;``import` `java.util.HashMap;``import` `java.util.HashSet;``import` `java.util.Map;``import` `java.util.SortedMap;``import` `java.util.TreeMap;` `class` `Graph{` `// Function to find subsequence``static` `String subsequence(String s,``                          ``int` `binary,``                          ``int` `len)``{``    ``String sub = ``""``;``    ` `    ``for``(``int` `j = ``0``; j < len; j++)``    ` `        ``// Check if jth bit in binary is 1``        ``if` `((binary & (``1` `<< j)) != ``0``)` `            ``// If jth bit is 1, include it``            ``// in subsequence``            ``sub += s.charAt(j);` `    ``return` `sub;``}` `// Function to print all subsequences``static` `void` `possibleSubsequences(String s)``{``    ` `    ``// Map to store subsequence``    ``// lexicographically by length``    ``SortedMap> sorted_subsequence = ``new` `TreeMap>();` `    ``int` `len = s.length();` `    ``// Total number of non-empty subsequence``    ``// in String is 2^len-1``    ``int` `limit = (``int``) Math.pow(``2``, len);` `    ``// i=0, corresponds to empty subsequence``    ``for``(``int` `i = ``1``; i <= limit - ``1``; i++)``    ``{``        ` `        ``// Subsequence for binary pattern i``        ``String sub = subsequence(s, i, len);``        ` `        ``// Storing sub in map``        ``if` `(!sorted_subsequence.containsKey(sub.length()))``            ``sorted_subsequence.put(``                ``sub.length(), ``new` `HashSet<>());``            ``sorted_subsequence.get(``                ``sub.length()).add(sub);``    ``}` `    ``for``(Map.Entry> it : sorted_subsequence.entrySet())``    ``{``        ` `        ``// it.first is length of Subsequence``        ``// it.second is set``        ``System.out.println(``"Subsequences of length = "` `+``                           ``it.getKey() + ``" are:"``);``                           ` `        ``for``(String ii : it.getValue())``        ` `            ``// ii is iterator of type set``            ``System.out.print(ii + ``" "``);` `        ``System.out.println();``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``String s = ``"aabc"``;``    ` `    ``possibleSubsequences(s);``}``}` `// This code is contributed by sanjeev2552`

## Python3

 `# Python3 program to print all Subsequences``# of a string in iterative manner` `# function to find subsequence``def` `subsequence(s, binary, length):``    ``sub ``=` `""``    ``for` `j ``in` `range``(length):``        ` `        ``# check if jth bit in binary is 1``        ``if` `(binary & (``1` `<< j)):` `            ``# if jth bit is 1, include it``            ``# in subsequence``            ``sub ``+``=` `s[j]``    ``return` `sub` `# function to print all subsequences``def` `possibleSubsequences(s):` `    ``# map to store subsequence``    ``# lexicographically by length``    ``sorted_subsequence ``=` `{}` `    ``length ``=` `len``(s)``    ` `    ``# Total number of non-empty subsequence``    ``# in string is 2^len-1``    ``limit ``=` `2` `*``*` `length``    ` `    ``# i=0, corresponds to empty subsequence``    ``for` `i ``in` `range``(``1``, limit):``        ` `        ``# subsequence for binary pattern i``        ``sub ``=` `subsequence(s, i, length)``        ` `        ``# storing sub in map``        ``if` `len``(sub) ``in` `sorted_subsequence.keys():``            ``sorted_subsequence[``len``(sub)] ``=` `\``             ``tuple``(``list``(sorted_subsequence[``len``(sub)]) ``+` `[sub])``        ``else``:``            ``sorted_subsequence[``len``(sub)] ``=` `[sub]` `    ``for` `it ``in` `sorted_subsequence:``        ` `        ``# it.first is length of Subsequence``        ``# it.second is set``        ``print``(``"Subsequences of length ="``, it, ``"are:"``)``        ``for` `ii ``in` `sorted``(``set``(sorted_subsequence[it])):``            ` `            ``# ii is iterator of type set``            ``print``(ii, end ``=` `' '``)``        ``print``()` `# Driver Code``s ``=` `"aabc"``possibleSubsequences(s)` `# This code is contributed by ankush_953`

## C#

 `// C# program to print all Subsequences``// of a String in iterative manner``using` `System;``using` `System.Collections.Generic;` `class` `Graph {` `  ``// Function to find subsequence``  ``static` `string` `subsequence(``string` `s, ``int` `binary, ``int` `len)``  ``{``    ``string` `sub = ``""``;` `    ``for` `(``int` `j = 0; j < len; j++)` `      ``// Check if jth bit in binary is 1``      ``if` `((binary & (1 << j)) != 0)` `        ``// If jth bit is 1, include it``        ``// in subsequence``        ``sub += s[j];` `    ``return` `sub;``  ``}` `  ``// Function to print all subsequences``  ``static` `void` `possibleSubsequences(``string` `s)``  ``{` `    ``// Map to store subsequence``    ``// lexicographically by length``    ``SortedDictionary<``int``, HashSet<``string``> >``      ``sorted_subsequence``      ``= ``new` `SortedDictionary<``int``, HashSet<``string``> >();` `    ``int` `len = s.Length;` `    ``// Total number of non-empty subsequence``    ``// in String is 2^len-1``    ``int` `limit = (``int``)Math.Pow(2, len);` `    ``// i=0, corresponds to empty subsequence``    ``for` `(``int` `i = 1; i <= limit - 1; i++) {` `      ``// Subsequence for binary pattern i``      ``string` `sub = subsequence(s, i, len);` `      ``// Storing sub in map``      ``if` `(!sorted_subsequence.ContainsKey(sub.Length))``        ``sorted_subsequence[sub.Length]``        ``= ``new` `HashSet<``string``>();``      ``sorted_subsequence[sub.Length].Add(sub);``    ``}` `    ``foreach``(``var` `it ``in` `sorted_subsequence)``    ``{` `      ``// it.first is length of Subsequence``      ``// it.second is set``      ``Console.WriteLine(``"Subsequences of length = "``                        ``+ it.Key + ``" are:"``);` `      ``foreach``(String ii ``in` `it.Value)` `        ``// ii is iterator of type set``        ``Console.Write(ii + ``" "``);` `      ``Console.WriteLine();``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``string` `s = ``"aabc"``;` `    ``possibleSubsequences(s);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output

```Subsequences of length = 1 are:
a b c
Subsequences of length = 2 are:
aa ab ac bc
Subsequences of length = 3 are:
aab aac abc
Subsequences of length = 4 are:
aabc ```

Time Complexity : , where n is length of string to find subsequences and l is length of binary string.
Space Complexity: O(1)

Approach 2 :

Approach is to get the position of rightmost set bit and reset that bit after appending corresponding character from given string to the subsequence and will repeat the same thing till corresponding binary pattern has no set bits.

```If input is s = “abc”
Binary representation to consider 1 to (2^3-1), i.e 1 to 7.
001 => abc . Only c corresponds to bit 1. So, subsequence = c
101 => abc . a and c corresponds to bit 1. So, subsequence = ac.
Let us use Binary representation of 5, i.e 101.
Rightmost bit is at position 1, append character at beginning of sub = c ,reset position 1 => 100
Rightmost bit is at position 3, append character at beginning of sub = ac ,reset position 3 => 000
As now we have no set bit left, we stop computing subsequence.```

Example:

```binary_representation (1) = 001 => c
binary_representation (2) = 010 => b
binary_representation (3) = 011 => bc
binary_representation (4) = 100 => a
binary_representation (5) = 101 => ac
binary_representation (6) = 110 => ab
binary_representation (7) = 111 => abc```

Below is the implementation of above approach :

## C++

 `// C++ code all Subsequences of a``// string in iterative manner``#include ``using` `namespace` `std;` `// function to find subsequence``string subsequence(string s, ``int` `binary)``{``    ``string sub = ``""``;``    ``int` `pos;``    ` `    ``// loop while binary is greater than 0``    ``while``(binary>0)``    ``{``        ``// get the position of rightmost set bit``        ``pos=log2(binary&-binary)+1;``        ` `        ``// append at beginning as we are``        ``// going from LSB to MSB``        ``sub=s[pos-1]+sub;``        ` `        ``// resets bit at pos in binary``        ``binary= (binary & ~(1 << (pos-1)));``    ``}``    ``reverse(sub.begin(),sub.end());``    ``return` `sub;``}` `// function to print all subsequences``void` `possibleSubsequences(string s){` `    ``// map to store subsequence``    ``// lexicographically by length``    ``map<``int``, set > sorted_subsequence;` `    ``int` `len = s.size();``    ` `    ``// Total number of non-empty subsequence``    ``// in string is 2^len-1``    ``int` `limit = ``pow``(2, len);``    ` `    ``// i=0, corresponds to empty subsequence``    ``for` `(``int` `i = 1; i <= limit - 1; i++) {``        ` `        ``// subsequence for binary pattern i``        ``string sub = subsequence(s, i);``        ` `        ``// storing sub in map``        ``sorted_subsequence[sub.length()].insert(sub);``    ``}` `    ``for` `(``auto` `it : sorted_subsequence) {``        ` `        ``// it.first is length of Subsequence``        ``// it.second is set``        ``cout << ``"Subsequences of length = "``            ``<< it.first << ``" are:"` `<< endl;``            ` `        ``for` `(``auto` `ii : it.second)``            ` `            ``// ii is iterator of type set``            ``cout << ii << ``" "``;``        ` `        ``cout << endl;``    ``}``}` `// driver function``int` `main()``{``    ``string s = ``"aabc"``;``    ``possibleSubsequences(s);``    ` `    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `GFG {``    ``// function to find subsequence``    ``public` `static` `String subsequence(String s, ``int` `binary) {``        ``String sub = ``""``;``        ``int` `pos;` `        ``// loop while binary is greater than 0``        ``while` `(binary > ``0``) {``            ``// get the position of rightmost set bit``            ``pos = (``int``) (Math.log(binary & -binary) / Math.log(``2``)) + ``1``;` `            ``// append at beginning as we are``            ``// going from LSB to MSB``            ``sub = s.charAt(pos - ``1``) + sub;` `            ``// resets bit at pos in binary``            ``binary = (binary & ~(``1` `<< (pos - ``1``)));``        ``}``        ``sub = ``new` `StringBuilder(sub).reverse().toString();``        ``return` `sub;``    ``}` `    ``// function to print all subsequences``    ``public` `static` `void` `possibleSubsequences(String s) {``        ``// map to store subsequence``        ``// lexicographically by length``        ``Map> sortedSubsequence = ``new` `HashMap<>();` `        ``int` `len = s.length();` `        ``// Total number of non-empty subsequence``        ``// in string is 2^len-1``        ``int` `limit = (``int``) Math.pow(``2``, len);` `        ``// i=0, corresponds to empty subsequence``        ``for` `(``int` `i = ``1``; i <= limit - ``1``; i++) {``            ``// subsequence for binary pattern i``            ``String sub = subsequence(s, i);` `            ``// storing sub in map``            ``sortedSubsequence.computeIfAbsent(sub.length(), k -> ``new` `TreeSet<>()).add(sub);``        ``}` `        ``for` `(Map.Entry> it : sortedSubsequence.entrySet()) {``            ``// it.getKey() is length of Subsequence``            ``// it.getValue() is Set``            ``System.out.println(``"Subsequences of length = "` `+ it.getKey() + ``" are:"``);` `            ``for` `(String ii : it.getValue())``                ``// ii is element of Set``                ``System.out.print(ii + ``" "``);` `            ``System.out.println();``        ``}``    ``}` `    ``// driver function``    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"aabc"``;``        ``possibleSubsequences(s);``    ``}``}`

## Python3

 `# Python3 program to print all Subsequences``# of a string in an iterative manner``from` `math ``import` `log2, floor` `# function to find subsequence``def` `subsequence(s, binary):``    ``sub ``=` `""``    ` `    ``# loop while binary is greater than``    ``while``(binary > ``0``):``        ` `        ``# get the position of rightmost set bit``        ``pos``=``floor(log2(binary&``-``binary) ``+` `1``)``        ` `        ``# append at beginning as we are``        ``# going from LSB to MSB``        ``sub ``=` `s[pos ``-` `1``] ``+` `sub``        ` `        ``# resets bit at pos in binary``        ``binary``=` `(binary & ~(``1` `<< (pos ``-` `1``)))` `    ``sub ``=` `sub[::``-``1``]``    ``return` `sub` `# function to print all subsequences``def` `possibleSubsequences(s):` `    ``# map to store subsequence``    ``# lexicographically by length``    ``sorted_subsequence ``=` `{}` `    ``length ``=` `len``(s)``    ` `    ``# Total number of non-empty subsequence``    ``# in string is 2^len-1``    ``limit ``=` `2` `*``*` `length``    ` `    ``# i=0, corresponds to empty subsequence``    ``for` `i ``in` `range``(``1``, limit):``        ` `        ``# subsequence for binary pattern i``        ``sub ``=` `subsequence(s, i)``        ` `        ``# storing sub in map``        ``if` `len``(sub) ``in` `sorted_subsequence.keys():``            ``sorted_subsequence[``len``(sub)] ``=` `\``            ``tuple``(``list``(sorted_subsequence[``len``(sub)]) ``+` `[sub])``        ``else``:``            ``sorted_subsequence[``len``(sub)] ``=` `[sub]` `    ``for` `it ``in` `sorted_subsequence:``        ` `        ``# it.first is length of Subsequence``        ``# it.second is set``        ``print``(``"Subsequences of length ="``, it, ``"are:"``)``        ``for` `ii ``in` `sorted``(``set``(sorted_subsequence[it])):``            ` `            ``# ii is iterator of type set``            ``print``(ii, end ``=` `' '``)``        ``print``()` `# Driver Code``s ``=` `"aabc"``possibleSubsequences(s)` `# This code is contributed by ankush_953`

## C#

 `// C# program to print all Subsequences``// of a string in an iterative manner` `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `GFG``{` `  ``// function to find subsequence``  ``static` `string` `subsequence(``string` `s, ``int` `binary)``  ``{``    ``string` `sub = ``""``;` `    ``// loop while binary is greater than``    ``while` `(binary > 0) {` `      ``// get the position of rightmost set bit``      ``var` `pos = (``int``)Math.Floor(``        ``Math.Log(binary & (-binary))``        ``/ Math.Log(2))``        ``+ 1;` `      ``// append at beginning as we are``      ``// going from LSB to MSB``      ``sub = s[pos - 1] + sub;` `      ``// resets bit at pos in binary``      ``binary = (binary & ~(1 << (pos - 1)));``    ``}` `    ``char``[] charArray = sub.ToCharArray();``    ``Array.Reverse(charArray);``    ``return` `new` `string``(charArray);``  ``}` `  ``// function to print all subsequences``  ``static` `void` `possibleSubsequences(``string` `s)``  ``{` `    ``// map to store subsequence``    ``// lexicographically by length``    ``Dictionary<``int``, HashSet<``string``> > sorted_subsequence``      ``= ``new` `Dictionary<``int``, HashSet<``string``> >();` `    ``int` `length = s.Length;` `    ``// Total number of non-empty subsequence``    ``// in string is 2^len-1``    ``int` `limit = (``int``)Math.Pow(2, length);` `    ``// i=0, corresponds to empty subsequence``    ``for` `(``int` `i = 1; i < limit; i++) {``      ``// subsequence for binary pattern i``      ``string` `sub = subsequence(s, i);` `      ``// storing sub in map``      ``if` `(sorted_subsequence.ContainsKey(``        ``sub.Length)) {``        ``sorted_subsequence[sub.Length].Add(sub);``      ``}``      ``else` `{``        ``sorted_subsequence[sub.Length]``          ``= ``new` `HashSet<``string``>();``        ``sorted_subsequence[sub.Length].Add(sub);``      ``}``    ``}``    ``foreach``(``var` `it ``in` `sorted_subsequence)``    ``{` `      ``// it.first is length of Subsequence``      ``// it.second is set``      ``Console.WriteLine(``"Subsequences of length = "``                        ``+ it.Key + ``" are:"``);``      ``var` `arr = (it.Value).ToArray();``      ``Array.Sort(arr);``      ``for` `(``int` `i = 0; i < arr.Length; i++) {``        ``Console.Write(arr[i] + ``" "``);``      ``}``      ``Console.WriteLine();``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``string` `s = ``"aabc"``;``    ``possibleSubsequences(s);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 `// JavaScript program to print all Subsequences``// of a string in an iterative manner` `// function to find subsequence``function` `subsequence(s, binary)``{``    ``var` `sub = ``""``;``    ` `    ``// loop while binary is greater than``    ``while``(binary > 0)``    ``{``        ` `        ``// get the position of rightmost set bit``        ``var` `pos= Math.floor(Math.log2(binary&-binary) + 1);``        ` `        ``// append at beginning as we are``        ``// going from LSB to MSB``        ``sub = s[pos - 1] + sub;``        ` `        ``// resets bit at pos in binary``        ``binary= (binary & ~(1 << (pos - 1)));``    ``}` `    ``sub =  sub.split(``""``);``    ``sub = sub.reverse();``    ``return` `sub.join(``""``);``}` `// function to print all subsequences``function` `possibleSubsequences(s)``{` `    ``// map to store subsequence``    ``// lexicographically by length``    ``var` `sorted_subsequence = {};` `    ``var` `length = s.length;``    ` `    ``// Total number of non-empty subsequence``    ``// in string is 2^len-1``    ``var` `limit = 2 ** length;``    ` `    ``// i=0, corresponds to empty subsequence``    ``for` `(``var` `i = 1; i < limit; i++)``    ``{``        ``// subsequence for binary pattern i``        ``var` `sub = subsequence(s, i);``        ` `        ``// storing sub in map``        ``if` `(sorted_subsequence.hasOwnProperty(sub.length))``        ``{``            ``//var list = sorted_subsequence[sub.length];``            ``//list.push(sub);``            ``sorted_subsequence[sub.length].push(sub);``        ``}``        ``else``            ``sorted_subsequence[sub.length] = [sub];``    ``}``    ``for` `(const it ``in` `sorted_subsequence)``    ``{``        ` `        ``// it.first is length of Subsequence``        ``// it.second is set``        ``console.log(``"Subsequences of length ="``, it, ``"are:"``);``        ``var` `arr = sorted_subsequence[it];``        ``arr.sort();``        ``var` `set = ``new` `Set(arr);``        ``for` `(const ii of set)``            ``// ii is iterator of type set``            ``process.stdout.write(ii + ``" "``);``        ``console.log()``    ``}``}` `// Driver Code``var` `s = ``"aabc"``;``possibleSubsequences(s);` `// This code is contributed by phasing17`

Output

```Subsequences of length = 1 are:
a b c
Subsequences of length = 2 are:
aa ab ac bc
Subsequences of length = 3 are:
aab aac abc
Subsequences of length = 4 are:
aabc ```

Time Complexity , where n is the length of string to find subsequence and b is the number of set bits in binary string.
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up