Skip to content
Related Articles

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

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[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[MAX], arr2[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++) {
        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[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[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[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+=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[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++) {
        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
Previous
Minimum number of moves required to solve a Jigsaw Assembly Puzzle
Next

How to find duplicate elements in a Stream in Java
Recommended Articles
Page :
Find smallest perfect square number A such that N + A is also a perfect square number
02, May 20
Check if a number is a perfect square having all its digits as a perfect square
15, Sep 20
Perfect Square factors of a Number
25, Jul 20
Number of factors of very large number N modulo M where M is any prime number
31, Mar 20
Count numbers upto N which are both perfect square and perfect cube
17, Dec 18
Smallest N digit number whose sum of square of digits is a Perfect Square
22, Apr 20
Check if a number is perfect square without finding square root
01, Jan 19
Find all factors of a natural number | Set 1
08, Mar 16
Find number of factors of N when location of its two factors whose product is N is given
14, Aug 19
Maximum number of prime factors a number can have with exactly x factors
07, May 20
Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
22, Apr 19
Print all Perfect Numbers from an array whose sum of digits is also a Perfect Number
19, Feb 21
Check if a number exists having exactly N factors and K prime factors
10, May 20
Multiply large integers under large modulo
01, May 17
Sum of all natural numbers from L to R ( for large values of L and R )
09, Sep 19
Find minimum number to be divided to make a number a perfect square
19, Jan 17
Perfect Cube factors of a Number
25, Jul 20
Number of distinct prime factors of first n natural numbers
16, Jun 18
Square of large number represented as String
18, Jul 18
Array range queries to find the number of perfect square elements with updates
14, May 20
Find the Largest N digit perfect square number in Base B
19, May 20
Find the Next perfect square greater than a given number
21, Sep 18
Number of times the largest perfect square number can be subtracted from N
08, Apr 19
Previous perfect square and cube number smaller than number N
07, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
epistler_999
@epistler_999
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox