Related Articles
Find all Factors of Large Perfect Square Natural Number in O(sqrt(sqrt(N))
• Difficulty Level : Medium
• Last Updated : 30 Apr, 2020

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

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up