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


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.





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
epistler_999
Practice until my ideals becomes my rivals
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.