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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















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



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















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



















                        chevron_right







                        filter_none











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


GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details 





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
epistler_999
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.