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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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_

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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_