Given two integers **N** and **K**, the task is to find the **N ^{th} Subset **from the sequence of subsets generated from the powers of K i.e. {1, K

^{1}, K

^{2}, K

^{3}, …..} such that the subsets are arranged in increasing order of their sum, the task is to find the

**N**from the sequence.

^{th}subset**Examples:**

Input:N = 5, K = 3Output:1 9Explanation:

Sequence of subsets along with their sum are:

- Subset = {1}, Sum = 1
- Subset = {3}, Sum = 3
- Subset = {1, 3}, Sum = 4
- Subset = {9}, Sum = 9
- Subset = {1, 9}, Sum = 10
Therefore, the subset at position 5 is {1, 9}.

Input:N = 4, K = 4Output:16

**Approach:**

Let’s refer to the required sequence for K = 3 given below:

From the above sequence, it can be observed that the subset {3} has position 2, the subset {9} has position 4, and the subset {27} has position 8, and so on. The subset {1, 3}, {1, 9}, {1, 27} occupies positions 3, 5, and 9 respectively. Hence, all the elements of the required N^{th} subset can be obtained by finding the nearest power of 2 which is smaller than or equal to **N**.

Illustration:

N = 6, K = 3

1st iteration:

- p = log
_{2}(6) = 2- 3
^{2}= 9, Subset = {9}- N = 6 % 4 = 2
2nd iteration:

- p = log
_{2}(2) = 1- 3
^{1}= 3, Subset = {3, 9}- N = 2 % 2 = 0
Therefore the required subset is {3, 9}

Follow the steps below to solve the problem:

- Calculate the nearest power of
**2**which is smaller than or equal to**N**, say**p**. Therefore,**p = log**._{2}N - Now, the element of the subset will be K
^{p}. Insert it into the front of the subset. - Update
**N**to**N % 2**.^{p} - Repeat the above steps until N becomes 0, and consequently print the obtained subset.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach ` `#include ` `#include ` `using` `namespace` `std;` `#define lli long long int` `// Function to print the ` `// required N-th subset ` `void` `printSubset(lli n, ` `int` `k)` `{` ` ` `vector answer;` ` ` `while` `(n > 0)` ` ` `{` ` ` ` ` `// Nearest power of 2<=N` ` ` `lli p = log2(n);` ` ` `// Now insert k^p in the answer` ` ` `answer.push_back(` `pow` `(k, p));` ` ` `// update n` ` ` `n %= (` `int` `)` `pow` `(2, p);` ` ` `}` ` ` ` ` `// Print the ans in sorted order` ` ` `reverse(answer.begin(), answer.end());` ` ` `for` `(` `auto` `x: answer)` ` ` `{` ` ` `cout << x < 0):` ` ` `# Nearest power of 2 <= N` ` ` `p = ` `int` `(math.` `log` `(N, 2))` ` ` `# Insert K ^ p in the subset` ` ` `answer = str(K**p)+` `" "` `+answer` ` ` `# Update N` ` ` `N = N % (2**p)` ` ` `# Print the subset` ` ` `print(answer)` `# Driver Code` `N = 5` `K = 4` `printSubset(N, K)` |

*chevron_right*

*filter_none*

**Output**

1 16

**Time Complexity: **O(logN) **Auxiliary Space: **O(1)

**Approach: **

- Initialize count and x by 0. Also, A vector to store the elements of the subsets.
- Do the following while n is greater than 0.
- Set x = n & 1, for finding the last bit of the number is set or not.
- Now Push element 3
^{count }into the subset if n is not 0. - Reduce the number n by two with the help of right shifting by 1 unit.
- Increase the count value by 1.

- Finally, elements into the array are the elements of Nth subset.

Below is the implementation of the above approach:

## C++

`// C++ program to print subset` `// at the nth position ordered` `// by the sum of the elements` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to print the elements of ` `// the subset at pos n` `void` `printsubset(` `int` `n,` `int` `k)` `{` ` ` `// Initialize count=0 and x=0` ` ` `int` `count = 0, x = 0;` ` ` ` ` `// create a vector for ` ` ` `// storing the elements` ` ` `// of subsets` ` ` `vector<` `int` `> vec;` ` ` ` ` `// doing until all the` ` ` `// set bits of n are used` ` ` `while` `(n) {` ` ` `x = n & 1;` ` ` ` ` `// this part is executed only` ` ` `// when the last bit is` ` ` `// set` ` ` `if` `(x) {` ` ` `vec.push_back(` `pow` `(k, count));` ` ` `}` ` ` ` ` `// right shift the bit by one position` ` ` `n = n >> 1; ` ` ` ` ` `// incresing the count each time by one` ` ` `count++; ` ` ` `}` ` ` ` ` `// printing the values os elements` ` ` `for` `(` `int` `i = 0; i < vec.size(); i++)` ` ` `cout << vec[i] << ` `" "` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `n = 7,k=4;` ` ` `printsubset(n,k);` ` ` `return` `0;` `}` `// This code is contributed by shivkant` |

*chevron_right*

*filter_none*

## Java

`// Java program for ` `// the above approach ` `import` `java.util.*;` `import` `java.lang.*;` `class` `GFG{` ` ` `// Function to print the ` `// elements of the subset ` `// at pos n` `static` `void` `printsubset(` `int` `n, ` ` ` `int` `k)` `{` ` ` `// Initialize count=0 and x=0` ` ` `int` `count = ` `0` `, x = ` `0` `;` ` ` `// Create a vector for ` ` ` `// storing the elements` ` ` `// of subsets` ` ` `ArrayList<Integer> vec = ` ` ` `new` `ArrayList<>();` ` ` `// Doing until all the` ` ` `// set bits of n are used` ` ` `while` `(n != ` `0` `) ` ` ` `{` ` ` `x = n & ` `1` `;` ` ` `// This part is executed only` ` ` `// when the last bit is` ` ` `// set` ` ` `if` `(x != ` `0` `) ` ` ` `{` ` ` `vec.add((` `int` `)Math.pow(k, ` ` ` `count));` ` ` `}` ` ` `// Right shift the bit ` ` ` `// by one position` ` ` `n = n >> ` `1` `; ` ` ` `// Incresing the count ` ` ` `// each time by one` ` ` `count++; ` ` ` `}` ` ` `// Printing the values os elements` ` ` `for` `(` `int` `i = ` `0` `; i < vec.size(); i++)` ` ` `System.out.print(vec.get(i) + ` `" "` `);` `}` `// Driver function` `public` `static` `void` `main (String[] args) ` `{` ` ` `int` `n = ` `7` `, k = ` `4` `;` ` ` `printsubset(n, k);` `}` `}` `// This code is contributed by offbeat` |

*chevron_right*

*filter_none*

**Output**

1 4 16

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Sum of maximum and minimum of Kth subset ordered by increasing subset sum
- Find K that requires minimum increments or decrements of array elements to obtain a sequence of increasing powers of K
- Count of numbers whose sum of increasing powers of digits is equal to the number itself
- Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
- Split N powers of 2 into two subsets such that their difference of sum is minimum
- Construct an AP series consisting of A and B having minimum possible Nth term
- Print all prime factors and their powers
- Count of pairs in a given range with sum of their product and sum equal to their concatenated number
- Largest possible Subset from an Array such that no element is K times any other element in the Subset
- Find original sequence from Array containing the sequence merged many times in order
- Count pairs from 1 to N such that their Sum is divisible by their XOR
- Possible values of Q such that, for any value of R, their product is equal to X times their sum
- Minimum size Subarray with maximum sum in non-increasing order
- Maximum sum of increasing order elements from n arrays
- Nth term of a sequence formed by sum of current term with product of its largest and smallest digit
- Sum of fourth powers of the first n natural numbers
- Sum of fifth powers of the first n natural numbers
- Sum of fourth powers of first n odd natural numbers
- Sum of largest divisible powers of p (a prime number) in a range
- Find k numbers which are powers of 2 and have sum N | Set 1

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.