Given a number n, write an efficient function to print all prime factors of n. For example, if the input number is 12, then output should be “2 2 3”. And if the input number is 315, then output should be “3 3 5 7”.

Following are the 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 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 above two steps. So print n if it is greater than 2.

`// Program to print all prime factors ` `import` `java.io.*; `
`import` `java.lang.Math; `
` ` `class` `GFG { `
` ` `// A function to print all prime factors `
` ` `// of a given number n `
` ` `public` `static` `void` `primeFactors(` `int` `n) `
` ` `{ `
` ` `// Print the number of 2s that divide n `
` ` `while` `(n % ` `2` `== ` `0` `) { `
` ` `System.out.print(` `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` `) { `
` ` `System.out.print(i + ` `" "` `); `
` ` `n /= i; `
` ` `} `
` ` `} `
` ` ` ` `// This condition is to handle the case whien `
` ` `// n is a prime number greater than 2 `
` ` `if` `(n > ` `2` `) `
` ` `System.out.print(n); `
` ` `} `
` ` ` ` `public` `static` `void` `main(String[] args) `
` ` `{ `
` ` `int` `n = ` `315` `; `
` ` `primeFactors(n); `
` ` `} `
`} ` |

*chevron_right*

*filter_none*

**Output:**

3 3 5 7

**How does this work?**

The steps 1 and 2 take care of composite numbers and step 3 takes care of prime numbers. To prove that the complete algorithm works, we need to prove that steps 1 and 2 actually take care of composite numbers. This is clear that step 1 takes care of even numbers. And after step 1, all remaining prime factor must be odd (difference of two prime factors must be at least 2), this explains why i is incremented by 2.

Now the main part is, the loop runs till square root of n not till. To prove that this optimization works, let us consider the following property of composite numbers.*Every composite number has at least one prime factor less than or equal to square root of itself.*

This property can be proved using counter statement. Let a and b be two factors of n such that a*b = n. If both are greater than √n, then a.b > √n, * √n, which contradicts the expression “a * b = n”.

In step 2 of the above algorithm, we run a loop and do following in loop

a) Find the least prime factor i (must be less than √n, )

b) Remove all occurrences i from n by repeatedly dividing n by i.

c) Repeat steps a and b for divided n and i = i + 2. The steps a and b are repeated till n becomes either 1 or a prime number.

Please refer complete article on Efficient program to print all prime factors of a given number for more details!

## Recommended Posts:

- C Program for efficiently print all prime factors of a given number
- Efficient program to print all prime factors of a given number
- Java Program to find Product of unique prime factors of a number
- Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
- Program to print factors of a number in pairs
- Efficient program to print the number of factors of n numbers
- Print all prime factors and their powers
- Java Program to Find sum of even factors of a number
- Java Program for Number of elements with odd factors in given range
- Java Program to Find minimum sum of factors of number
- Prime factors of a big number
- Sum of Factors of a Number using Prime Factorization
- Number which has the maximum number of distinct prime factors in the range M to N
- Number of steps to convert to prime factors
- Product of unique prime factors of a number