Generating all divisors of a number using its prime factorization
Last Updated :
14 Aug, 2024
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<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 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 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 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 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# 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 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
<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 occurrenceand 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>
Time Complexity: O(sqrt(n))
Auxiliary Space: O(sqrt(n))
Similar Reads
Product of divisors of a number from a given list of its prime factors Given an array arr[] representing a list of prime factors of a given number, the task is to find the product of divisors of that number. Note: Since the product can be, very large printed, the answer is mod 109 + 7. Examples: Input: arr[] = {2, 2, 3} Output: 1728 Explanation: Product of the given pr
7 min read
Print all prime factors of a given number Given a number n, the task is to find all prime factors of n.Examples:Input: n = 24Output: 2 2 2 3Explanation: The prime factorization of 24 is 23×3.Input: n = 13195Output: 5 7 13 29Explanation: The prime factorization of 13195 is 5×7×13×29.Approach:Every composite number has at least one prime fact
6 min read
Sum of all proper divisors of a natural number Given a natural number, calculate sum of all its proper divisors. A proper divisor of a natural number is the divisor that is strictly less than the number. For example, number 20 has 5 proper divisors: 1, 2, 4, 5, 10, and the divisor summation is: 1 + 2 + 4 + 5 + 10 = 22.Examples : Input : num = 10
6 min read
Mathematical Algorithms - Prime Factorization and Divisors In the Mathematical algorithm there are two fundamental mathematical algorithms that is prime factorization and finding divisors. Prime factorization is the process of breaking down a number into its prime factors, while finding divisors involves identifying all the numbers that can evenly divide th
3 min read
Sum of all prime divisors of all the numbers in range L-R Given two integers L and R. The task is to find the sum of all prime factors of every number in the range[L-R]. Examples: Input: l = 5, r = 10 Output: 17 5 is prime, hence sum of factors = 0 6 has prime factors 2 and 3, hence sum = 5 7 is prime, hence sum = 0 8 has prime factor 2, hence sum = 2 9 ha
13 min read