Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Last Updated : 22 Sep, 2022
Improve Article
Save Article

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




// 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 until 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;
}

Java




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

Python3




# Python3 implementation to print elements 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 until we 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

C#




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

Javascript




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

Output: 

46656 64 729

 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!