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 cubeInput: N = 216
Output: 4
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++ 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 program for the above approach import java.io.*;
public 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 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# 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 |
<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> |
4
Time Complexity: O(log(N))
Auxiliary Space: O(1)