Unique Prime Factors in Sorted Order

Given a number n. Find its unique prime factors in increasing order.

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.

Factorization using Trial Division - O(sqrt(n)) Time and O(1) 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:

• Check if n is divisible by 2; if so, store 2 and divide n by 2 until it is no longer divisible.
• Check all odd numbers from 3 to √n.
• Whenever a number divides n, store it and keep dividing n by it until it is no longer divisible.
• After the loop, if n > 2, store n as the remaining prime factor.
• Dividing out each prime factor completely ensures only unique prime factors are stored.

#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 

Sieve of Eratosthenes

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 queries , In those cases we can precompute spf array and then answer queries in O(log n) time instead of naive O(sqrt n) time.

Step by step approach:

• Precompute the smallest prime factor (spf) for every number up to n.
• Create an spf[] array and initialize spf[i] = i.
• Use the Sieve of Eratosthenes to fill the smallest prime factor for each number.
• To find the unique prime factors of n, repeatedly use spf[n] and store each distinct factor.
• Divide n by the current prime factor until it is no longer divisible.
• Continue until n becomes 1.

#include <iostream>
#include <vector>
#include <set>
using namespace std;
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;
}

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

import java.util.*;

public class GFG {

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

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

    static ArrayList<Integer> primeFac(int n) {

        int[] spf = computeSPF(n);

        Set<Integer> uniqueFactors = new TreeSet<>();

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

        return new ArrayList<>(uniqueFactors);
    }

    public static void main(String[] args) {

        int n = 100;

        List<Integer> result = primeFac(n);

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

        System.out.println();
    }
}

def compute_spf(n):
    spf = list(range(n + 1))

    i = 2
    while i * i <= n:

        # i is prime
        if spf[i] == i:
            j = i * i

            while j <= n:
                if spf[j] == j:
                    spf[j] = i
                j += i

        i += 1

    return spf


def primeFac(n):
    spf = compute_spf(n)

    unique_factors = set()

    while n > 1:
        unique_factors.add(spf[n])
        n //= spf[n]

    return sorted(unique_factors)


n = 100
result = primeFac(n)

for factor in result:
    print(factor, end=" ")
print()

using System;
using System.Collections.Generic;

class GFG
{
    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++)
        {
            // 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;
    }

    static List<int> primeFac(int n)
    {
        int[] spf = ComputeSPF(n);

        SortedSet<int> uniqueFactors = new SortedSet<int>();

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

        return new List<int>(uniqueFactors);
    }

    static void Main()
    {
        int n = 100;

        List<int> result = primeFac(n);

        foreach (int factor in result)
        {
            Console.Write(factor + " ");
        }

        Console.WriteLine();
    }
}

function computeSPF(n) {
    const spf = Array(n + 1);

    for (let i = 0; i <= n; i++) {
        spf[i] = i;
    }

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

    return spf;
}

function primeFac(n) {
    const spf = computeSPF(n);

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

// Driver Code
const n = 100;
const result = primeFac(n);

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