Skip to content
Related Articles

Related Articles

Generating all divisors of a number using its prime factorization
  • Last Updated : 19 Feb, 2020

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

Examples:

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 it’s prime factorization as p1a1*p2a2*……*pkak, here 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 it’s 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
Output:
1 3 2 6

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
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
Minimum value exceeding X whose count of divisors has different parity with count of divisors of X
18, Nov 20
Check if count of even divisors of N is equal to count of odd divisors
29, May 20
Sum of all the prime divisors of a number
08, Aug 18
Distinct Numbers obtained by generating all permutations of a Binary String
05, Apr 21
Generating subarrays using recursion
02, Oct 18
Find number from its divisors
16, May 19
Check if a number has prime count of divisors
29, Jan 20
Check if a number can be expressed as a product of exactly K prime divisors
22, Apr 20
Count of the non-prime divisors of a given number
22, May 20
Generating Lyndon words of length n
20, Nov 18
Heap's Algorithm for generating permutations
04, Jul 16
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