Finding the largest prime factor of a number in JavaScript

In JavaScript, finding the largest prime factor of a number involves dividing the number by its prime factors until we reach the highest one. This is commonly solved using prime factorization.

Understanding Prime Factors

A prime factor is a prime number that divides the given number exactly (without remainder). For example, the number 84 has prime factors: 2, 2, 3, and 7. Among these, 7 is the largest prime factor.

Algorithm Approach

We use prime factorization by starting with the smallest prime (2) and dividing the number repeatedly. When a prime no longer divides the number, we move to the next potential prime. The process continues until the number becomes 1.

Implementation

function largestPrimeFactor(number) {
    let largest = 1;
    let current = 2;
    
    while (current * current <= number) {
        while (number % current === 0) {
            largest = current;
            number = number / current;
        }
        current++;
    }
    
    // If number is still greater than 1, then it's a prime
    if (number > 1) {
        largest = number;
    }
    
    return largest;
}

// Test with different numbers
console.log("Largest prime factor of 84:", largestPrimeFactor(84));
console.log("Largest prime factor of 315:", largestPrimeFactor(315));
console.log("Largest prime factor of 17:", largestPrimeFactor(17));

Largest prime factor of 84: 7
Largest prime factor of 315: 7
Largest prime factor of 17: 17

Optimized Version

We can optimize by only checking up to the square root of the number, since factors come in pairs:

function optimizedLargestPrimeFactor(number) {
    let largest = 1;
    
    // Handle factor of 2
    while (number % 2 === 0) {
        largest = 2;
        number = number / 2;
    }
    
    // Check odd factors from 3 onwards
    for (let i = 3; i * i <= number; i += 2) {
        while (number % i === 0) {
            largest = i;
            number = number / i;
        }
    }
    
    // If number is still a prime greater than 2
    if (number > 2) {
        largest = number;
    }
    
    return largest;
}

console.log("Optimized result for 84:", optimizedLargestPrimeFactor(84));
console.log("Optimized result for 1001:", optimizedLargestPrimeFactor(1001));

Optimized result for 84: 7
Optimized result for 1001: 13

Step-by-Step Example

Let's trace through finding the largest prime factor of 84:

function traceFactorization(number) {
    console.log(`Finding largest prime factor of ${number}:`);
    let largest = 1;
    let current = 2;
    let original = number;
    
    while (current * current <= number) {
        while (number % current === 0) {
            console.log(`${number} ÷ ${current} = ${number / current}`);
            largest = current;
            number = number / current;
        }
        current++;
    }
    
    if (number > 1) {
        largest = number;
        console.log(`Remaining number ${number} is prime`);
    }
    
    console.log(`Largest prime factor: ${largest}
`);
    return largest;
}

traceFactorization(84);

Finding largest prime factor of 84:
84 ÷ 2 = 42
42 ÷ 2 = 21
21 ÷ 3 = 7
Remaining number 7 is prime
Largest prime factor: 7

Time Complexity

The time complexity is O(?n), where n is the input number. This is because we only need to check factors up to the square root of the number. The space complexity is O(1) as we use constant extra space.

Conclusion

Finding the largest prime factor efficiently requires prime factorization starting from the smallest primes. The optimized approach checks only up to the square root, making it suitable for larger numbers.