Check if any permutation of N equals any power of K

Given a positive integer N and K where 2 \leq N \leq 10^{18} and 2 \leq K \leq N. The task is to check whether any permutation of digits of N equals any power of K. If possible return “True” otherwise return “False“.

Examples:

Input: N = 96889010407, K = 7
Output: True
Explanation: 96889010407 = 713

Input : N = 123456789, K = 4
Output : False



Approach: The Naive approach is to generate all permutation of digits of N and then check one by one if any of them is divisible of any power of K.
Efficient Approach: We know that total numbers of all power of K will not be more than logK(1018), for eg: if K = 2 then there will be atmost 64 numbers of power of K. We generate all power of K and store it in array.

Now we iterate all numbers from array and check where it contains all digits of N or not.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP implementation of above approach
#include <bits/stdc++.h>
using namespace std;
  
// function to check if N and K are anagrams
bool isValid(long long int N, long long int K)
{
    multiset<int> m1, m2;
  
    while (N > 0) {
        m1.insert(N % 10);
        N /= 10;
    }
  
    while (K > 0) {
        m2.insert(K % 10);
        K /= 10;
    }
  
    if (m1 == m2)
        return true;
    return false;
}
  
// Function to check if any permutation of N exist
// such that it is some power of K
string anyPermutation(long long int N, long long int K)
{
    long long int powK[100], Limit = pow(10, 18);
  
    // generate all power of K under 10^18
    powK[0] = K;
  
    int i = 1;
    while (powK[i - 1] * K < Limit) {
        powK[i] = powK[i - 1] * K;
        i++;
    }
  
    // check if any power of K is valid
    for (int j = 0; j < i; j++)
        if (isValid(N, powK[j])) {
            return "True";
        }
  
    return "False";
}
  
// Driver program
int main()
{
    long long int N = 96889010407, K = 7;
  
    // function call to print required answer
    cout << anyPermutation(N, K);
  
    return 0;
}
  
// This code is written by Sanjit_Prasad

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of above approach.
import java.util.*;
  
class GfG 
{
  
    // function to check if N and K are anagrams
    static boolean isValid(int N, int K) 
    {
        HashSet<Integer> m1 = new HashSet<Integer>();
        HashSet<Integer> m2 = new HashSet<Integer>();
        while (N > 0
        {
            m1.add(N % 10);
            N /= 10;
        }
  
        while (K > 0
        {
            m2.add(K % 10);
            K /= 10;
        }
  
        if (m1.equals(m2))
        {
            return true;
        }
        return false;
    }
  
    // Function to check if any 
    // permutation of N exist
    // such that it is some power of K
    static String anyPermutation(int N, int K) 
    {
        int powK[] = new int[100 + 1], Limit = (int) Math.pow(10, 18);
  
        // generate all power of K under 10^18
        powK[0] = K;
  
        int i = 1;
        while (powK[i - 1] * K < Limit && i<100
        {
            powK[i] = powK[i - 1] * K;
            i++;
        }
  
        // check if any power of K is valid
        for (int j = 0; j < i; j++)
        {
            if (isValid(N, powK[j])) 
            {
                return "True";
            }
        }
  
        return "False";
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int N = (int) 96889010407L, K = 7;
  
        // function call to print required answer
        System.out.println(anyPermutation(N, K));
    }
}
  
// This code contributed by Rajput-Ji

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of above approach
  
# function to check if N 
# and K are anagrams
def isValid(N, K):
  
    m1 = [] 
    m2 = []
  
    while (N > 0) :
        m1.append(N % 10)
        N //= 10
  
    while (K > 0) :
        m2.append(K % 10)
        K //= 10
  
    if (m1 == m2):
        return True
    return False
  
# Function to check if any permutation 
# of N exist such that it is some power of K
def anyPermutation(N, K):
  
    powK = [0] * 100
    Limit = pow(10, 18)
  
    # generate all power of 
    # K under 10^18
    powK[0] = K
  
    i = 1
    while (powK[i - 1] * K < Limit) :
        powK[i] = powK[i - 1] * K
        i += 1
  
    # check if any power of K is valid
    for j in range(i):
        if (isValid(N, powK[j])) :
            return "True"
  
    return "False"
  
# Driver Code
if __name__ == "__main__":
  
    N = 96889010407
    K = 7
  
    # function call to print 
    # required answer
    print(anyPermutation(N, K))
  
# This code is contributed 
# by ChitraNayal

chevron_right


Output:

True

Time Complexity: O(logK(1018)2)



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.



Improved By : ChitraNayal, Rajput-Ji