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