Perfect Square factors of a Number

Given an integer N, the task is to find the number of factors of N which are perfect square.
Examples: 

Input: N = 100 
Output:
Explanation: 
There are four factors of 
100 (1, 4, 25, 100) that are perfect square.

Input: N = 900 
Output:
Explanation: 
There are eight factors of 900 (1, 4, 9, 25, 36, 100, 225, 900) that are perfect square. 
 

Naive Approach: The simplest approach to solve this problem is to find all possible factors of the given number N and for each factor, check if the factor is a perfect square or not. For every factor found to be so, increase count. Print the final count
Time Complexity: O(N) 
Auxiliary Space: O(1)

Efficient Approach: 
The following observations need to be made to optimize the above approach:
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 square, the count of distinct prime factors must be divisible by 2. Therefore, the count of factors that are a perfect square is given by:

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

Illustration: 

The prime factors of N = 100 are 2, 2, 5, 5. 
Therefore, the number of factors that are perfect square are (1 + 2/2) * (1 + 2/2) = 4. 
The factors are 1, 4, 25, 100. 

Therefore, find the count of prime factors and apply the above formula to find the count of factors that are a perfect square.
Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function that returns the count of
// factors that are perfect squares
int noOfFactors(int N)
{
    if (N == 1)
        return 1;
  
    // Stores the count of number
    // of times a prime number
    // divides N.
    int count = 0;
  
    // Stores the number of factors
    // that are perfect square
    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 / 2 + 1);
  
    // Check for all the possible
    // numbers that can divide it
    for (int i = 3;
         i * i <= N; i = i + 2) {
        count = 0;
  
        // 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 / 2 + 1);
    }
  
    // Return final count
    return ans;
}
  
// Driver Code
int main()
{
    int N = 100;
  
    cout << noOfFactors(N);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
  
class GFG{
  
// Function that returns the count of
// factors that are perfect squares
static int noOfFactors(int N)
{
    if (N == 1)
        return 1;
  
    // Stores the count of number
    // of times a prime number
    // divides N.
    int count = 0;
  
    // Stores the number of factors
    // that are perfect square
    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 / 2 + 1);
  
    // Check for all the possible
    // numbers that can divide it
    for(int i = 3; i * i <= N; i = i + 2
    {
        count = 0;
  
        // 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 / 2 + 1);
    }
  
    // Return final count
    return ans;
}
  
// Driver Code
public static void main(String[] args)
{
    int N = 100;
  
    System.out.print(noOfFactors(N));
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
  
# Function that returns the count of
# factors that are perfect squares
def noOfFactors(N):
  
    if (N == 1):
        return 1
  
    # Stores the count of number
    # of times a prime number
    # divides N.
    count = 0
  
    # Stores the number of factors
    # that are perfect square
    ans = 1
  
    # Count number of 2's
    # that divides N
    while (N % 2 == 0):
        count += 1
        N = N // 2
  
    # Calculate ans according
    # to above formula
    ans *= (count // 2 + 1)
  
    # Check for all the possible
    # numbers that can divide it
    i = 3
    while i * i <= N:
        count = 0
  
        # Check the number of
        # times prime number
        # i divides it
        while (N % i == 0):
            count += 1
            N = N // i
  
        # Calculate ans according
        # to above formula
        ans *= (count // 2 + 1)
        i += 2
      
    # Return final count
    return ans
  
# Driver Code
if __name__ == "__main__":
      
    N = 100
  
    print(noOfFactors(N))
  
# This code is contributed by chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
  
class GFG{
  
// Function that returns the count of
// factors that are perfect squares
static int noOfFactors(int N)
{
    if (N == 1)
        return 1;
  
    // Stores the count of number
    // of times a prime number
    // divides N.
    int count = 0;
  
    // Stores the number of factors
    // that are perfect square
    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 / 2 + 1);
  
    // Check for all the possible
    // numbers that can divide it
    for(int i = 3; i * i <= N; i = i + 2) 
    {
        count = 0;
  
        // 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 / 2 + 1);
    }
  
    // Return final count
    return ans;
}
  
// Driver Code
public static void Main(String[] args)
{
    int N = 100;
  
    Console.Write(noOfFactors(N));
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Output: 

4

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

competitive-programming-img




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.