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

 `// C++ Program to implement ` `// the above approach ` `#include ` `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; ` `} `

## Java

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

## Python3

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

## C#

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

Output:

```4
```

Time Complexity: O(log(N))
Space Complexity: O(1) 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.