 Open in App
Not now

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

• Difficulty Level : Hard
• Last Updated : 20 Feb, 2022

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:
Explanation: 5 = 51

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

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 (((k-1)+1).kx = k.kx = kx+1).
4. Since the smallest number has to be found, after this step, all the lower powers of k are reduced to 0 as adding(k-b)kx (b=value at that position in the base k representation) has already made the 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 or equal to n represented``// as the sum of distinct powers of k``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 or equal to n represented``// as the sum of distinct powers of k``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`

## Python3

 `# Python3 implementation of the above approach` `# Function to find the smallest number``# greater than or equal to n represented``# as the sum of distinct powers of k``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 or equal to n represented``// as the sum of distinct powers of k``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`

## Javascript

 ``

Output:

`49`

Time Complexity: O(logkn)

Auxiliary Space: O(logkn)

My Personal Notes arrow_drop_up