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

**Example**

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:**

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

*chevron_right*

*filter_none*

**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.

0 | 1 | 2 | 3 | 2 |
---|

- Mark all the remaining multiples of all number till sqrt(n). For finding the factors of an nth number.

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

*chevron_right*

*filter_none*

**Output**

3 7

**Time Complexity: **O(logn)

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.