The **Largest prime factor** is a very simple concept. Let's break it down:
* Every number has many different factors. 
* **Factors** are numbers that completely divide a particular number to get zero as a remainder.
* For example, if we look at the number `6`, it has four factors: `1`,`2`,`3`,`6`. However, of these *factors*, `2` and `3` are prime numbers. As `3` is greater than `2`, `3` is said to be the *largest prime factor* of number `6`.


#include <iostream>
#include <vector>
using namespace std;

bool is_Prime(int x)
{
  // invalid input
  if (x <= 1)
    return false;

  // process all potential divisors
  for(int i = 2; i <= x / 2; i++) {
      if(x % i == 0) {
         return false;
      }
   }

  // no divisor found, therfore it's a prime number
  return true;
}


int main() {
   // the number we want factors of
   int number = 123;

   // vector to store all the prime factors of a number
   vector<int>Factors;
   // iterate from 2 to half of the number as there can be no factor
   // greater than half of the number. 
   for(int i = 2; i <= number/2; i++)
   {
      //check if number is factor
      if(number % i == 0)
      {
         // check if the factor is also a prime number
         if(is_Prime(i)==true)
         {
         // add the value in the vector
         Factors.push_back(i);
         }
      }
   }
   int max=1;
   // iterate the vector to find largest prime factor
   for(int i = 0; i < Factors.size(); i++)
   {
      if(Factors[i] > max)
      {
         max = Factors[i];
      }
   }
   
// output the largest prime factor
   cout<<"Largest prime factor = " << max<<endl;
   return 0;
}

import java.util.Collections;
import java.util.Vector;
class HelloWorld {
   // helper function to check is given number is prime
   static boolean is_Prime(int x) {
   if (x <= 1)
    return false;

  // process all potential divisors
  for(int i = 2; i <= x / 2; i++) {
      if(x % i == 0) {
         return false;
      }
   }

  // no divisor found, therfore it's a prime number
  return true;
}
    public static void main( String args[] ) {
      
   // the number we want factors of  
   int number = 123;
   
   // vector of type integer to store all the prime factors of a number
    Vector<Integer> Factors = new Vector<>();
    //List<int> Factors = new ArrayList<int>();


    Factors.add(1); 

   // iterate from 2 to half of the number as there can be no factor
   // greater than half of the number. 
   for(int i = 2; i <= number / 2; i++)
   {
      // check if number is a factor
      if(number % i == 0)
      {
         // check if factor is also a prime number
         if(is_Prime(i)==true)
         {
         // add the number to the vector
         Factors.add(i);
         }
      }
   }
   
   
// Output the Largest prime factor
   System.out.println("Largest prime factor = " + Collections.max(Factors));

    }
}

Java

def isPrime(x):
    # invalid input
    if x <= 1:
        return False

    # process all potential divisors
    for i in range(2,x):
        if x % i == 0:
            return False 
      

    # no divisor found, therfore it's a prime number
    return True
# the number to we want largest prime factor of
number = 123

# a list to store all the prime factors of a number
Factors=[]
Factors.append(1)
# iterate from 2 to half of the number as there can be no factor
# greater than half of the number.
for i in range(2, number//2 + 1):
    # check if number is a factor
    if number % i == 0:
        # check if factor is also a prime
        if isPrime(i)==True:
            # add the number to the list
            Factors.append(i)
# output the maximum of the factors to obtain largest prime factor
print("Largest Prime Factor =",max(Factors))

       

Python3

For any number, we must first find out all the factors associated with it. For example, if we look at the number `15`, we can see that it has three factors: `1`,`3`,`5`. In the code, we run a loop from `2` to half of the number. In this case, the loop will run from `2` to `7`. Now, we will check if each factor is also a prime number. We have defined a helper function in the code to check if a number is prime or not -- we call this function on every factor. If the number is a factor and also a prime, we add it to the maintained list of factors. At last, we find out the maximum number from the list to obtain the *largest prime factor*.  

Largest prime factor

Code