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

A Btech Computer Engineering undergraduate from Aligarh Muslim University

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.