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

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).k^x = k.k^x = k^{x+1}).
  4. Since the smallest number has to be found, after this step, all the lower powers of k is reduced to 0 as adding (k-b)k^x(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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
#include <bits/stdc++.h>
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<ll> 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

49

competitive-programming-img




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.