Related Articles

# Perfect Cube factors of a Number

• Last Updated : 05 Apr, 2021

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`

## Javascript

 ``
Output:
`4`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up