Skip to content
Related Articles

Related Articles

Improve Article

Perfect Cube factors of a Number

  • Last Updated : 05 Apr, 2021
Geek Week

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 <bits/stdc++.h>
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




<script>
 
// Javascript program for the above approach
 
// Function that returns the count
// of factors that are perfect cube
function noOfFactors(N)
{
    if (N == 1)
        return 1;
 
    // To store the count of number
    // of times a prime number
    // divides N.
    let count = 0;
 
    // To store the number of factors
    // that are perfect cube
    let ans = 1;
 
    // Count number of 2's that divides N
    while (N % 2 == 0) {
        count++;
        N = parseInt(N / 2);
    }
 
    // Calculate ans according
    // to above formula
    ans *= (parseInt(count / 3) + 1);
 
    // Check for all the possible
    // numbers that can divide it
    for (let 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 = parseInt(N / i);
        }
 
        // Calculate ans according
        // to above formula
        ans *= (parseInt(count / 3) + 1);
    }
 
    // Return final count
    return ans;
}
 
// Driver Code
// Given number
let N = 216;
 
// Function Call
document.write(noOfFactors(N));
     
</script>
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
Recommended Articles
Page :