Elements of Array which can be expressed as power of some integer to given exponent K

Given an array arr[] of size N, and an integer K, the task is to print all the elements of the Array which can be expressed as a power of some integer (X) to the exponent K, i.e. XK.

Examples:

Input: arr[] = {46656, 64, 256, 729, 16, 1000}, K = 6
Output: 46656 64 729
Explanation:
Only numbers 46656, 64, 729 can be expressed as a power of 6.
46656 = 66,
64 = 26,
729 = 36

Input: arr[] = {23, 81, 256, 125, 16, 1000}, K = 4
Output: 81 256 16
Explanation:
The number 81, 256, 16 can be expressed as a power of 4.

Approach: To solve the problem mentioned above the main idea is to for each number in the Array, find the N-th root of a number. Then check whether this number is an integer or not. If yes, then print it, else skip to the next number.



Below is the implementation of the above approach:

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to print elements of
// the Array which can be expressed as
// power of some integer to given exponent K
  
#include <bits/stdc++.h>
using namespace std;
#define ll long long
  
// Method returns Nth power of A
double nthRoot(ll A, ll N)
{
  
    double xPre = 7;
  
    // Smaller eps, denotes more accuracy
    double eps = 1e-3;
  
    // Initializing difference between two
    // roots by INT_MAX
    double delX = INT_MAX;
  
    // x^K denotes current value of x
    double xK;
  
    // loop untill we reach desired accuracy
    while (delX > eps) {
  
        // calculating current value from previous
        // value by newton's method
        xK = ((N - 1.0) * xPre
              + (double)A / pow(xPre, N - 1))
             / (double)N;
  
        delX = abs(xK - xPre);
        xPre = xK;
    }
  
    return xK;
}
  
// Function to check
// whether its k root
// is an integer or not
bool check(ll no, int k)
{
    double kth_root = nthRoot(no, k);
    ll num = kth_root;
  
    if (abs(num - kth_root) < 1e-4)
        return true;
  
    return false;
}
  
// Function to find the numbers
void printExpo(ll arr[], int n, int k)
{
    for (int i = 0; i < n; i++) {
        if (check(arr[i], k))
            cout << arr[i] << " ";
    }
}
  
// Driver code
int main()
{
  
    int K = 6;
  
    ll arr[] = { 46656, 64, 256,
                 729, 16, 1000 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    printExpo(arr, n, K);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to print elements of
// the Array which can be expressed as
// power of some integer to given exponent K
  
class GFG{
   
// Method returns Nth power of A
static double nthRoot(long A, long N)
{
   
    double xPre = 7;
   
    // Smaller eps, denotes more accuracy
    double eps = 1e-3;
   
    // Initializing difference between two
    // roots by Integer.MAX_VALUE
    double delX = Integer.MAX_VALUE;
   
    // x^K denotes current value of x
    double xK = 0;
   
    // loop untill we reach desired accuracy
    while (delX > eps) {
   
        // calculating current value from previous
        // value by newton's method
        xK = ((N - 1.0) * xPre
              + (double)A / Math.pow(xPre, N - 1))
             / (double)N;
   
        delX = Math.abs(xK - xPre);
        xPre = xK;
    }
   
    return xK;
}
   
// Function to check
// whether its k root
// is an integer or not
static boolean check(long no, int k)
{
    double kth_root = nthRoot(no, k);
    long num = (long) kth_root;
   
    if (Math.abs(num - kth_root) < 1e-4)
        return true;
   
    return false;
}
   
// Function to find the numbers
static void printExpo(long arr[], int n, int k)
{
    for (int i = 0; i < n; i++) {
        if (check(arr[i], k))
            System.out.print(arr[i]+ " ");
    }
}
   
// Driver code
public static void main(String[] args)
{
   
    int K = 6;
   
    long arr[] = { 46656, 64, 256,
                 729, 16, 1000 };
    int n = arr.length;
   
    printExpo(arr, n, K);
   
}
}
  
// This code is contributed by sapnasingh4991

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to prelements of
# the Array which can be expressed as
# power of some integer to given exponent K
  
# Method returns Nth power of A
def nthRoot(A, N):
  
    xPre = 7
  
    # Smaller eps, denotes more accuracy
    eps = 1e-3
  
    # Initializing difference between two
    # roots by INT_MAX
    delX = 10**9
  
    # x^K denotes current value of x
    xK = 0
  
    # loop untiwe reach desired accuracy
    while (delX > eps):
  
        # calculating current value from previous
        # value by newton's method
        xK = ((N - 1.0) * xPre+ A /pow(xPre, N - 1))/ N
  
        delX = abs(xK - xPre)
        xPre = xK
  
    return xK
  
# Function to check
# whether its k root
# is an integer or not
def check(no, k):
    kth_root = nthRoot(no, k)
    num = int(kth_root)
  
    if (abs(num - kth_root) < 1e-4):
        return True
  
    return False
  
# Function to find the numbers
def printExpo(arr, n, k):
    for i in range(n):
        if (check(arr[i], k)):
            print(arr[i],end=" ")
  
# Driver code
if __name__ == '__main__':
  
    K = 6
  
    arr = [46656, 64, 256,729, 16, 1000]
    n = len(arr)
  
    printExpo(arr, n, K)
  
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to print elements of
// the Array which can be expressed as
// power of some integer to given exponent K
using System;
  
class GFG{
    
// Method returns Nth power of A
static double nthRoot(long A, long N)
{
    
    double xPre = 7;
    
    // Smaller eps, denotes more accuracy
    double eps = 1e-3;
    
    // Initializing difference between two
    // roots by int.MaxValue
    double delX = int.MaxValue;
    
    // x^K denotes current value of x
    double xK = 0;
    
    // loop untill we reach desired accuracy
    while (delX > eps) {
    
        // calculating current value from previous
        // value by newton's method
        xK = ((N - 1.0) * xPre
              + (double)A / Math.Pow(xPre, N - 1))
             / (double)N;
    
        delX = Math.Abs(xK - xPre);
        xPre = xK;
    }
    
    return xK;
}
    
// Function to check
// whether its k root
// is an integer or not
static bool check(long no, int k)
{
    double kth_root = nthRoot(no, k);
    long num = (long) kth_root;
    
    if (Math.Abs(num - kth_root) < 1e-4)
        return true;
    
    return false;
}
    
// Function to find the numbers
static void printExpo(long []arr, int n, int k)
{
    for (int i = 0; i < n; i++) {
        if (check(arr[i], k))
            Console.Write(arr[i]+ " ");
    }
}
    
// Driver code
public static void Main(String[] args)
{
    
    int K = 6;
    
    long []arr = { 46656, 64, 256,
                 729, 16, 1000 };
    int n = arr.Length;
    
    printExpo(arr, n, K);
    
}
}
  
// This code is contributed by Princi Singh

chevron_right


Output:

46656 64 729

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




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.