Prime Factor Program

Try it on GfG Practice

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.

[Approach 1] 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.

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

vector<int> primeFac(int n) {
    vector<int> 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<int> result = primeFac(n);
    for (int factor : result) {
        cout << factor << " ";
    }
    return 0;
}

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 + " ");
        }
    }
}

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

using System;
using System.Collections.Generic;

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

        // 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));
    }
}

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(" "));

2 5 

[Approach 2] 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.

#include <iostream>
#include <vector>
#include <set>
using namespace std;

// Function to compute SPF (Smallest Prime Factor) for every number up to N
vector<int> computeSPF(int N) {
    vector<int> 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<int> primeFac(int n, const vector<int>& spf) {
    set<int> uniqueFactors;
    while (n > 1) {
        uniqueFactors.insert(spf[n]);
        n /= spf[n];
    }
    return vector<int>(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;
}

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 + " ");
        }
    }
}

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

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));
    }
}

// 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(" "));

2 5 

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