GFG App
Open App
Browser
Continue

# Find all Unique Subsets of a given Set

Given an array A[] of positive integers, print all the unique non-empty subsets of the array

Note: The set can not contain duplicate elements, so any repeated subset should be considered only once in the output.

Examples:

Input: A[] = {1, 5, 6}
Output: {{1}, {1, 5}, {1, 6}, {5}, {5, 6}, {6}, {1, 5, 6}}
Explanation: The number of all the non-empty possible subsets will be 2N-1
Here it will be {1}, {1, 5}, {1, 6}, {5}, {5, 6}, {6} and {1, 5, 6}

Input: A[] = {1, 2, 2}
Output: {{1}, {1, 2}, {1, 2, 2}, {2}, {2, 2}}

Intuition: The main idea to solve the problem is as follows:

This problem falls under the classic algorithm of “pick or don’t pick“.

In this problem, there are two choices of whether we want to include an element in the set or exclude it. For every choice, the element can be appended into the resultant array and then, using backtracking, we will exclude it. This way, the desired set will be generated.

The image shown below shows the choices for each element and how the resultant array is generated at the end of the recursion tree.

Recursion tree to generate all subsets

Approach 1 (Recursion):

Follow the given steps to solve the problem using the above approach:

• Iterate over the elements one by one.
• For each element, just pick the element and move ahead recursively and add the subset to the result.
• Then using backtracking, remove the element and continue finding the subsets and adding them to the result.

Below is the implementation for the above approach:

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Helper function to find all unique subsets` `void` `findSubsets(vector<``int``>& v, ``int` `idx,` `                 ``vector<``int``>& subset,` `                 ``set >& result)` `{` `    ``// If the current subset is not empty` `    ``// insert it into the result` `    ``if` `(!subset.empty())` `        ``result.insert(subset);`   `    ``// Iterate over every element in the array` `    ``for` `(``int` `j = idx; j < v.size(); j++) {`   `        ``// Pick the element and move ahead` `        ``subset.push_back(v[j]);` `        ``findSubsets(v, j + 1, subset, result);`   `        ``// Backtrack to drop the element` `        ``subset.pop_back();` `    ``}` `}`   `// Function to return all unique subsets` `vector > solve(vector<``int``>& v)` `{` `    ``// To store the resulting subsets` `    ``set > result;` `    ``vector<``int``> subset;`   `    ``// Helper function call` `    ``findSubsets(v, 0, subset, result);`   `    ``vector > res;` `    ``for` `(``auto` `v : result)` `        ``res.push_back(v);`   `    ``return` `res;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> A = { 1, 2, 2 };`   `    ``// Function call` `    ``vector > result = solve(A);`   `    ``// Print all unique subsets` `    ``for` `(``auto` `v : result) {` `        ``for` `(``int` `i : v) {` `            ``cout << i << ``" "``;` `        ``}` `        ``cout << ``"\n"``;` `    ``}` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Helper function to find all unique subsets` `    ``static` `void` `findSubsets(List v, ``int` `idx,` `                            ``List subset,` `                            ``List > result)` `    ``{` `        ``// If the current subset is not empty insert it into` `        ``// the result` `        ``if` `(!subset.isEmpty()) {` `            ``if` `(!result.contains(subset)) {` `                ``result.add(``new` `ArrayList<>(subset));` `            ``}` `        ``}`   `        ``// Iterate over every element in the array` `        ``for` `(``int` `j = idx; j < v.size(); j++) {` `            ``// Pick the element and move ahead` `            ``subset.add(v.get(j));` `            ``findSubsets(v, j + ``1``, subset, result);`   `            ``// Backtrack to drop the element` `            ``subset.remove(subset.size() - ``1``);` `        ``}` `    ``}`   `    ``// Function to return all unique subsets` `    ``static` `List > solve(List v)` `    ``{` `        ``// To store the resulting subsets.` `        ``List > result` `            ``= ``new` `ArrayList >();` `        ``List subset = ``new` `ArrayList();`   `        ``// Helper function call` `        ``findSubsets(v, ``0``, subset, result);`   `        ``List > res` `            ``= ``new` `ArrayList >();` `        ``for` `(``int` `i = ``0``; i < result.size(); i++) {` `            ``res.add(``new` `ArrayList<>(result.get(i)));` `        ``}`   `        ``return` `res;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``List A = ``new` `ArrayList();` `        ``A.add(``1``);` `        ``A.add(``2``);` `        ``A.add(``2``);`   `        ``List > result` `            ``= ``new` `ArrayList >();`   `        ``// Function call` `        ``result = solve(A);`   `        ``// print all unique subsets` `        ``for` `(``int` `i = ``0``; i < result.size(); i++) {` `            ``List temp = result.get(i);` `            ``for` `(``int` `j = ``0``; j < temp.size(); j++) {` `                ``System.out.print(temp.get(j) + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Python3

 `# Python code to implement the above approach`   `# Helper function to find all unique subsets` `def` `findSubsets(v, idx, subset, result):` `  `  `    ``# If the current subset is not empty insert it into` `    ``# the result` `    ``if` `(``len``(subset) !``=` `0``):` `        ``if` `(subset ``not` `in` `result):` `            ``result.append(subset[:])`   `    ``# Iterate over every element in the array` `    ``for` `j ``in` `range``(idx, ``len``(v)):` `      `  `        ``# Pick the element and move ahead` `        ``subset.append(v[j])` `        ``findSubsets(v, j ``+` `1``, subset, result)`   `        ``# Backtrack to drop the element` `        ``subset.pop()`   `# Function to return all unique subsets` `def` `solve(v):` `  `  `    ``# To store the resulting subsets.` `    ``result ``=` `[]` `    ``subset ``=` `[]`   `    ``# Helper function call` `    ``findSubsets(v, ``0``, subset, result)`   `    ``res ``=` `[]` `    ``for` `i ``in` `range``(``len``(result)):` `        ``res.append(``list``(result[i]))`   `    ``return` `res`   `if` `__name__ ``=``=` `'__main__'``:` `    ``A ``=` `[``1``, ``2``, ``2``]`   `    ``# Function Call` `    ``result ``=` `solve(A)`   `    ``# print all unique subsets` `    ``for` `i ``in` `range``(``len``(result)):` `        ``temp ``=` `result[i]` `        ``for` `j ``in` `range``(``len``(temp)):` `            ``print``(temp[j], end``=``" "``)` `        ``print``()`   `# This code is contributed by Tapesh(tapeshdua420)`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `public` `class` `ListEqualityComparer` `    ``: IEqualityComparer > {` `    ``private` `readonly` `IEqualityComparer` `        ``_itemEqualityComparer;`   `    ``public` `ListEqualityComparer()` `        ``: ``this``(``null``)` `    ``{` `    ``}`   `    ``public` `ListEqualityComparer(` `        ``IEqualityComparer itemEqualityComparer)` `    ``{` `        ``_itemEqualityComparer = itemEqualityComparer` `            ``?? EqualityComparer.Default;` `    ``}`   `    ``public` `static` `readonly` `ListEqualityComparer Default` `        ``= ``new` `ListEqualityComparer();`   `    ``public` `bool` `Equals(List x, List y)` `    ``{` `        ``if` `(ReferenceEquals(x, y))` `            ``return` `true``;` `        ``if` `(ReferenceEquals(x, ``null``)` `            ``|| ReferenceEquals(y, ``null``))` `            ``return` `false``;` `        ``return` `x.Count == y.Count` `            ``&& !x.Except(y, _itemEqualityComparer).Any();` `    ``}`   `    ``public` `int` `GetHashCode(List list)` `    ``{` `        ``int` `hash = 17;` `        ``foreach``(``var` `itemHash ``in` `list` `                    ``.Select(x => _itemEqualityComparer` `                                      ``.GetHashCode(x))` `                    ``.OrderBy(h => h))` `        ``{` `            ``hash += 31 * itemHash;` `        ``}` `        ``return` `hash;` `    ``}` `}`   `class` `Program {` `    ``// Helper function to find all unique subsets` `    ``static` `void` `findSubsets(List<``int``> v, ``int` `idx,` `                            ``List<``int``> subset,` `                            ``List > result)` `    ``{`   `        ``// If the current subset is not empty` `        ``// insert it into the result` `        ``if` `(subset.Count != 0) {` `            ``result.Add(``new` `List<``int``>(subset));` `        ``}`   `        ``// Iterate over every element in the array` `        ``for` `(``int` `j = idx; j < v.Count; j++) {` `            ``// Pick the element and move ahead` `            ``subset.Add(v[j]);` `            ``findSubsets(v, j + 1, subset, result);`   `            ``// Backtrack to drop the element` `            ``subset.RemoveAt(subset.Count - 1);` `        ``}` `    ``}`   `    ``// Function to return all unique subsets` `    ``static` `List > solve(List<``int``> v)` `    ``{` `        ``// To store the resulting subsets` `        ``List > result = ``new` `List >();` `        ``List<``int``> subset = ``new` `List<``int``>();`   `        ``// Helper function call` `        ``findSubsets(v, 0, subset, result);`   `        ``List > newList` `            ``= result` `                  ``.Distinct(` `                      ``ListEqualityComparer<``int``>.Default)` `                  ``.ToList();` `        ``return` `newList;` `    ``}`   `    ``// Driver code` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``List<``int``> A = ``new` `List<``int``>();` `        ``A.Add(1);` `        ``A.Add(2);` `        ``A.Add(2);`   `        ``// Function call` `        ``List > result = solve(A);`   `        ``// Print all unique subsets` `        ``foreach``(List<``int``> v ``in` `result)` `        ``{` `            ``foreach``(``int` `i ``in` `v) { Console.Write(i + ``" "``); }` `            ``Console.WriteLine();` `        ``}` `    ``}` `}`   `// This code is contributed by Tapesh(tapeshdua420)`

## Javascript

 `// Javascript code to implement the approach`     `let result = ``new` `Set();` `let subset = [];`   `// Helper function to find all unique subsets` `function` `findSubsets(idx)` `{` `    ``// If the current subset is not empty` `    ``// insert it into the result` `    ``if` `(subset.length > 0){` `            ``result.add(subset.join(``""``));        ` `    ``}`   `    ``// Iterate over every element in the array` `    ``for` `(let j = idx; j < v.length; j++) {`   `        ``// Pick the element and move ahead` `        ``subset.push(v[j]);` `        ``findSubsets(j + 1);`   `        ``// Backtrack to drop the element` `        ``subset.pop();` `    ``}` `}`   `// Function to return all unique subsets` `function` `solve()` `{` `    ``// To store the resulting subsets`   `    ``// Helper function call` `    ``findSubsets(0);`   `    ``let res = Array.from(result);` `    `  `    ``// console.log(res);` `    ``return` `res;` `}`   `// Driver code`   `let v = [1, 2, 2];`   `// Function call` `let rslt = solve(v);`   `// Print all unique subsets` `for``(let i = 0; i < rslt.length; i++){` `    ``let temp = ``""``;` `    ``for``(let j = 0; j < rslt[i].length; j++){` `        ``temp = temp + rslt[i][j] + ``" "``;` `    ``}` `    ``console.log(temp);` `}`   `// The code is contributed by Nidhi goel. `

Output

```1
1 2
1 2 2
2
2 2 ```

Time complexity: O(N * log(2N) * 2N) = O(N2 * 2N)
Auxiliary space: O(2N)

Approach 2 (Iterative Approach):

Follow the given steps to solve the problem using the above approach:

• Iterate through every number, and there are two choices:
• Either include the element, then add it into all subsets.
• Or exclude the element, then don’t do anything.

Below is the implementation for the above approach:

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function to return all unique subsets` `vector > solve(vector<``int``>& v)` `{` `    ``// To store the resulting subsets` `    ``set > res;` `    ``vector<``int``> subset;` `    ``vector > result;`   `    ``// Insert it into the resultant vector` `    ``res.insert(subset);`   `    ``// Iterate over all elements` `    ``for` `(``int` `i = 0; i < v.size(); i++) {` `        ``int` `N = res.size();` `        ``for` `(``auto` `it = res.begin();` `             ``it != res.end() and N > 0; it++) {`   `            ``// Iterate through every subset` `            ``// generated till now and inset` `            ``// the current element in the` `            ``// end of it` `            ``subset = *it;` `            ``subset.push_back(v[i]);` `            ``result.push_back(subset);` `            ``N--;` `        ``}` `        ``res.insert(result.begin(), result.end());` `        ``result.clear();` `    ``}`   `    ``for` `(``auto` `u : res)` `        ``result.push_back(u);`   `    ``return` `result;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> A = { 1, 2, 2 };`   `    ``// Function call` `    ``vector > result = solve(A);` `    ``for` `(``auto` `v : result) {` `        ``for` `(``int` `i : v) {` `            ``cout << i << ``" "``;` `        ``}` `        ``cout << ``"\n"``;` `    ``}` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach` `import` `java.util.*;`   `class` `GFG` `{` `  `  `  ``// Function to return all unique subsets` `  ``public` `static` `List >` `    ``solve(List v)` `  ``{` `    `  `    ``// To store the resulting subsets` `    ``Set > res = ``new` `HashSet<>();` `    ``List subset = ``new` `ArrayList<>();` `    ``List > result = ``new` `ArrayList<>();`   `    ``// Insert it into the resultant vector` `    ``res.add(subset);`   `    ``// Iterate over all elements` `    ``for` `(``int` `i = ``0``; i < v.size(); i++) {` `      ``int` `N = res.size();` `      ``for` `(List it : res) {` `        ``// Iterate through every subset` `        ``// generated till now and insert` `        ``// the current element in the` `        ``// end of it` `        ``subset = ``new` `ArrayList<>(it);` `        ``subset.add(v.get(i));` `        ``result.add(subset);` `        ``N--;` `        ``if` `(N == ``0``) {` `          ``break``;` `        ``}` `      ``}` `      ``res.addAll(result);` `      ``result.clear();` `    ``}`   `    ``return` `new` `ArrayList<>(res);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``List A = Arrays.asList(``1``, ``2``, ``2``);`   `    ``// Function call` `    ``List > result = solve(A);` `    ``result.sort((x, y) -> {` `      ``for` `(``int` `i = ``0``;` `           ``i < Math.min(x.size(), y.size()); i++) {` `        ``if` `(x.get(i) != y.get(i)) {` `          ``return` `x.get(i) - y.get(i);` `        ``}` `      ``}` `      ``return` `x.size() - y.size();` `    ``});`   `    ``for` `(List v : result) {` `      ``for` `(``int` `i : v) {` `        ``System.out.print(i + ``" "``);` `      ``}` `      ``System.out.println();` `    ``}` `  ``}` `}`   `// This code is contributed by akashish__`

## Python3

 `from` `typing ``import` `List`   `def` `solve(v: ``List``[``int``]) ``-``> ``List``[``List``[``int``]]:` `    ``# To store the resulting subsets` `    ``res ``=` `set``()` `    ``subset ``=` `[]` `    ``result ``=` `[]`   `    ``# Insert an empty subset into the resultant set` `    ``res.add(``tuple``(subset))`   `    ``# Iterate over all elements` `    ``for` `i ``in` `range``(``len``(v)):` `        ``N ``=` `len``(res)` `        ``for` `it ``in` `res:` `            ``# Iterate through every subset generated till now and insert the current element in the end of it` `            ``subset ``=` `list``(it)` `            ``subset.append(v[i])` `            ``result.append(subset)` `            ``N ``-``=` `1` `            ``if` `N ``=``=` `0``:` `                ``break` `        ``res.update([``tuple``(x) ``for` `x ``in` `result])` `        ``result.clear()`   `    ``return` `[``list``(x) ``for` `x ``in` `res]`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``A ``=` `[``1``, ``2``, ``2``]`   `    ``# Function call` `    ``result ``=` `solve(A)` `    ``result.sort(key``=``lambda` `x: (``len``(x), x))`   `    ``for` `v ``in` `result:` `        ``for` `i ``in` `v:` `            ``print``(i, end``=``' '``)` `        ``print``()`

## C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `class` `GFG` `{` `  `  `  ``// Function to return all unique subsets` `  ``public` `static` `List>` `    ``solve(List<``int``> v)` `  ``{`   `    ``// To store the resulting subsets` `    ``HashSet> res = ``new` `HashSet>();` `    ``List<``int``> subset = ``new` `List<``int``>();` `    ``List> result = ``new` `List>();`   `    ``// Insert it into the resultant vector` `    ``res.Add(subset);`   `    ``// Iterate over all elements` `    ``for` `(``int` `i = 0; i < v.Count(); i++)` `    ``{` `      ``int` `N = res.Count();` `      ``foreach` `(List<``int``> it ``in` `res)` `      ``{` `        ``// Iterate through every subset` `        ``// generated till now and insert` `        ``// the current element in the` `        ``// end of it` `        ``subset = ``new` `List<``int``>(it);` `        ``subset.Add(v[i]);` `        ``result.Add(subset);` `        ``N--;` `        ``if` `(N == 0)` `        ``{` `          ``break``;` `        ``}` `      ``}` `      ``res.UnionWith(result);` `      ``result.Clear();` `    ``}`   `    ``return` `res.ToList();` `  ``}`   `  ``// Driver code` `  ``static` `void` `Main(``string``[] args)` `  ``{` `    ``List<``int``> A = ``new` `List<``int``> { 1, 2, 2 };`   `    ``// Function call` `    ``List> result = solve(A);` `    ``result.Sort((x, y) =>` `                ``{` `                  ``for` `(``int` `i = 0;` `                       ``i < Math.Min(x.Count(), y.Count()); i++)` `                  ``{` `                    ``if` `(x[i] != y[i])` `                    ``{` `                      ``return` `x[i] - y[i];` `                    ``}` `                  ``}` `                  ``return` `x.Count() - y.Count();` `                ``});`   `    ``foreach` `(List<``int``> v ``in` `result)` `    ``{`   `      ``foreach` `(``int` `i ``in` `v)` `      ``{` `        ``Console.Write(i + ``" "``);` `      ``}` `      ``Console.WriteLine();` `    ``}` `  ``}` `}`

## Javascript

 `function` `solve(v) {` `  ``// To store the resulting subsets` `  ``let res = ``new` `Set();` `  ``let subset = [];` `  ``let result = [];`   `  ``// Insert it into the resultant set` `  ``res.add(subset.toString());`   `  ``// Iterate over all elements` `  ``for` `(let i = 0; i < v.length; i++) {` `    ``let N = res.size;` `    ``for` `(let it of res) {` `      ``// Iterate through every subset generated till now and insert the current element in the end of it` `      ``let subset = it.split(``","``).map(Number);` `      ``subset.push(v[i]);` `      ``result.push(subset);` `      ``N--;` `      ``if` `(N == 0) {` `        ``break``;` `      ``}` `    ``}` `    ``for` `(let x of result) {` `      ``res.add(x.toString());` `    ``}` `    ``result = [];` `  ``}`   `  ``return` `Array.from(res).map((x) => x.split(``","``).map(Number));` `}`   `// Driver code` `let A = [1, 2, 2];`   `// Function call` `let result = solve(A);` `result.sort((x, y) => {` `  ``for` `(let i = 0; i < Math.min(x.length, y.length); i++) {` `    ``if` `(x[i] != y[i]) {` `      ``return` `x[i] - y[i];` `    ``}` `  ``}` `  ``return` `x.length - y.length;` `});`   `result.forEach((v) => { let temp=``""``;` `  ``v.forEach((i) => { ``if` `(i!=0){` `    ``temp = temp +i + ``" "``; }` `  ``});` `  ``console.log(temp);` `});`

Output

```1
1 2
1 2 2
2
2 2 ```

Time complexity: O(N2 * 2N)
Auxiliary space: O(2N)

Prerequisite: Power Set

To solve the problem using the above approach, follow the idea below:

Represent all the numbers from 1 to 2N – 1 where N is the size of the subset in the binary format and the position for which the bits are set to be added to the array and then add that array into the result i.e to use a bit-mask pattern to generate all the combinations. For example,

Input: A = {1, 5, 6}, N = 3
Explanation: Hence we will check every number from 1 to 7 i.e.till 2n-1 = 23 – 1 = 7
1 => 001 => {6}
2 => 010 => {5}
3 => 011 => {5, 6}
4 => 100 => {1}
5 => 101 => {1, 6}
6 => 110 => {1, 5}
7 => 111 => {1, 5, 6}

Below is the implementation for the above approach:

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function to find the unique subsets` `vector > solve(vector<``int``>& v)` `{` `    ``// To store the resulting subsets` `    ``set > res;` `    ``vector<``int``> subset;` `    ``int` `size = v.size();`   `    ``// Finding 2^N` `    ``int` `N = 1 << size;` `    ``for` `(``int` `i = 1; i < N; i++) {`   `        ``int` `bit = i;` `        ``subset.clear();` `        ``int` `pos = 0;`   `        ``while` `(bit) {`   `            ``// If the bit is set inset` `            ``// it into the subset` `            ``if` `(bit & 1) {` `                ``subset.push_back(v[pos]);` `            ``}` `            ``pos++;` `            ``bit >>= 1;` `        ``}` `        ``res.insert(subset);` `    ``}`   `    ``vector > result;` `    ``for` `(``auto` `u : res)` `        ``result.push_back(u);` `    ``return` `result;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> A = { 1, 2, 2 };`   `    ``// Function call` `    ``vector > result = solve(A);` `    ``for` `(``auto` `v : result) {` `        ``for` `(``int` `i : v) {` `            ``cout << i << ``" "``;` `        ``}` `        ``cout << ``"\n"``;` `    ``}` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach`   `import` `java.util.*;`   `public` `class` `GFG {` `    `  `      ``// Function to find the unique subsets` `    ``static` `List> solve(List v) {` `        ``// To store the resulting subsets` `        ``Set> res = ``new` `HashSet>();` `        ``List subset;` `        ``int` `size = v.size();`   `        ``// Finding 2^N` `        ``int` `N = ``1` `<< size;` `        ``for` `(``int` `i = ``1``; i < N; i++) {` `            ``int` `bit = i;` `            ``subset = ``new` `ArrayList();` `            ``int` `pos = ``0``;`   `            ``while` `(bit != ``0``) {` `                ``// If the bit is set, insert` `                ``// it into the subset` `                ``if` `((bit & ``1``) != ``0``) {` `                    ``subset.add(v.get(pos));` `                ``}` `                ``pos++;` `                ``bit >>= ``1``;` `            ``}` `            ``res.add(subset);` `        ``}`   `        ``List> result = ``new` `ArrayList>();` `        ``for` `(List u : res)` `            ``result.add(u);` `        ``return` `result;` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``List A = ``new` `ArrayList();` `        ``A.add(``1``);` `        ``A.add(``2``);` `        ``A.add(``2``);`   `        ``// Function call` `        ``List> result = solve(A);` `        ``for` `(List v : result) {` `            ``for` `(``int` `i : v) {` `                ``System.out.print(i + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}` `}`

## Python3

 `# Python code to implement the approach` `# Function to find the unique subsets` `def` `solve(v):` `  ``# To store the resulting subsets` `  ``res ``=` `set``()` `  ``subset ``=` `[]` `  ``size ``=` `len``(v)`   `  ``# Finding 2^N` `  ``N ``=` `1` `<< size` `  ``for` `i ``in` `range``(``1``,N):` `    `  `    ``bit ``=` `i` `    ``subset ``=` `[]` `    ``pos ``=` `0`   `    ``while` `bit:`   `      ``# If the bit is set inset` `      ``# it into the subset` `      ``if` `bit & ``1``:` `        ``subset.append(v[pos])` `      ``pos ``+``=` `1` `      ``bit >>``=` `1` `    ``res.add(``tuple``(subset))`   `  ``result ``=` `[]` `  ``iter` `=` `[x ``for` `x ``in` `res]`   `  ``# to store only unique arrays` `  ``hashMap ``=` `{}`   `  ``for` `arr ``in` `iter``:` `    ``hashMap[``str``(arr)] ``=` `arr`   `  ``result_temp ``=` `[v ``for` `_, v ``in` `hashMap.items()]` `  ``for` `i ``in` `range``(``len``(result_temp)):` `    ``u ``=` `result_temp[i]` `    ``result.append(u)`   `  ``return` `result`   `# Driver code` `A ``=` `[``1``, ``2``, ``2``]`   `# Function call` `result ``=` `solve(A)` `print``(result)`   `# This code is contributed by akashish__`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``// Function to find the unique subsets` `  ``static` `List> Solve(List<``int``> v)` `  ``{`   `    ``// To store the resulting subsets` `    ``HashSet> res = ``new` `HashSet>(``new` `ListComparer<``int``>());` `    ``List<``int``> subset;` `    ``int` `size = v.Count;`   `    ``// Finding 2^N` `    ``int` `N = 1 << size;` `    ``for` `(``int` `i = 1; i < N; i++) {` `      ``int` `bit = i;` `      ``subset = ``new` `List<``int``>();` `      ``int` `pos = 0;`   `      ``while` `(bit != 0) {` `        ``// If the bit is set, insert` `        ``// it into the subset` `        ``if` `((bit & 1) != 0) {` `          ``subset.Add(v[pos]);` `        ``}` `        ``pos++;` `        ``bit >>= 1;` `      ``}` `      ``res.Add(subset);` `    ``}`   `    ``List> result = ``new` `List>();` `    ``foreach` `(List<``int``> u ``in` `res) {` `      ``result.Add(u);` `    ``}` `    ``return` `result;` `  ``}`   `  ``public` `static` `void` `Main() {` `    ``List<``int``> A = ``new` `List<``int``>();` `    ``A.Add(1);` `    ``A.Add(2);` `    ``A.Add(2);`   `    ``// Function call` `    ``List> result = Solve(A);` `    ``foreach` `(List<``int``> v ``in` `result) {` `      ``foreach` `(``int` `i ``in` `v) {` `        ``Console.Write(i + ``" "``);` `      ``}` `      ``Console.WriteLine();` `    ``}` `  ``}`   `  ``// Custom comparer for list of integers` `  ``class` `ListComparer : IEqualityComparer> {` `    ``public` `bool` `Equals(List x, List y) {` `      ``if` `(x.Count != y.Count) {` `        ``return` `false``;` `      ``}` `      ``for` `(``int` `i = 0; i < x.Count; i++) {` `        ``if` `(!x[i].Equals(y[i])) {` `          ``return` `false``;` `        ``}` `      ``}` `      ``return` `true``;` `    ``}`   `    ``public` `int` `GetHashCode(List obj) {` `      ``int` `hash = 17;` `      ``foreach` `(T item ``in` `obj) {` `        ``hash = hash * 31 + item.GetHashCode();` `      ``}` `      ``return` `hash;` `    ``}` `  ``}` `}`   `// This code is contributed by akashish__`

## Javascript

 `// JS code to implement the approach`   `// Function to find the unique subsets` `function` `solve(v) {` `  ``// To store the resulting subsets` `  ``let res = ``new` `Set()` `  ``subset = [];` `  ``let size = v.length;`   `  ``// Finding 2^N` `  ``let N = 1 << size;` `  ``for` `(let i = 1; i < N; i++) {`   `    ``let bit = i;` `    ``subset = [];` `    ``let pos = 0;`   `    ``while` `(bit) {`   `      ``// If the bit is set inset` `      ``// it into the subset` `      ``if` `(bit & 1) {` `        ``subset.push(v[pos]);` `      ``}` `      ``pos++;` `      ``bit >>= 1;` `    ``}` `    ``res.add(subset);` `  ``}`   `  ``let result = [];` `  ``const iter = [...res];`   `  ``// to store only unique arrays` `  ``let hashMap = {}`   `  ``iter.forEach(``function` `(arr) {` `    ``hashMap[arr.join(``"|"``)] = arr;` `  ``});`   `  ``let result_temp = Object.keys(hashMap).map(``function` `(k) {` `    ``return` `hashMap[k]` `  ``})`   `  ``for` `(let i = 0; i < result_temp.length; i++) {` `    ``let u = result_temp[i];` `    ``result.push(u);` `  ``}`   `  ``return` `result;` `}`   `// Driver code` `let A = [1, 2, 2];`   `// Function call` `let result = solve(A);` `console.log(result);`   `// This code is contributed by akashish__`

Output

```1
1 2
1 2 2
2
2 2 ```

Time Complexity: O(N2 * 2N)
Auxiliary Space: O(2N)

My Personal Notes arrow_drop_up