Perfect power (1, 4, 8, 9, 16, 25, 27, ...)

Given a positive integer n, the task is to find the count of perfect powers from 1 to n.

Note: A perfect power is a number that can be expressed as a power of another positive integer i.e. it can be expressed as x^y where x >= 1 and y > 1

Examples :

Input: n = 10
Output: 4
Explanation: 1, 4, 8, and 9 are the numbers that are of the form x ^ y where x > 0 and y > 1.
Input: n = 50
Output: 10
Explanation: 1, 4, 8, 9, 16, 25, 27, 32, 36, 49 are the numbers that are of the form x ^ y where x > 0 and y > 1.

[Naive Approach] - O(n log n) Time and O(n) Space

The idea is to iterate through all integers from 1 to square root n and find all possible perfect powers. To find the perfect powers, run a loop starting from i * i, multiplied by i in each iteration until the value is not greater than n.

Below is given the implementation:

C++

// CPP program to find count of
// perfect power from 1 to n
#include <bits/stdc++.h>
using namespace std;

// Function to find count of perfect power
int perfectPowers(int n) {

    // to store all unique power numbers
    set<int> res;
    res.insert(1);

    for (int i = 2; i * i <= n; i++) {
        for(int j = i * i; j <= n; j *= i) {
            res.insert(j);
        }
    }

    return res.size();
}

int main() {
    int n = 50;
    cout << perfectPowers(n);
    return 0;
}

Java

// Java program to find count of
// perfect power from 1 to n
import java.util.*;

class GfG {

    // Function to find count of perfect power
    static int perfectPowers(int n) {

        // to store all unique power numbers
        Set<Integer> res = new HashSet<>();
        res.add(1);

        for (int i = 2; i * i <= n; i++) {
            for (int j = i * i; j <= n; j *= i) {
                res.add(j);
            }
        }

        return res.size();
    }

    public static void main(String[] args) {
        int n = 50;
        System.out.println(perfectPowers(n));
    }
}

Python

# Python program to find count of
# perfect power from 1 to n

# Function to find count of perfect power
def perfectPowers(n):

    # to store all unique power numbers
    res = {1}

    for i in range(2, int(n**0.5) + 1):
        j = i * i
        while j <= n:
            res.add(j)
            j *= i

    return len(res)

# Driver code
if __name__ == "__main__":
    n = 50
    print(perfectPowers(n))

// C# program to find count of
// perfect power from 1 to n
using System;
using System.Collections.Generic;

class GfG {

    // Function to find count of perfect power
    static int perfectPowers(int n) {

        // to store all unique power numbers
        HashSet<int> res = new HashSet<int>();
        res.Add(1);

        for (int i = 2; i * i <= n; i++) {
            for (int j = i * i; j <= n; j *= i) {
                res.Add(j);
            }
        }

        return res.Count;
    }

    static void Main(string[] args) {
        int n = 50;
        Console.WriteLine(perfectPowers(n));
    }
}

JavaScript

// JavaScript program to find count of
// perfect power from 1 to n

// Function to find count of perfect power
function perfectPowers(n) {

    // to store all unique power numbers
    let res = new Set();
    res.add(1);

    for (let i = 2; i * i <= n; i++) {
        for (let j = i * i; j <= n; j *= i) {
            res.add(j);
        }
    }

    return res.size;
}

// Driver code
let n = 50;
console.log(perfectPowers(n));

Output

Time Complexity: O(n log n)
Space Complexity: O(n)

[Expected Approach] - O(n log n) Time and O(n ^ (1/4)) Space

The idea is to separate the odd powers from even powers and calculate their numbers separately. For calculating all the even powers less than and equal to n, we only need the square root of n. Because, the count of even powers smaller than n is equal to the square root of n. For odd powers, the above approach can be used.