Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Generating all divisors of a number using its prime factorization

  • Last Updated : 31 May, 2021

Given an integer N, the task is to find all of its divisors using its prime factorization.

Examples: 

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 6 
Output: 1 2 3 6



Input: N = 10 
Output: 1 2 5 10

Approach: As every number greater than 1 can be represented in its prime factorization as p1a1*p2a2*……*pkak, where pi is a prime number, k ≥ 1 and ai is a positive integer. 
Now all the possible divisors can be generated recursively if the count of occurrence of every prime factor of n is known. For every prime factor pi, it can be included x times where 0 ≤ x ≤ ai. First, find the prime factorization of n using this approach and for every prime factor, store it with the count of its occurrence.
Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include "iostream"
#include "vector"
using namespace std;
 
struct primeFactorization {
 
    // to store the prime factor
    // and its highest power
    int countOfPf, primeFactor;
};
 
// Recursive function to generate all the
// divisors from the prime factors
void generateDivisors(int curIndex, int curDivisor,
                      vector<primeFactorization>& arr)
{
 
    // Base case i.e. we do not have more
    // primeFactors to include
    if (curIndex == arr.size()) {
        cout << curDivisor << ' ';
        return;
    }
 
    for (int i = 0; i <= arr[curIndex].countOfPf; ++i) {
        generateDivisors(curIndex + 1, curDivisor, arr);
        curDivisor *= arr[curIndex].primeFactor;
    }
}
 
// Function to find the divisors of n
void findDivisors(int n)
{
 
    // To store the prime factors along
    // with their highest power
    vector<primeFactorization> arr;
 
    // Finding prime factorization of n
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            int count = 0;
            while (n % i == 0) {
                n /= i;
                count += 1;
            }
 
            // For every prime factor we are storing
            // count of it's occurenceand itself.
            arr.push_back({ count, i });
        }
    }
 
    // If n is prime
    if (n > 1) {
        arr.push_back({ 1, n });
    }
 
    int curIndex = 0, curDivisor = 1;
 
    // Generate all the divisors
    generateDivisors(curIndex, curDivisor, arr);
}
 
// Driver code
int main()
{
    int n = 6;
 
    findDivisors(n);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
class GFG
{
 
static class primeFactorization
{
 
    // to store the prime factor
    // and its highest power
    int countOfPf, primeFactor;
 
    public primeFactorization(int countOfPf,
                              int primeFactor)
    {
        this.countOfPf = countOfPf;
        this.primeFactor = primeFactor;
    }
}
 
// Recursive function to generate all the
// divisors from the prime factors
static void generateDivisors(int curIndex, int curDivisor,
                           Vector<primeFactorization> arr)
{
 
    // Base case i.e. we do not have more
    // primeFactors to include
    if (curIndex == arr.size())
    {
        System.out.print(curDivisor + " ");
        return;
    }
 
    for (int i = 0; i <= arr.get(curIndex).countOfPf; ++i)
    {
        generateDivisors(curIndex + 1, curDivisor, arr);
        curDivisor *= arr.get(curIndex).primeFactor;
    }
}
 
// Function to find the divisors of n
static void findDivisors(int n)
{
 
    // To store the prime factors along
    // with their highest power
    Vector<primeFactorization> arr = new Vector<>();
 
    // Finding prime factorization of n
    for (int i = 2; i * i <= n; ++i)
    {
        if (n % i == 0)
        {
            int count = 0;
            while (n % i == 0)
            {
                n /= i;
                count += 1;
            }
 
            // For every prime factor we are storing
            // count of it's occurenceand itself.
            arr.add(new primeFactorization(count, i ));
        }
    }
 
    // If n is prime
    if (n > 1)
    {
        arr.add(new primeFactorization( 1, n ));
    }
 
    int curIndex = 0, curDivisor = 1;
 
    // Generate all the divisors
    generateDivisors(curIndex, curDivisor, arr);
}
 
// Driver code
public static void main(String []args)
{
    int n = 6;
 
    findDivisors(n);
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 implementation of the approach
 
# Recursive function to generate all the
# divisors from the prime factors
def generateDivisors(curIndex, curDivisor, arr):
     
    # Base case i.e. we do not have more
    # primeFactors to include
    if (curIndex == len(arr)):
        print(curDivisor, end = ' ')
        return
     
    for i in range(arr[curIndex][0] + 1):
        generateDivisors(curIndex + 1, curDivisor, arr)
        curDivisor *= arr[curIndex][1]
     
# Function to find the divisors of n
def findDivisors(n):
     
    # To store the prime factors along
    # with their highest power
    arr = []
     
    # Finding prime factorization of n
    i = 2
    while(i * i <= n):
        if (n % i == 0):
            count = 0
            while (n % i == 0):
                n //= i
                count += 1
                 
            # For every prime factor we are storing
            # count of it's occurenceand itself.
            arr.append([count, i])
     
    # If n is prime
    if (n > 1):
        arr.append([1, n])
     
    curIndex = 0
    curDivisor = 1
     
    # Generate all the divisors
    generateDivisors(curIndex, curDivisor, arr)
 
# Driver code
n = 6
findDivisors(n)
 
# This code is contributed by SHUBHAMSINGH10
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
public class primeFactorization
{
 
    // to store the prime factor
    // and its highest power
    public int countOfPf, primeFactor;
 
    public primeFactorization(int countOfPf,
                              int primeFactor)
    {
        this.countOfPf = countOfPf;
        this.primeFactor = primeFactor;
    }
}
 
// Recursive function to generate all the
// divisors from the prime factors
static void generateDivisors(int curIndex, int curDivisor,
                             List<primeFactorization> arr)
{
 
    // Base case i.e. we do not have more
    // primeFactors to include
    if (curIndex == arr.Count)
    {
        Console.Write(curDivisor + " ");
        return;
    }
 
    for (int i = 0; i <= arr[curIndex].countOfPf; ++i)
    {
        generateDivisors(curIndex + 1, curDivisor, arr);
        curDivisor *= arr[curIndex].primeFactor;
    }
}
 
// Function to find the divisors of n
static void findDivisors(int n)
{
 
    // To store the prime factors along
    // with their highest power
    List<primeFactorization> arr = new List<primeFactorization>();
 
    // Finding prime factorization of n
    for (int i = 2; i * i <= n; ++i)
    {
        if (n % i == 0)
        {
            int count = 0;
            while (n % i == 0)
            {
                n /= i;
                count += 1;
            }
 
            // For every prime factor we are storing
            // count of it's occurenceand itself.
            arr.Add(new primeFactorization(count, i ));
        }
    }
 
    // If n is prime
    if (n > 1)
    {
        arr.Add(new primeFactorization( 1, n ));
    }
 
    int curIndex = 0, curDivisor = 1;
 
    // Generate all the divisors
    generateDivisors(curIndex, curDivisor, arr);
}
 
// Driver code
public static void Main(String []args)
{
    int n = 6;
 
    findDivisors(n);
}
}
 
// This code is contributed by PrinciRaj1992
Javascript



<script>
// Javascript implementation of the approach
 
// Recursive function to generate all the
// divisors from the prime factors
function generateDivisors(curIndex, curDivisor, arr)
{
 
    // Base case i.e. we do not have more
    // primeFactors to include
    if (curIndex == arr.length) {
        document.write(curDivisor + " ");
        return;
    }
 
    for (var i = 0; i <= arr[curIndex][0]; ++i) {
        generateDivisors(curIndex + 1, curDivisor, arr);
        curDivisor *= arr[curIndex][1];
    }
}
 
// Function to find the divisors of n
function findDivisors(n)
{
 
    // To store the prime factors along
    // with their highest power
    arr = [];
 
    // Finding prime factorization of n
    for (var i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            var count = 0;
            while (n % i == 0) {
                n /= i;
                count += 1;
            }
 
            // For every prime factor we are storing
            // count of it's occurenceand itself.
            arr.push([ count, i ]);
        }
    }
 
    // If n is prime
    if (n > 1) {
        arr.push([ 1, n ]);
    }
 
    var curIndex = 0, curDivisor = 1;
 
    // Generate all the divisors
    generateDivisors(curIndex, curDivisor, arr);
}
 
 
// driver code
var n = 6;
findDivisors(n);
// This code contributed by shubhamsingh10
</script>
Output: 
1 3 2 6
 



My Personal Notes
arrow_drop_up
Next

Efficient program to print all prime factors of a given number
Recommended Articles
Page :
Count occurrences of a prime number in the prime factorization of every element from the given range
11, Sep 19
Sum of Factors of a Number using Prime Factorization
03, Oct 18
Maximum possible prime divisors that can exist in numbers having exactly N divisors
07, May 20
Prime Factorization using Sieve O(log n) for multiple queries
10, Mar 17
Find sum of divisors of all the divisors of a natural number
21, Jan 17
Pollard's Rho Algorithm for Prime Factorization
03, Jan 16
Product of divisors of a number from a given list of its prime factors
15, Jul 20
Find sum of inverse of the divisors when sum of divisors and the number is given
28, Jun 19
Check if a number has an odd count of odd divisors and even count of even divisors
20, Aug 20
Check if a number is divisible by all prime divisors of another number
18, Oct 17
Sum of all prime divisors of all the numbers in range L-R
14, Aug 18
Generating all possible Subsequences using Recursion
03, Oct 18
Divisors of n-square that are not divisors of n
11, Nov 17
Check if count of even divisors of N is equal to count of odd divisors
29, May 20
Minimum value exceeding X whose count of divisors has different parity with count of divisors of X
18, Nov 20
Sum of all the prime divisors of a number
08, Aug 18
Sum of all the prime divisors of a number | Set 2
01, Jul 21
Distinct Numbers obtained by generating all permutations of a Binary String
05, Apr 21
Print all numbers that are divisors of N and are co-prime with the quotient of their division
18, Jun 21
Find number from its divisors
16, May 19
Generating subarrays using recursion
02, Oct 18
Check if a number has prime count of divisors
29, Jan 20
Count of the non-prime divisors of a given number
22, May 20
Check if a number can be expressed as a product of exactly K prime divisors
22, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
BhupendraYadav
@BhupendraYadav
Vote for difficulty





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

Start Your Coding Journey Now!