Distinct Prime Factors (original) (raw)

Last Updated : 9 May, 2026

Given an integer **n, find all unique prime factors of n. A prime factor is a prime number that divides n exactly (without leaving a remainder).

**Examples:

**Input: n = 100
**Output: [2, 5]
**Explanation: Unique prime factors of 100 are 2 and 5.

**Input: n = 60
**Output: [2, 3, 5]
**Explanation: Prime factors of 60 are 2, 2, 3, 5. Unique prime factors are 2, 3 and 5.

Try It Yourself

Table of Content

• Factorization using Trial Division - O(sqrt(n)) Time and O(log(n)) Space
• Sieve of Eratosthenes (Smallest Prime Factor)

Factorization using Trial Division - O(sqrt(n)) Time and O(log(n)) Space

First, divide n by 2 repeatedly and store 2 as a unique prime factor if it divides n. Then, check odd numbers from 3 to √n, for each that divides n, store it and divide n completely by it. Finally, if n is still greater than 2, store it as it is a prime factor.

**Step by step approach:

• Start by checking if n is divisible by 2.
  • If yes, store 2 as a unique prime factor and divide n repeatedly by 2.
• Loop through odd numbers i from 3 to √n:
  • If i divides n, store i as a unique prime factor.
  • Keep dividing n by i until it's no longer divisible.
• After the loop, if n > 2, it is a prime and should be stored.
• This ensures all unique prime factors are captured efficiently.
• The algorithm avoids duplicates by fully removing each prime factor once found. C++ `

#include #include #include using namespace std;

vector primeFac(int n) { vector res;

// Check for factor 2
if (n % 2 == 0) {
    res.push_back(2);
    while (n % 2 == 0) n /= 2;
}

// Check for odd prime factors
for (int i = 3; i <= sqrt(n); i += 2) {
    if (n % i == 0) {
        res.push_back(i);
        while (n % i == 0) n /= i;
    }
}

// If remaining n is a prime number > 2
if (n > 2) res.push_back(n);

return res;

}

int main() { int n = 100; vector result = primeFac(n); for (int factor : result) { cout << factor << " "; } return 0; }

Java

import java.util.*;

public class GfG {

public static ArrayList<Integer> primeFac(int n) {
    ArrayList<Integer> res = new ArrayList<>();

    // Check for factor 2
    if (n % 2 == 0) {
        res.add(2);
        while (n % 2 == 0) {
            n /= 2;
        }
    }

    // Check for odd prime factors
    for (int i = 3; i <= Math.sqrt(n); i += 2) {
        if (n % i == 0) {
            res.add(i);
            while (n % i == 0) {
                n /= i;
            }
        }
    }

    // If remaining n is a prime number > 2
    if (n > 2) {
        res.add(n);
    }

    return res;
}

public static void main(String[] args) {
    int n = 100;
    ArrayList<Integer> result = primeFac(n);

    for (int factor : result) {
        System.out.print(factor + " ");
    }
}

}

Python

import math

def primeFac(n): res = []

# Check for factor 2
if n % 2 == 0:
    res.append(2)
    while n % 2 == 0:
        n //= 2

# Check for odd prime factors
i = 3
while i * i <= n:
    if n % i == 0:
        res.append(i)
        while n % i == 0:
            n //= i
    i += 2

# If n is a prime > 2
if n > 2:
    res.append(n)

return res

Driver code

if name == "main": n = 100 result = primeFac(n) print(" ".join(map(str, result)))

C#

using System; using System.Collections.Generic;

class GfG { public static List primeFac(int n) { List res = new List();

    // Check for factor 2
    if (n % 2 == 0)
    {
        res.Add(2);
        while (n % 2 == 0)
            n /= 2;
    }

    // Check for odd prime factors
    for (int i = 3; i <= Math.Sqrt(n); i += 2)
    {
        if (n % i == 0)
        {
            res.Add(i);
            while (n % i == 0)
                n /= i;
        }
    }

    // If n is a prime number > 2
    if (n > 2)
        res.Add(n);

    return res;
}

public static void Main()
{
    int n = 100;
    List<int> result = primeFac(n);
    Console.WriteLine(string.Join(" ", result));
}

}

JavaScript

function primeFac(n) { const res = [];

// Check for factor 2
if (n % 2 === 0) {
    res.push(2);
    while (n % 2 === 0) {
        n = Math.floor(n / 2);
    }
}

// Check for odd prime factors
for (let i = 3; i <= Math.sqrt(n); i += 2) {
    if (n % i === 0) {
        res.push(i);
        while (n % i === 0) {
            n = Math.floor(n / i);
        }
    }
}

// If n is a prime > 2
if (n > 2) {
    res.push(n);
}

return res;

}

const n = 100; const result = primeFac(n); console.log(result.join(" "));

`

Sieve of Eratosthenes (Smallest Prime Factor)

The idea in the SPF approach is to precompute the smallest prime factor (SPF) for every number up to n using a modified sieve. Once SPF is ready, we can efficiently find the unique prime factors of any number by repeatedly dividing it by its SPF. This makes each factorization run in O(log n) time.

**Note: This approach is best for cases where we need to find unique prime factors for multiple input values.

**Step by step approach:

• Precompute spf for every number up to n:
  • Create an array spf[] of size n+1, where spf[i] stores the smallest prime factor of i.
  • Initialize spf[i] = i for all i.
  • Use the Sieve of Eratosthenes, for each prime i, mark spf[j] = i for all multiples j of i (if not already marked).
• To find unique prime factors of a number n:
  • Repeatedly divide n by spf[n] (i.e n = n/spf[n]).
  • Store each new spf[n] encountered in a set (to keep it unique and in ascending order).
  • Continue until n becomes 1. C++ `

#include #include #include using namespace std;

// Function to compute SPF (Smallest Prime Factor) for every number up to N vector computeSPF(int N) { vector spf(N + 1); for (int i = 0; i <= N; ++i) { spf[i] = i; }

for (int i = 2; i * i <= N; ++i) {
    // i is prime
    if (spf[i] == i) { 
        for (int j = i * i; j <= N; j += i) {
            if (spf[j] == j) {
                spf[j] = i;
            }
        }
    }
}
return spf;

}

// Function to get unique prime factors using precomputed SPF vector primeFac(int n, const vector& spf) { set uniqueFactors; while (n > 1) { uniqueFactors.insert(spf[n]); n /= spf[n]; } return vector(uniqueFactors.begin(), uniqueFactors.end()); }

int main() {

int n = 100;
vector<int> spf = computeSPF(n);
vector<int> result = primeFac(n, spf);
for (int factor : result) {
    cout << factor << " ";
}
cout << endl;
return 0;

}

Java

import java.util.*;

public class GfG { // Function to compute SPF (Smallest Prime Factor) public static int[] computeSPF(int n) { int[] spf = new int[n + 1]; for (int i = 0; i <= n; i++) { spf[i] = i; }

    for (int i = 2; i * i <= n; i++) {
        if (spf[i] == i) {
            for (int j = i * i; j <= n; j += i) {
                if (spf[j] == j) {
                    spf[j] = i;
                }
            }
        }
    }
    return spf;
}

// Function to get unique prime factors using SPF
public static ArrayList<Integer> primeFac(int n, int[] spf) {
    Set<Integer> unique = new HashSet<>();
    // finding unique prime factor
    while (n > 1) {
        unique.add(spf[n]);
        n /= spf[n];
    }
    ArrayList<Integer> result = new ArrayList<>(unique);
    Collections.sort(result); 
    return result;
}

public static void main(String[] args) {
    int n = 100;
    int[] spf = computeSPF(n);
    ArrayList<Integer> result = primeFac(n, spf);
    for (int x : result) {
        System.out.print(x + " ");
    }
}

}

Python

import math

Function to compute SPF (Smallest Prime Factor) up to N

def compute_spf(N): spf = [i for i in range(N + 1)]

for i in range(2, int(math.sqrt(N)) + 1):
    if spf[i] == i:  # i is prime
        for j in range(i * i, N + 1, i):
            if spf[j] == j:
                spf[j] = i
return spf

Function to get unique prime factors using precomputed SPF

def prime_factors(n, spf): unique_factors = set() while n > 1: unique_factors.add(spf[n]) n //= spf[n] return sorted(unique_factors)

Driver code

if name == "main": n = 100 spf = compute_spf(n) result = prime_factors(n, spf) print(" ".join(map(str, result)))

C#

using System; using System.Collections.Generic;

class GfG { // Function to compute SPF (Smallest Prime Factor) for every number up to N static int[] computeSPF(int N) { int[] spf = new int[N + 1];

    for (int i = 0; i <= N; i++)
    {
        spf[i] = i;
    }

    for (int i = 2; i * i <= N; i++)
    {
        if (spf[i] == i) // i is prime
        {
            for (int j = i * i; j <= N; j += i)
            {
                if (spf[j] == j)
                {
                    spf[j] = i;
                }
            }
        }
    }

    return spf;
}

// Function to get unique prime factors using precomputed SPF
static List<int> primeFac(int n, int[] spf)
{
    HashSet<int> uniqueFactors = new HashSet<int>();

    while (n > 1)
    {
        uniqueFactors.Add(spf[n]);
        n /= spf[n];
    }

    List<int> result = new List<int>(uniqueFactors);
    result.Sort(); // Optional: to keep factors in ascending order
    return result;
}

static void Main()
{
    int n = 100;
    int[] spf = computeSPF(n);
    List<int> result = primeFac(n, spf);

    Console.WriteLine(string.Join(" ", result));
}

}

JavaScript

// Function to compute SPF (Smallest Prime Factor) up to N function computeSPF(N) { const spf = Array.from({ length: N + 1 }, (_, i) => i);

for (let i = 2; i * i <= N; i++) {
    if (spf[i] === i) { // i is prime
        for (let j = i * i; j <= N; j += i) {
            if (spf[j] === j) {
                spf[j] = i;
            }
        }
    }
}

return spf;

}

// Function to get unique prime factors using precomputed SPF function primeFac(n, spf) { const uniqueFactors = new Set();

while (n > 1) {
    uniqueFactors.add(spf[n]);
    n = Math.floor(n / spf[n]);
}

return Array.from(uniqueFactors).sort((a, b) => a - b); // Optional sort

}

// Driver code const n = 100; const spf = computeSPF(n); const result = primeFac(n, spf);

console.log(result.join(" "));

`

**Time Complexity: O(n*log(log(n))) -The SPF array is built in O(n(log(log(n))) time using the sieve. Then, finding the unique prime factors of a single number n takes O(log(n)) time.
**Auxiliary Space: O(n)- The algorithm uses O(n) space for the SPF array, which stores the smallest prime factor for each number up to n.

**Practice problems for finding prime factors

• Distinct Prime Factors of Array Product
• N-th prime factor of a given number
• Program to print factors of a number in pairs
• Number of distinct prime factors of first n natural numbers
• Product of unique prime factors of a number
• Common prime factors of two numbers
• Least prime factor of numbers till n
• Smallest prime divisor of a number
• Sum of Factors of a Number using Prime Factorization