Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Java Program to Perform the Unique Factorization of a Given Number

  • Last Updated : 01 Oct, 2021

Given a number n, the task is to write an efficient program to print all unique prime factors of n. 

Example

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input: 12
Output: 2, 3
Explanation: All prime factors or 12 are 2, 2, 3. In those factors, unique factors
         are 2 and 3.

Input: 315 
Output: 3, 5, 7

Steps to find all prime factors

1) While n is divisible by 2, print 2 and divide n by 2.



2) After step 1, n must be odd. Now start a loop from i = 3 to the square root of n. While i divides n, print i and divide n by i, increment i by 2 and continue.

3) If n is a prime number and is greater than 2, then n will not become 1 by the above two steps. So print n if it is greater than 2.

In the second step, the loop runs to the square root of n because the pairs for the product of nth number only possible when one number is less than greater than the square root of n and the second number is greater and equal to the square root of n.

For example, let n =16 square root of 16 is 4 and the factors of 16 are 1×16, 16×1, 2×8, 8×2, 4×4  in this sequence the first number should be less than or equal to the square root of n and the second number is greater than and equal to square root to n.

Mathematically proof:

  1. Let x < sqrt(n) and y < sqrt(n) multiply both equation x×y < n hence when any x and y less than n. The product of any x and y is always less than n.
  2. Let x > sqrt(n) and y > sqrt(n) multiply both equations x×y > n hence when any x and y less than n.The product of any x and y is always less than n.
  3. Let one number is below sqrt(n) and the second number above sqrt(n). In this case there is always at least one pair of numbers whose product is n. let x and y be the two numbers whose product is n. We can write x = sqrt(n) * sqrt(n)/y  ⇾ equation 1st

There are two conditions:

  • When y < sqrt(n) i.e 1 < sqrt(n)/y so we can write 1st equation  x = sqrt(n)*(1+b) hence x > sqrt(n)
  • When y < sqrt(n) i.e 1 > sqrt(n)/y so we can write 1st equation x = sqrt(n)*(1-b) hence x < sqrt(n).

Hence, we can conclude the for x*y=n at least one number is less than equal to sqrt(n) or greater than and equal to sqrt(n)

This concept is used in many Number theory Algorithms like a sieve, Finding all divisors of n, etc
 

Approaches For Finding unique prime Factors of given Number

1. Approach using HashSet 

  • While n is divisible by 2, store 2 in the set and divide n by 2.
  • After the above step, n must be odd. Now start a loop from i = 3 to the square root of n. While i divides n, store i in the set and divide n by i. After i fails to divide n, increment i by 2 and continue.
  • If n is a prime number and is greater than 2, then n will not become 1 by the above two steps. So store in set n if it is greater than 2.

Java




// Java Program to print all unique prime factors
 
import java.io.*;
import java.lang.Math;
import java.util.*;
class GFG {
 
    // A function to print all prime factors
    // of a given number n
    public static void primeFactors(int n,
                                    HashSet<Integer> h)
    {
        // Print the number of 2s that divide n
        while (n % 2 == 0) {
 
            h.add(2);
            n /= 2;
        }
 
        // n must be odd at this point. So we can
        // skip one element (Note i = i +2)
        for (int i = 3; i <= Math.sqrt(n); i += 2) {
 
            // While i divides n, print i and divide n
            while (n % i == 0) {
                h.add(i);
                n /= i;
            }
        }
 
        // This condition is to handle the case when
        // n is a prime number greater than 2
        if (n > 2)
            h.add(n);
    }
    static void printFactors(HashSet<Integer> H)
    {
        // Itearator over the HashSet
        Iterator<Integer> It = H.iterator();
 
        // printing the elements of HashSet
        while (It.hasNext()) {
 
            System.out.print(It.next() + " ");
        }
        System.out.println();
    }
    public static void main(String[] args)
    {
        int n = 15;
        HashSet<Integer> h = new HashSet<>();
 
        primeFactors(n, h);
 
        // print the unique factors
        printFactors(h);
    }
}
Output
3 5

 Time Complexity: O(sqrt(n))
 

2. Approach Using Sieve :

  • Marks all the multiples of numbers till sqrt(n) reason mention above where n is the maximum length of the array.
  • The array looks like for multiple of 2 and so on till length of the array.
01232
  • Mark all the remaining multiples of all number till sqrt(n). For finding the factors of an nth number.
    • Divide the n with n/dp[n] until dp[n]!=n
    • Store all the dp[n] values in HashSet or TreeSet and finally store n in the set.
    • Print the set for unique factors.

Java




// Java Program to print all unique prime factors
 
import java.util.*;
import java.io.*;
 
public class GFG {
    static int dp[] = new int[100001];
 
    static void fill()
    {
        int n = 100000;
        for (int i = 1; i <= n; ++i) {
            dp[i] = i;
        }
       
        // mark the multiply of 2
        for (int i = 2; i <= n; i += 2) {
            dp[i] = 2;
        }
       
        // mark the multilple of less than sqrt(n)
        for (int i = 3; i <= Math.sqrt(n); ++i) {
            for (int j = i * i; j <= n; j += i) {
                if (dp[j] == j) {
                    dp[j] = i;
                }
            }
        }
    }
    static void Factors(int n, HashSet<Integer> h)
    {
 
        // when n is prime number
        if (dp[n] == n) {
            h.add(n);
            return;
        }
        else {
            while (dp[n] != n) {
 
                // Adding the multiple.
                h.add(dp[n]);
                n = n / dp[n];
            }
            h.add(n);
            return;
        }
    }
    static void print(HashSet<Integer> h)
    {
        Iterator<Integer> it = h.iterator();
 
        // printing the elements
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
 
    public static void main(String[] args)
    {
        int n = 21;
        fill();
        HashSet<Integer> h = new HashSet<>();
 
        // finding the factors
        Factors(n, h);
        print(h);
    }
}
Output
3 7

Time Complexity: O(logn)




My Personal Notes arrow_drop_up
Recommended Articles
Page :