# Perfect Cube factors of a Number

Given an integer N, the task is to find the number of factors of N that are a perfect cube.

Examples:

Input: N = 27
Output: 2
Explanation :
There are 2 factors of 27 (1, 27) that are perfect cube

Input: N = 216
Output:
Explanation:
There are 4 factors of 216 (1, 8, 27, 216) that are perfect cube

Naive Approach: The naive idea is to find all possible factors of the given number N and count if each factor is a perfect cube or not. If yes then count this factor and check for the next factor.

Time Complexity: O(N)
Auxiliary Space: O(1)

Efficient Approach: The idea is to use mathematical observation to find a formula to calculate the number of factors that are a perfect cube. The number of factors for a number is given by:

Factors of N = (1 + a1)*(1 + a2)*(1 + a3)*..*(1 + an)
where a1, a2, a3, .., an are the count of distinct prime factors of N.

In a perfect cube, the count of distinct prime factors must be divisible by 3. Therefore, the count of factors that are a perfect cube is given by:

Factors of N that are perfect cube = (1 + a1/3)*(1 + a2/3)*…*(1 + an/3)
where a1, a2, a3, .., an are the count of distinct prime factors of N.

Illustration:

The factors of N = 216 are 2, 2, 2, 3, 3, 3.
Therefore, number of factors that are perfect cube are (1 + 3/3) * (1 + 3/3) = 4. The factors are 1, 8, 27, and 216.

Therefore, find the count of prime factors and apply the above formula to find the count of factors that are a perfect cube.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function that returns the count ` `// of factors that are perfect cube ` `int` `noOfFactors(``int` `N) ` `{ ` `    ``if` `(N == 1) ` `        ``return` `1; ` ` `  `    ``// To store the count of number ` `    ``// of times a prime number ` `    ``// divides N. ` `    ``int` `count = 0; ` ` `  `    ``// To store the number of factors ` `    ``// that are perfect cube ` `    ``int` `ans = 1; ` ` `  `    ``// Count number of 2's that divides N ` `    ``while` `(N % 2 == 0) { ` `        ``count++; ` `        ``N = N / 2; ` `    ``} ` ` `  `    ``// Calculate ans according ` `    ``// to above formula ` `    ``ans *= (count / 3 + 1); ` ` `  `    ``// Check for all the possible ` `    ``// numbers that can divide it ` `    ``for` `(``int` `i = 3; i * i <= N; i = i + 2) { ` `        ``count = 0; ` ` `  `        ``// Loop to check the number ` `        ``// of times prime number ` `        ``// i divides it ` `        ``while` `(N % i == 0) { ` `            ``count++; ` `            ``N = N / i; ` `        ``} ` ` `  `        ``// Calculate ans according ` `        ``// to above formula ` `        ``ans *= (count / 3 + 1); ` `    ``} ` ` `  `    ``// Return final count ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given number ` `    ``int` `N = 216; ` ` `  `    ``// Function Call ` `    ``cout << noOfFactors(N); ` `    ``return` `0; ` `}`

## Java

 `// Java program for the above approach  ` `class` `GFG{  ` ` `  `// Function that returns the count  ` `// of factors that are perfect cube  ` `static` `int` `noOfFactors(``int` `N)  ` `{  ` `    ``if` `(N == ``1``)  ` `        ``return` `1``;  ` ` `  `    ``// To store the count of number  ` `    ``// of times a prime number  ` `    ``// divides N.  ` `    ``int` `count = ``0``;  ` ` `  `    ``// To store the number of factors  ` `    ``// that are perfect cube  ` `    ``int` `ans = ``1``;  ` ` `  `    ``// Count number of 2's that divides N  ` `    ``while` `(N % ``2` `== ``0``) ` `    ``{  ` `        ``count++;  ` `        ``N = N / ``2``;  ` `    ``}  ` ` `  `    ``// Calculate ans according  ` `    ``// to above formula  ` `    ``ans *= (count / ``3` `+ ``1``);  ` ` `  `    ``// Check for all the possible  ` `    ``// numbers that can divide it  ` `    ``for``(``int` `i = ``3``; i * i <= N; i = i + ``2``)  ` `    ``{  ` `        ``count = ``0``;  ` ` `  `        ``// Loop to check the number  ` `        ``// of times prime number  ` `        ``// i divides it  ` `        ``while` `(N % i == ``0``) ` `        ``{  ` `            ``count++;  ` `            ``N = N / i;  ` `        ``}  ` ` `  `        ``// Calculate ans according  ` `        ``// to above formula  ` `        ``ans *= (count / ``3` `+ ``1``);  ` `    ``}  ` ` `  `    ``// Return final count  ` `    ``return` `ans;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `     `  `    ``// Given number  ` `    ``int` `N = ``216``;  ` ` `  `    ``// Function call  ` `    ``System.out.print(noOfFactors(N));  ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 program for the above approach ` ` `  `# Function that returns the count  ` `# of factors that are perfect cube ` `def` `noofFactors(N): ` `     `  `    ``if` `N ``=``=` `1``: ` `        ``return` `1` `         `  `    ``# To store the count of number  ` `    ``# of times a prime number ` `    ``# divides N ` `    ``count ``=` `0` ` `  `    ``# To store the count of factors that ` `    ``# are perfect cube ` `    ``ans ``=` `1` ` `  `    ``# Count number of 2's that divides N ` `    ``while``(N ``%` `2` `=``=` `0``): ` `        ``count ``+``=` `1` `        ``N ``/``/``=` `2` ` `  `    ``# Calculate ans according  ` `    ``# to above formula ` `    ``ans ``*``=` `((count ``/``/` `3``) ``+` `1``) ` ` `  `    ``# Check for all possible ` `    ``# numbers that can divide it ` `    ``i ``=` `3` `    ``while``((i ``*` `i) <``=` `N): ` `        ``count ``=` `0` ` `  `        ``# Loop to check the number ` `        ``# of times prime number  ` `        ``# i divides it ` `        ``while``(N ``%` `i ``=``=` `0``): ` `            ``count ``+``=` `1` `            ``N ``/``/``=` `i ` `         `  `        ``# Calculate ans according  ` `        ``# to above formula ` `        ``ans ``*``=` `((count ``/``/` `3``) ``+` `1``) ` `        ``i ``+``=` `2` `         `  `    ``return` `ans ` ` `  `# Driver Code ` ` `  `# Given number ` `N ``=` `216` ` `  `# Function call ` `print``(noofFactors(N)) ` `     `  `# This code is contributed by VirusBuddah_ `

## C#

 `// C# program for the above approach  ` `using` `System; ` ` `  `class` `GFG{  ` ` `  `// Function that returns the count  ` `// of factors that are perfect cube  ` `static` `int` `noOfFactors(``int` `N)  ` `{  ` `    ``if` `(N == 1)  ` `        ``return` `1;  ` ` `  `    ``// To store the count of number  ` `    ``// of times a prime number  ` `    ``// divides N.  ` `    ``int` `count = 0;  ` ` `  `    ``// To store the number of factors  ` `    ``// that are perfect cube  ` `    ``int` `ans = 1;  ` ` `  `    ``// Count number of 2's that divides N  ` `    ``while` `(N % 2 == 0) ` `    ``{  ` `        ``count++;  ` `        ``N = N / 2;  ` `    ``}  ` ` `  `    ``// Calculate ans according  ` `    ``// to above formula  ` `    ``ans *= (count / 3 + 1);  ` ` `  `    ``// Check for all the possible  ` `    ``// numbers that can divide it  ` `    ``for``(``int` `i = 3; i * i <= N; i = i + 2)  ` `    ``{  ` `        ``count = 0;  ` ` `  `        ``// Loop to check the number  ` `        ``// of times prime number  ` `        ``// i divides it  ` `        ``while` `(N % i == 0) ` `        ``{  ` `            ``count++;  ` `            ``N = N / i;  ` `        ``}  ` ` `  `        ``// Calculate ans according  ` `        ``// to above formula  ` `        ``ans *= (count / 3 + 1);  ` `    ``}  ` ` `  `    ``// Return final count  ` `    ``return` `ans;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String[] args)  ` `{  ` `     `  `    ``// Given number  ` `    ``int` `N = 216;  ` ` `  `    ``// Function call  ` `    ``Console.Write(noOfFactors(N));  ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```4
```

Time Complexity: O(log(N))
Auxiliary Space: O(1)

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.

Improved By : Rajput-Ji, VirusBuddah_

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.