 Open in App
Not now

# Generating all divisors of a number using its prime factorization

• Last Updated : 06 Jan, 2023

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 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& 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 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 occurrenceand 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 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 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 occurrenceand 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 occurrenceand 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 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 arr = ``new` `List();` `    ``// 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 occurrenceand 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

 ``

Output:

`1 3 2 6`

Time Complexity: O(sqrt(n))
Auxiliary Space: O(sqrt(n))

My Personal Notes arrow_drop_up