Prime factor is the factor of the given number which is a prime number. Factors are the numbers you multiply together to get another number. In simple words, prime factor is finding which prime numbers multiply together to make the original number.

**Example:** The prime factors of 15 are 3 and 5 (because 3×5=15, and 3 and 5 are prime numbers).

**Some interesting fact about Prime Factor : **

- There is only one (unique!) set of prime factors for any number.
- In order to maintain this property of unique prime factorizations, it is necessary that the number one, 1, be categorized as neither prime nor composite.
- Prime factorizations can help us with divisibility, simplifying fractions, and finding common denominators for fractions.
- Pollard’s Rho is a prime factorization algorithm, particularly fast for a large composite number with small prime factors.
- Cryptography is the study of secret codes. Prime Factorization is very important to people who try to make (or break) secret codes based on numbers.

**How to print a prime factor of a number?**

**Naive solution:**

Given a number n, write a 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:

- While
*n*is divisible by 2, print 2 and divide n by 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. - 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.

## C/C++

`// Program to print all prime factors ` `# include <stdio.h> ` `# include <math.h> ` ` ` `// A function to print all prime factors of a given number n ` `void` `primeFactors(` `int` `n) ` `{ ` ` ` `// Print the number of 2s that divide n ` ` ` `while` `(n%2 == 0) ` ` ` `{ ` ` ` `printf` `(` `"%d "` `, 2); ` ` ` `n = n/2; ` ` ` `} ` ` ` ` ` `// n must be odd at this point. So we can skip ` ` ` `// one element (Note i = i +2) ` ` ` `for` `(` `int` `i = 3; i <= ` `sqrt` `(n); i = i+2) ` ` ` `{ ` ` ` `// While i divides n, print i and divide n ` ` ` `while` `(n%i == 0) ` ` ` `{ ` ` ` `printf` `(` `"%d "` `, i); ` ` ` `n = n/i; ` ` ` `} ` ` ` `} ` ` ` ` ` `// This condition is to handle the case when n ` ` ` `// is a prime number greater than 2 ` ` ` `if` `(n > 2) ` ` ` `printf` `(` `"%d "` `, n); ` `} ` ` ` `/* Driver program to test above function */` `int` `main() ` `{ ` ` ` `int` `n = 315; ` ` ` `primeFactors(n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// 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*

## Python

`# Python program to print prime factors ` ` ` `import` `math ` ` ` `# A function to print all prime factors of ` `# a given number n ` `def` `primeFactors(n): ` ` ` ` ` `# Print the number of two's that divide n ` ` ` `while` `n ` `%` `2` `=` `=` `0` `: ` ` ` `print` `2` `, ` ` ` `n ` `=` `n ` `/` `2` ` ` ` ` `# n must be odd at this point ` ` ` `# so a skip of 2 ( i = i + 2) can be used ` ` ` `for` `i ` `in` `range` `(` `3` `, ` `int` `(math.sqrt(n))` `+` `1` `, ` `2` `): ` ` ` ` ` `# while i divides n, print i ad divide n ` ` ` `while` `n ` `%` `i ` `=` `=` `0` `: ` ` ` `print` `i, ` ` ` `n ` `=` `n ` `/` `i ` ` ` ` ` `# Condition if n is a prime ` ` ` `# number greater than 2 ` ` ` `if` `n > ` `2` `: ` ` ` `print` `n ` ` ` `# Driver Program to test above function ` ` ` `n ` `=` `315` `primeFactors(n) ` ` ` `# This code is contributed by Harshit Agrawal ` |

*chevron_right*

*filter_none*

## C#

`// C# Program to print all prime factors ` `using` `System; ` ` ` `namespace` `prime { ` `public` `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) { ` ` ` `Console.Write(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) { ` ` ` `Console.Write(i + ` `" "` `); ` ` ` `n /= i; ` ` ` `} ` ` ` `} ` ` ` ` ` `// This condition is to handle the case whien ` ` ` `// n is a prime number greater than 2 ` ` ` `if` `(n > 2) ` ` ` `Console.Write(n); ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `n = 315; ` ` ` `primeFactors(n); ` ` ` `} ` `} ` `} ` ` ` `// This code is contributed by Sam007 ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP Efficient program to print all ` `// prime factors of a given number ` ` ` `// function to print all prime ` `// factors of a given number n ` `function` `primeFactors(` `$n` `) ` `{ ` ` ` ` ` `// Print the number of ` ` ` `// 2s that divide n ` ` ` `while` `(` `$n` `% 2 == 0) ` ` ` `{ ` ` ` `echo` `2, ` `" "` `; ` ` ` `$n` `= ` `$n` `/ 2; ` ` ` `} ` ` ` ` ` `// n must be odd at this ` ` ` `// point. So we can skip ` ` ` `// one element (Note i = i +2) ` ` ` `for` `(` `$i` `= 3; ` `$i` `<= sqrt(` `$n` `); ` ` ` `$i` `= ` `$i` `+ 2) ` ` ` `{ ` ` ` ` ` `// While i divides n, ` ` ` `// print i and divide n ` ` ` `while` `(` `$n` `% ` `$i` `== 0) ` ` ` `{ ` ` ` `echo` `$i` `, ` `" "` `; ` ` ` `$n` `= ` `$n` `/ ` `$i` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// This condition is to ` ` ` `// handle the case when n ` ` ` `// is a prime number greater ` ` ` `// than 2 ` ` ` `if` `(` `$n` `> 2) ` ` ` `echo` `$n` `, ` `" "` `; ` `} ` ` ` ` ` `// Driver Code ` ` ` `$n` `= 315; ` ` ` `primeFactors(` `$n` `); ` ` ` `// This code is contributed by aj_36 ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

3 3 5 7

**How does this work?**

- Steps 1 and 2 take care of composite number 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.

It’s clear that step-1 takes care of even numbers. 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*. 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-
- Find the least prime factor i (must be less than √n, )
- Remove all occurrences i from n by repeatedly dividing n by i.
- 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.

**Efficient solution:**

**Programs to find prime factor of a number**

- 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

**More problems related to Prime Factor **

- Count numbers from range whose prime factors are only 2 and 3
- 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
- Numbers with sum of digits equal to the sum of digits of its all prime factor
- Number which has the maximum number of distinct prime factors in the range M to N

**Recent Articles on Prime Factor!**

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Exactly n distinct prime factor numbers from a to b
- k-th prime factor of a given number
- Queries on the sum of prime factor counts in a range
- Nearest element with at-least one common prime factor
- Count of subarrays whose products don't have any repeating prime factor
- Find largest prime factor of a number
- Sum of largest prime factor of each number less than equal to n
- N-th prime factor of a given number
- Numbers with sum of digits equal to the sum of digits of its all prime factor
- Count all the numbers less than 10^6 whose minimum prime factor is N
- Find sum of a number and its maximum prime factor
- Sum of Maximum and Minimum prime factor of every number in the Array
- Count of distinct power of prime factor of N
- Least prime factor of numbers till n
- Print the kth common factor of two numbers
- Smallest number S such that N is a factor of S factorial or S!
- Factor Tree of a given Number
- Count all the numbers in a range with smallest factor as K
- Largest factor of a given number which is a perfect square
- Check if frequency of character in one string is a factor or multiple of frequency of same character in other string