# Find all Factors of Large Perfect Square Natural Number in O(sqrt(sqrt(N))

Given a perfect square natural number N. The task is to find all the factors of N.

Examples

Input: N = 100
Output: 1 2 4 5 10 20 25 50 100

Input: N = 900
Output: 1 2 4 3 6 12 9 18 36 5 10 20 15 30 60 45 90 180 25 50 100 75 150 300 225 450 900

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Find the square root of N in temp.
2. Find all the prime factors of temp in O(sqrt(temp)) using the approach discussed in this article.
3. Initialise an array factor[] with element 1 in it.
4. Store all the prime factors of temp obtained in above step twice in an array factor[].
5. Initialise a matrix M such that for every element in factor[] starting from index 1:
• If factor[i] is equals to factor[i-1], then store factor[i]*factor[i-1] in matrix M in row i – 1 .
• Else factor[i] is not equals to factor[i-1], then store factor[i]*factor[i-1] in matrix M in row i.
6. Initialise two arrays arr1[] and arr2[] with the element 1 in both the array.
7. Iterate over every row of matrix M such that the product of every element in arr1[] with every element of current row must be stored in arr2[].
8. After above step, copy every element of arr2[] in arr1[].
9. Repeat above two steps, till all the element of matrixM is traverse.
10. The array arr2[] contains all the factors of number N.

Below is the implementation of the above approach:

## CPP

 `// C++ program to find the factors ` `// of large perfect square number ` `// in O(sqrt(sqrt(N))) time ` `#include "bits/stdc++.h" ` `using` `namespace` `std; ` ` `  `int` `MAX = 100000; ` ` `  `// Function that find all the prime ` `// factors of N ` `void` `findFactors(``int` `N) ` `{ ` `    ``// Store the sqrt(N) in temp ` `    ``int` `temp = ``sqrt``(N); ` ` `  `    ``// Initialise factor array with ` `    ``// 1 as a factor in it ` `    ``int` `factor[MAX] = { 1 }; ` `    ``int` `i, j, k; ` `    ``int` `len1 = 1; ` ` `  `    ``// Check divisibility by 2 ` `    ``while` `(temp % 2 == 0) { ` ` `  `        ``// Store the factors twice ` `        ``factor[len1++] = 2; ` `        ``factor[len1++] = 2; ` ` `  `        ``temp /= 2; ` `    ``} ` ` `  `    ``// Check for other prime ` `    ``// factors other than 2 ` `    ``for` `(j = 3; j < ``sqrt``(temp); j += 2) { ` ` `  `        ``// If j is a prime factor ` `        ``while` `(temp % j == 0) { ` ` `  `            ``// Store the prime ` `            ``// factor twice ` `            ``factor[len1++] = j; ` `            ``factor[len1++] = j; ` `            ``temp /= j; ` `        ``} ` `    ``} ` ` `  `    ``// If j is prime number left ` `    ``// other than 2 ` `    ``if` `(temp > 2) { ` ` `  `        ``// Store j twice ` `        ``factor[len1++] = temp; ` `        ``factor[len1++] = temp; ` `    ``} ` ` `  `    ``// Intialise Matrix M to ` `    ``// to store all the factors ` `    ``int` `M[len1][MAX] = { 0 }; ` ` `  `    ``// tpc for rows ` `    ``// tpr for column ` `    ``int` `tpc = 0, tpr = 0; ` ` `  `    ``// Initialise M = 1 as ` `    ``// it also factor of N ` `    ``M = 1; ` `    ``j = 1; ` ` `  `    ``// Traversing factor array ` `    ``while` `(j < len1) { ` ` `  `        ``// If current and previous ` `        ``// factors are not same then ` `        ``// move to next row and ` `        ``// insert the current factor ` `        ``if` `(factor[j] != factor[j - 1]) { ` `            ``tpr++; ` `            ``M[tpr] = factor[j]; ` `            ``j++; ` `            ``tpc = 1; ` `        ``} ` ` `  `        ``// If current and previous ` `        ``// factors are same then, ` `        ``// Insert the factor with ` `        ``// previous factor inserted ` `        ``// in matrix M ` `        ``else` `{ ` `            ``M[tpr][tpc] ` `                ``= M[tpr][tpc - 1] * factor[j]; ` `            ``j++; ` `            ``tpc++; ` `        ``} ` `    ``} ` ` `  `    ``// The arr1[] and arr2[] used to ` `    ``// store all the factors of N ` `    ``int` `arr1[MAX], arr2[MAX]; ` `    ``int` `l1, l2; ` `    ``l1 = l2 = 1; ` ` `  `    ``// Initialise arrays as 1 ` `    ``arr1 = arr2 = 1; ` ` `  `    ``// Traversing the matrix M ` `    ``for` `(i = 1; i < tpr + 1; i++) { ` ` `  `        ``// Traversing till column ` `        ``// element doesn't become 0 ` `        ``for` `(j = 0; M[i][j] != 0; j++) { ` ` `  `            ``// Store the product of ` `            ``// every element of current ` `            ``// row with every element ` `            ``// in arr1[] ` `            ``for` `(k = 0; k < l1; k++) { ` `                ``arr2[l2++] ` `                    ``= arr1[k] * M[i][j]; ` `            ``} ` `        ``} ` ` `  `        ``// Copying every element of ` `        ``// arr2[] in arr1[] ` `        ``for` `(j = l1; j < l2; j++) { ` `            ``arr1[j] = arr2[j]; ` `        ``} ` ` `  `        ``// length of arr2[] and arr1[] ` `        ``// are equal after copying ` `        ``l1 = l2; ` `    ``} ` ` `  `    ``// Print all the factors ` `    ``for` `(i = 0; i < l2; i++) { ` `        ``cout << arr2[i] << ``' '``; ` `    ``} ` `} ` ` `  `// Drivers Code ` `int` `main() ` `{ ` `    ``int` `N = 900; ` `    ``findFactors(N); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the factors ` `// of large perfect square number ` `// in O(Math.sqrt(Math.sqrt(N))) time ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `  `  `static` `int` `MAX = ``100000``; ` `  `  `// Function that find all the prime ` `// factors of N ` `static` `void` `findFactors(``int` `N) ` `{ ` `    ``// Store the Math.sqrt(N) in temp ` `    ``int` `temp = (``int``) Math.sqrt(N); ` `  `  `    ``// Initialise factor array with ` `    ``// 1 as a factor in it ` `    ``int` `[]factor = ``new` `int``[MAX]; ` `    ``Arrays.fill(factor, ``1``); ` `    ``int` `i, j, k; ` `    ``int` `len1 = ``1``; ` `  `  `    ``// Check divisibility by 2 ` `    ``while` `(temp % ``2` `== ``0``) { ` `  `  `        ``// Store the factors twice ` `        ``factor[len1++] = ``2``; ` `        ``factor[len1++] = ``2``; ` `  `  `        ``temp /= ``2``; ` `    ``} ` `  `  `    ``// Check for other prime ` `    ``// factors other than 2 ` `    ``for` `(j = ``3``; j < Math.sqrt(temp); j += ``2``) { ` `  `  `        ``// If j is a prime factor ` `        ``while` `(temp % j == ``0``) { ` `  `  `            ``// Store the prime ` `            ``// factor twice ` `            ``factor[len1++] = j; ` `            ``factor[len1++] = j; ` `            ``temp /= j; ` `        ``} ` `    ``} ` `  `  `    ``// If j is prime number left ` `    ``// other than 2 ` `    ``if` `(temp > ``2``) { ` `  `  `        ``// Store j twice ` `        ``factor[len1++] = temp; ` `        ``factor[len1++] = temp; ` `    ``} ` `  `  `    ``// Intialise Matrix M to ` `    ``// to store all the factors ` `    ``int` `[][]M = ``new` `int``[len1][MAX]; ` `  `  `    ``// tpc for rows ` `    ``// tpr for column ` `    ``int` `tpc = ``0``, tpr = ``0``; ` `  `  `    ``// Initialise M = 1 as ` `    ``// it also factor of N ` `    ``M[``0``][``0``] = ``1``; ` `    ``j = ``1``; ` `  `  `    ``// Traversing factor array ` `    ``while` `(j < len1) { ` `  `  `        ``// If current and previous ` `        ``// factors are not same then ` `        ``// move to next row and ` `        ``// insert the current factor ` `        ``if` `(factor[j] != factor[j - ``1``]) { ` `            ``tpr++; ` `            ``M[tpr][``0``] = factor[j]; ` `            ``j++; ` `            ``tpc = ``1``; ` `        ``} ` `  `  `        ``// If current and previous ` `        ``// factors are same then, ` `        ``// Insert the factor with ` `        ``// previous factor inserted ` `        ``// in matrix M ` `        ``else` `{ ` `            ``M[tpr][tpc] ` `                ``= M[tpr][tpc - ``1``] * factor[j]; ` `            ``j++; ` `            ``tpc++; ` `        ``} ` `    ``} ` `  `  `    ``// The arr1[] and arr2[] used to ` `    ``// store all the factors of N ` `    ``int` `[]arr1 = ``new` `int``[MAX]; ` `    ``int` `[]arr2 = ``new` `int``[MAX]; ` `    ``int` `l1, l2; ` `    ``l1 = l2 = ``1``; ` `  `  `    ``// Initialise arrays as 1 ` `    ``arr1[``0``] = arr2[``0``] = ``1``; ` `  `  `    ``// Traversing the matrix M ` `    ``for` `(i = ``1``; i < tpr + ``1``; i++) { ` `  `  `        ``// Traversing till column ` `        ``// element doesn't become 0 ` `        ``for` `(j = ``0``; M[i][j] != ``0``; j++) { ` `  `  `            ``// Store the product of ` `            ``// every element of current ` `            ``// row with every element ` `            ``// in arr1[] ` `            ``for` `(k = ``0``; k < l1; k++) { ` `                ``arr2[l2++] ` `                    ``= arr1[k] * M[i][j]; ` `            ``} ` `        ``} ` `  `  `        ``// Copying every element of ` `        ``// arr2[] in arr1[] ` `        ``for` `(j = l1; j < l2; j++) { ` `            ``arr1[j] = arr2[j]; ` `        ``} ` `  `  `        ``// length of arr2[] and arr1[] ` `        ``// are equal after copying ` `        ``l1 = l2; ` `    ``} ` `  `  `    ``// Print all the factors ` `    ``for` `(i = ``0``; i < l2; i++) { ` `        ``System.out.print(arr2[i] + ``" "``); ` `    ``} ` `} ` `  `  `// Drivers Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``900``; ` `    ``findFactors(N); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## Python3

 `# Python 3 program to find the factors ` `# of large perfect square number ` `# in O(sqrt(sqrt(N))) time ` `  `  `import` `math ` ` `  `MAX` `=` `100000` `  `  `# Function that find all the prime ` `# factors of N ` `def` `findFactors( N): ` ` `  `    ``# Store the sqrt(N) in temp ` `    ``temp ``=` `int``(math.sqrt(N)) ` `  `  `    ``# Initialise factor array with ` `    ``# 1 as a factor in it ` `    ``factor ``=` `[``1``]``*``MAX` `    ``len1 ``=` `1` `  `  `    ``# Check divisibility by 2 ` `    ``while` `(temp ``%` `2` `=``=` `0``) : ` `  `  `        ``# Store the factors twice ` `        ``factor[len1] ``=` `2` `        ``len1 ``+``=` `1` `        ``factor[len1] ``=` `2` `        ``len1 ``+``=` `1` `        ``temp ``/``/``=` `2` `       `  `    ``# Check for other prime ` `    ``# factors other than 2 ` `    ``sqt ``=` `math.sqrt(temp) ` `    `  `    ``for` `j ``in` `range``(``3``, math.ceil(sqt), ``2``): ` `  `  `        ``# If j is a prime factor ` `        ``while` `(temp ``%` `j ``=``=` `0``): ` `  `  `            ``# Store the prime ` `            ``# factor twice ` `            ``factor[len1] ``=` `j ` `            ``len1 ``+``=` `1` `            ``factor[len1] ``=` `j ` `            ``len1 ``+``=` `1` `            ``temp ``/``/``=` `j ` `  `  `    ``# If j is prime number left ` `    ``# other than 2 ` `    ``if` `(temp > ``2``) : ` `  `  `        ``# Store j twice ` `        ``factor[len1] ``=` `temp ` `        ``len1 ``+``=` `1` `        ``factor[len1] ``=` `temp ` `        ``len1 ``+``=` `1` `     `  `    ``# Intialise Matrix M to ` `    ``# to store all the factors ` `    ``M ``=` `[ [ ``0` `for` `x ``in` `range``(``MAX``)] ``for` `y ``in` `range``(len1)] ` `  `  `    ``# tpc for rows ` `    ``# tpr for column ` `    ``tpc , tpr ``=` `0` `, ``0` `  `  `    ``# Initialise M = 1 as ` `    ``# it also factor of N ` `    ``M[``0``][``0``] ``=` `1` `    ``j ``=` `1` `  `  `    ``# Traversing factor array ` `    ``while` `(j < len1): ` `  `  `        ``# If current and previous ` `        ``# factors are not same then ` `        ``# move to next row and ` `        ``# insert the current factor ` `        ``if` `(factor[j] !``=` `factor[j ``-` `1``]): ` `            ``tpr``+``=``1` `            ``M[tpr][``0``] ``=` `factor[j] ` `            ``j ``+``=` `1` `            ``tpc ``=` `1` `         `  `        ``# If current and previous ` `        ``# factors are same then, ` `        ``# Insert the factor with ` `        ``# previous factor inserted ` `        ``# in matrix M ` `        ``else` `: ` `            ``M[tpr][tpc]``=` `M[tpr][tpc ``-` `1``] ``*` `factor[j] ` `            ``j ``+``=` `1` `            ``tpc ``+``=` `1` `  `  `    ``# The arr1[] and arr2[] used to ` `    ``# store all the factors of N ` `    ``arr1 ``=` `[``0``]``*``MAX` `    ``arr2 ``=` `[``0``]``*``MAX` `    ``l1 ``=` `l2 ``=` `1` `  `  `    ``# Initialise arrays as 1 ` `    ``arr1[``0``] ``=` `1` `    ``arr2[``0``] ``=` `1` `  `  `    ``# Traversing the matrix M ` `    ``# print("tpr ",tpr) ` `    ``for` `i ``in` `range``(``1` `, tpr ``+` `1``) : ` `  `  `        ``# Traversing till column ` `        ``# element doesn't become 0 ` `        ``j ``=` `0` `        ``while` `M[i][j] !``=` `0``: ` `  `  `            ``# Store the product of ` `            ``# every element of current ` `            ``# row with every element ` `            ``# in arr1[] ` `            ``for` `k ``in` `range``(l1): ` `                ``arr2[l2]``=` `arr1[k] ``*` `M[i][j] ` `                ``l2 ``+``=` `1` `                     `  `            ``j ``+``=` `1` `  `  `        ``# Copying every element of ` `        ``# arr2[] in arr1[] ` `        ``for` `j ``in` `range``(l1, l2): ` `            ``arr1[j] ``=` `arr2[j] ` `  `  `        ``# length of arr2[] and arr1[] ` `        ``# are equal after copying ` `        ``l1 ``=` `l2 ` `         `  `    ``# Print all the factors ` `    ``for` `i ``in` `range``(l2): ` `        ``print``(arr2[i] ,end``=` `" "``) ` `  `  `# Drivers Code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``N ``=` `900` `    ``findFactors(N) ` `     `  `# This code is contributed by chitranayal `

## C#

 `// C# program to find the factors ` `// of large perfect square number ` `// in O(Math.Sqrt(Math.Sqrt(N))) time ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `static` `int` `MAX = 100000; ` ` `  `// Function that find all the prime ` `// factors of N ` `static` `void` `findFactors(``int` `N) ` `{ ` `    ``// Store the Math.Sqrt(N) in temp ` `    ``int` `temp = (``int``) Math.Sqrt(N); ` ` `  `    ``// Initialise factor array with ` `    ``// 1 as a factor in it ` `    ``int` `[]factor = ``new` `int``[MAX]; ` `    ``for``(``int` `l= 0; l < MAX; l++) ` `        ``factor[l] = 1; ` `    ``int` `i, j, k; ` `    ``int` `len1 = 1; ` ` `  `    ``// Check divisibility by 2 ` `    ``while` `(temp % 2 == 0) { ` ` `  `        ``// Store the factors twice ` `        ``factor[len1++] = 2; ` `        ``factor[len1++] = 2; ` ` `  `        ``temp /= 2; ` `    ``} ` ` `  `    ``// Check for other prime ` `    ``// factors other than 2 ` `    ``for` `(j = 3; j < Math.Sqrt(temp); j += 2) { ` ` `  `        ``// If j is a prime factor ` `        ``while` `(temp % j == 0) { ` ` `  `            ``// Store the prime ` `            ``// factor twice ` `            ``factor[len1++] = j; ` `            ``factor[len1++] = j; ` `            ``temp /= j; ` `        ``} ` `    ``} ` ` `  `    ``// If j is prime number left ` `    ``// other than 2 ` `    ``if` `(temp > 2) { ` ` `  `        ``// Store j twice ` `        ``factor[len1++] = temp; ` `        ``factor[len1++] = temp; ` `    ``} ` ` `  `    ``// Intialise Matrix M to ` `    ``// to store all the factors ` `    ``int` `[,]M = ``new` `int``[len1, MAX]; ` ` `  `    ``// tpc for rows ` `    ``// tpr for column ` `    ``int` `tpc = 0, tpr = 0; ` ` `  `    ``// Initialise M[0,0] = 1 as ` `    ``// it also factor of N ` `    ``M[0, 0] = 1; ` `    ``j = 1; ` ` `  `    ``// Traversing factor array ` `    ``while` `(j < len1) { ` ` `  `        ``// If current and previous ` `        ``// factors are not same then ` `        ``// move to next row and ` `        ``// insert the current factor ` `        ``if` `(factor[j] != factor[j - 1]) { ` `            ``tpr++; ` `            ``M[tpr, 0] = factor[j]; ` `            ``j++; ` `            ``tpc = 1; ` `        ``} ` ` `  `        ``// If current and previous ` `        ``// factors are same then, ` `        ``// Insert the factor with ` `        ``// previous factor inserted ` `        ``// in matrix M ` `        ``else` `{ ` `            ``M[tpr,tpc] ` `                ``= M[tpr,tpc - 1] * factor[j]; ` `            ``j++; ` `            ``tpc++; ` `        ``} ` `    ``} ` ` `  `    ``// The arr1[] and arr2[] used to ` `    ``// store all the factors of N ` `    ``int` `[]arr1 = ``new` `int``[MAX]; ` `    ``int` `[]arr2 = ``new` `int``[MAX]; ` `    ``int` `l1, l2; ` `    ``l1 = l2 = 1; ` ` `  `    ``// Initialise arrays as 1 ` `    ``arr1 = arr2 = 1; ` ` `  `    ``// Traversing the matrix M ` `    ``for` `(i = 1; i < tpr + 1; i++) { ` ` `  `        ``// Traversing till column ` `        ``// element doesn't become 0 ` `        ``for` `(j = 0; M[i, j] != 0; j++) { ` ` `  `            ``// Store the product of ` `            ``// every element of current ` `            ``// row with every element ` `            ``// in arr1[] ` `            ``for` `(k = 0; k < l1; k++) { ` `                ``arr2[l2++] ` `                    ``= arr1[k] * M[i, j]; ` `            ``} ` `        ``} ` ` `  `        ``// Copying every element of ` `        ``// arr2[] in arr1[] ` `        ``for` `(j = l1; j < l2; j++) { ` `            ``arr1[j] = arr2[j]; ` `        ``} ` ` `  `        ``// length of arr2[] and arr1[] ` `        ``// are equal after copying ` `        ``l1 = l2; ` `    ``} ` ` `  `    ``// Print all the factors ` `    ``for` `(i = 0; i < l2; i++) { ` `        ``Console.Write(arr2[i] + ``" "``); ` `    ``} ` `} ` ` `  `// Drivers Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `N = 900; ` `    ``findFactors(N); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

Output:

```1 2 4 3 6 12 9 18 36 5 10 20 15 30 60 45 90 180 25 50 100 75 150 300 225 450 900
```

Time Complexity: O(sqrt(sqrt(N)))

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

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.