Related Articles
Nth Subset of the Sequence consisting of powers of K in increasing order of their Sum
• Difficulty Level : Medium
• Last Updated : 02 Mar, 2021

Given two integers N and K, the task is to find the Nth Subset from the sequence of subsets generated from the powers of K i.e. {1, K1, K2, K3, …..} such that the subsets are arranged in increasing order of their sum, the task is to find the Nth subset from the sequence.

Examples:

Input: N = 5, K = 3
Output: 1 9
Explanation:
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 = 4
Output: 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 Nth 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:

1. p = log2(6) = 2
2. 32 = 9, Subset = {9}
3. N = 6 % 4 = 2

2nd iteration:

1. p = log2(2) = 1
2. 31 = 3, Subset = {3, 9}
3. 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 = log2N.
• Now, the element of the subset will be Kp. Insert it into the front of the subset.
• Update N to N % 2p.
• 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 << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``lli n = 5;``    ``int` `k = 4;``    ``printSubset(n, k);``}` `// This code is contributed by winter_soldier`

## Java

 `// Java program for above approach``import` `java.util.*;``import` `java.lang.*;``import` `java.io.*;``class` `GFG``{` `  ``// Function to print the ``  ``// required N-th subset ``  ``static` `void` `printSubset(``long` `n, ``int` `k)``  ``{``    ``ArrayList answer = ``new` `ArrayList<>();``    ``while``(n > ``0``)``    ``{` `      ``// Nearest power of 2<=N``      ``long` `p = (``long``)(Math.log(n) / Math.log(``2``));;` `      ``// Now insert k^p in the answer``      ``answer.add((``long``)(Math.pow(k, p)));` `      ``// update n``      ``n %= (``int``)Math.pow(``2``, p);``    ``}` `    ``// Print the ans in sorted order``    ``Collections.sort(answer);``    ``for``(Long x: answer)``    ``{``      ``System.out.print(x + ``" "``);``    ``}``  ``}` `  ``// Driver function``  ``public` `static` `void` `main (String[] args)``  ``{``    ``long` `n = ``5``;``    ``int` `k = ``4``;``    ``printSubset(n, k);``  ``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for``# the above approach``import` `math` `# Function to print the``# required N-th subset``def` `printSubset(N, K):``    ``# Stores the subset``    ``answer ``=` `""``    ``while``(N > ``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)`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `  ``// Function to print the``  ``// required N-th subset``  ``static` `void` `printSubset(``int` `n, ``int` `k)``  ``{``    ``List<``int``> answer = ``new` `List<``int``>();``    ``while``(n > 0)``    ``{` `      ``// Nearest power of 2<=N``      ``int` `p = (``int``)Math.Log(n,2);` `      ``// Now insert k^p in the answer``      ``answer.Add((``int``)Math.Pow(k, p));` `      ``// update n``      ``n %= (``int``)Math.Pow(2, p);``    ``}` `    ``// Print the ans in sorted order``    ``answer.Reverse();``    ``foreach``(``int` `x ``in` `answer)``    ``{``      ``Console.Write(x + ``" "``);``    ``}``  ``}` `  ``// Driver code``  ``static` `void` `Main() {``    ``int` `n = 5;``    ``int` `k = 4;``    ``printSubset(n, k);``  ``}``}` `// This code is contributed by divyeshrabadiya07.`
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 3count 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 ``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`

## Java

 `// Java program to print subset``// at the nth position ordered``// by the sum of the elements``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 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`

## Python3

 `# Python3 program to print subset``# at the nth position ordered``# by the sum of the elements``import` `math` `# Function to print the elements of``# the subset at pos n``def` `printsubset(n, k):``    ` `    ``# Initialize count=0 and x=0``    ``count ``=` `0``    ``x ``=` `0` `    ``# Create a vector for``    ``# storing the elements``    ``# of subsets``    ``vec ``=` `[]` `    ``# 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):``            ``vec.append(``pow``(k, count))``    ` `        ``# Right shift the bit by one position``        ``n ``=` `n >> ``1``    ` `        ``# Increasing the count each time by one``        ``count ``+``=` `1` `    ``# Printing the values os elements``    ``for` `item ``in` `vec:``        ``print``(item, end ``=` `" "``)` `# Driver Code``n ``=` `7``k ``=` `4` `printsubset(n, k)` `# This code is contributed by Stream_Cipher`

## C#

 `// C# program to print subset``// at the nth position ordered``// by the sum of the elements``using` `System.Collections.Generic;``using` `System;` `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``    ``List<``int``> vec = ``new` `List<``int``>();``    ` `    ``// 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.Count; i++)``        ``Console.Write(vec[i] + ``" "``);``}` `// Driver code``public` `static` `void` `Main ()``{``    ``int` `n = 7, k = 4;``    ` `    ``printsubset(n, k);``}``}` `// This code is contributed by Stream_Cipher`

Output
`1 4 16 `

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up