# Smallest number greater than n that can be represented as a sum of distinct power of k

Given a number n and a value k, the task is to find the smallest m(m>=n), such that m can be represented as a sum of distinct powers of k.

Examples:

Input: n = 5, k = 5
Output: 5
Explanation: 5 = 51

Input: n = 29, k = 5
Output: 30
Explanation: 30 = 51 + 52

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Store the k-nary(base k) representation of n. Then traverse through each element of the base k representation.
2. If the base k representation of this position is 1 or 0 then continue, if it is >1; it means that the current power of k occurs more than once.
3. In that case, that power is added k (k’s-position value) times which makes it one power more .
4. Since the smallest number has to be found, after this step, all the lower powers of k is reduced to 0 as adding (b=value at that position in base k representation) has already made the number bigger than the previous number.
5. Finally, convert the number back to decimal form.

Below is the implementation of the above approach

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `typedef` `long` `long` `ll; ` `#define pb push_back ` ` `  `// Function to find the smallest number ` `// greater than k represented as ` `// the sum of distinct powers ` `void` `greaterK(ll n, ll k) ` `{ ` ` `  `    ``// Vector P to store the base k ` `    ``// representation of the number ` `    ``vector p; ` `    ``ll x = n; ` `    ``while` `(x) { ` `        ``p.pb(x % k); ` `        ``x /= k; ` `    ``} ` `    ``int` `idx = 0; ` `    ``for` `(ll i = 0; i < (ll)p.size() - 1; ++i) { ` `        ``if` `(p[i] >= 2) { ` ` `  `            ``// If the representation is >=2, then ` `            ``// this power of k has to be added ` `            ``// once again and then increase the ` `            ``// next power of k and make the ` `            ``// current power 0 ` ` `  `            ``p[i] = 0; ` `            ``p[i + 1]++; ` ` `  `            ``// Reduce all the lower power of ` `            ``// k to 0 ` ` `  `            ``for` `(``int` `j = idx; j < i; ++j) { ` `                ``p[j] = 0; ` `            ``} ` `            ``idx = i + 1; ` `        ``} ` ` `  `        ``if` `(p[i] == k) { ` `            ``p[i] = 0; ` `            ``p[i + 1]++; ` `        ``} ` `    ``} ` `    ``ll j = (ll)p.size() - 1; ` ` `  `    ``// Check if the most significant ` `    ``// bit also satisfy the above ` `    ``// conditions ` ` `  `    ``if` `(p[j] >= 2) { ` `        ``for` `(``auto``& i : p) ` `            ``i = 0; ` `        ``p.pb(1); ` `    ``} ` `    ``ll ans = 0; ` ` `  `    ``// Converting back from the ` `    ``// k-nary representation to ` `    ``// decimal form. ` `    ``for` `(ll i = p.size() - 1; i >= 0; --i) { ` `        ``ans = ans * k + p[i]; ` `    ``} ` `    ``cout << ans << endl; ` `} ` ` `  `int` `main() ` `{ ` `    ``ll n = 29, k = 7; ` `    ``greaterK(n, k); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach ` `class` `GFG ` `{ ` ` `  `// Function to find the smallest number ` `// greater than k represented as ` `// the sum of distinct powers ` `static` `void` `greaterK(``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Vector P to store the base k ` `    ``// representation of the number ` `    ``int` `[]p = ``new` `int``[String.valueOf(n).length() + ``2``]; ` `    ``int` `index = ``0``; ` `    ``int` `x = n; ` `    ``while` `(x > ``0``)  ` `    ``{ ` `        ``p[index]=(``int``) (x % k); ` `        ``x /= k; ` `        ``index++; ` `    ``} ` `    ``int` `idx = ``0``; ` `    ``for` `(``int` `i = ``0``; i < p.length - ``1``; ++i) ` `    ``{ ` `        ``if` `(p[i] >= ``2``) ` `        ``{ ` ` `  `            ``// If the representation is >=2, then ` `            ``// this power of k has to be added ` `            ``// once again and then increase the ` `            ``// next power of k and make the ` `            ``// current power 0 ` `            ``p[i] = ``0``; ` `            ``p[i + ``1``]++; ` ` `  `            ``// Reduce all the lower power of ` `            ``// k to 0 ` `            ``for` `(``int` `j = idx; j < i; ++j)  ` `            ``{ ` `                ``p[j] = ``0``; ` `            ``} ` `            ``idx = i + ``1``; ` `        ``} ` ` `  `        ``if` `(p[i] == k) ` `        ``{ ` `            ``p[i] = ``0``; ` `            ``p[i + ``1``]++; ` `        ``} ` `    ``} ` `    ``int` `j = p.length - ``1``; ` ` `  `    ``// Check if the most significant ` `    ``// bit also satisfy the above ` `    ``// conditions ` `    ``if` `(p[j] >= ``2``)  ` `    ``{ ` `        ``p[index] = ``1``; ` `        ``index++; ` `    ``} ` `    ``int` `ans = ``0``; ` ` `  `    ``// Converting back from the ` `    ``// k-nary representation to ` `    ``// decimal form. ` `    ``for` `(``int` `i = p.length - ``1``; i >= ``0``; --i)  ` `    ``{ ` `        ``ans = ans * k + p[i]; ` `    ``} ` `    ``System.out.print(ans +``"\n"``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``29``, k = ``7``; ` `    ``greaterK(n, k); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python 3

 `# Python 3 implementation of the above approach ` ` `  `# Function to find the smallest number ` `# greater than k represented as ` `# the sum of distinct powers ` `def` `greaterK(n, k): ` `     `  `    ``# Vector P to store the base k ` `    ``# representation of the number ` `    ``index ``=` `0` `    ``p ``=` `[``0` `for` `i ``in` `range``(n ``+` `2``)] ` `    ``x ``=` `n ` `    ``while` `(x > ``0``): ` `        ``p[index] ``=` `x ``%` `k ` `        ``x ``/``/``=` `k ` `        ``index ``+``=` `1` ` `  `    ``idx ``=` `0` `    ``for` `i ``in` `range``(``0``,``len``(p)``-``1``, ``1``): ` `        ``if` `(p[i] >``=` `2``): ` `             `  `            ``# If the representation is >=2, then ` `            ``# this power of k has to be added ` `            ``# once again and then increase the ` `            ``# next power of k and make the ` `            ``# current power 0 ` `            ``p[i] ``=` `0` `            ``p[i ``+` `1``] ``+``=` `1` ` `  `            ``# Reduce all the lower power of ` `            ``# k to 0 ` `            ``for` `j ``in` `range``(idx, i, ``1``): ` `                ``p[j] ``=` `0` `             `  `            ``idx ``=` `i ``+` `1` ` `  `        ``if` `(p[i] ``=``=` `k): ` `            ``p[i] ``=` `0` `            ``p[i ``+` `1``] ``+``=` `1` `         `  `    ``j ``=` `len``(p) ``-` `1` ` `  `    ``# Check if the most significant ` `    ``# bit also satisfy the above ` `    ``# conditions ` `    ``if` `(p[j] >``=` `2``): ` `        ``p[index] ``=` `1` `        ``index ``+``=` `1` `    ``ans ``=` `0` ` `  `    ``# Converting back from the ` `    ``# k-nary representation to ` `    ``# decimal form. ` `    ``i ``=` `len``(p)``-``1` `    ``while``(i>``=` `0``): ` `        ``ans ``=` `ans ``*` `k ``+` `p[i] ` `        ``i ``-``=` `1` `    ``print``(ans) ` ` `  `if` `__name__ ``=``=` `'__main__'``: ` `    ``n ``=` `29` `    ``k ``=` `7` `    ``greaterK(n, k) ` ` `  `# This code is contributed by Surendra_Gangwar `

## C#

 `// C# implementation of the above approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to find the smallest number ` `// greater than k represented as ` `// the sum of distinct powers ` `static` `void` `greaterK(``int` `n, ``int` `k) ` `{ ` ` `  `    ``// List P to store the base k ` `    ``// representation of the number ` `    ``int` `[]p = ``new` `int``[String.Join(``""``,n).Length + 2]; ` `    ``int` `index = 0; ` `    ``int` `x = n; ` `    ``int` `j; ` `    ``while` `(x > 0)  ` `    ``{ ` `        ``p[index] = (``int``) (x % k); ` `        ``x /= k; ` `        ``index++; ` `    ``} ` `    ``int` `idx = 0; ` `    ``for` `(``int` `i = 0; i < p.Length - 1; ++i) ` `    ``{ ` `        ``if` `(p[i] >= 2) ` `        ``{ ` ` `  `            ``// If the representation is >=2, then ` `            ``// this power of k has to be added ` `            ``// once again and then increase the ` `            ``// next power of k and make the ` `            ``// current power 0 ` `            ``p[i] = 0; ` `            ``p[i + 1]++; ` ` `  `            ``// Reduce all the lower power of ` `            ``// k to 0 ` `            ``for` `(j = idx; j < i; ++j)  ` `            ``{ ` `                ``p[j] = 0; ` `            ``} ` `            ``idx = i + 1; ` `        ``} ` ` `  `        ``if` `(p[i] == k) ` `        ``{ ` `            ``p[i] = 0; ` `            ``p[i + 1]++; ` `        ``} ` `    ``} ` `    ``j = p.Length - 1; ` ` `  `    ``// Check if the most significant ` `    ``// bit also satisfy the above ` `    ``// conditions ` `    ``if` `(p[j] >= 2)  ` `    ``{ ` `        ``p[index] = 1; ` `        ``index++; ` `    ``} ` `    ``int` `ans = 0; ` ` `  `    ``// Converting back from the ` `    ``// k-nary representation to ` `    ``// decimal form. ` `    ``for` `(``int` `i = p.Length - 1; i >= 0; --i)  ` `    ``{ ` `        ``ans = ans * k + p[i]; ` `    ``} ` `    ``Console.Write(ans +``"\n"``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 29, k = 7; ` `    ``greaterK(n, k); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```49
``` My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.