Find the largest prime number factor?

Question

I need to find The prime factors of 13195 are 5, 7, 13 and 29. / * Largest is 377. * / What is the largest prime factor of the number 600851475143 ?

#include<         


        

Answer 1

#include<stdio.h>
//Euler problem #3
int main(){
    long long i, sqi;
    long long value, large = 600851475143LL;
    long long max = 0LL;

    i   = 2LL;
    sqi = 4LL; //i*i
    for(value = large; sqi <= value ; sqi +=  2LL * i++ + 1LL){
        while(value % i == 0LL){
            value /= (max=i);
        }
    }

    if(value != 1LL && value != large){
        max = value;
    }
    if(max == 0LL){
        max = large;
    }
    printf("%lld\n", max);
    return 0; 
}

Answer 2

public class LargeFactor{

     public static void main(String []args){
     long num = 600851475143L;
     long largestFact = 0;
     long[] factors = new long[2];

    for (long i = 2; i * i < num; i++) {
         if (num % i == 0) { // It is a divisor
        factors[0] = i;
        factors[1] = num / i;

        for (int k = 0; k < 2; k++) {
            boolean isPrime = true;
            for (long j = 2; j * j <  factors[k]; j++) {
                if (factors[k] % j == 0) {
                    isPrime = false;
                    break;
                 }
             }
             if (isPrime && factors[k] > largestFact) {
                largestFact = factors[k];
             }
            }
        }
     }
     System.out.println(largestFact);
}
}

Above code utilises the fact that we only need to check all numbers up to the square root when looking for factors.

Answer 3

The most important thing that is wrong here is that your code is too slow: even if you fix other issues, such as using a wrong data type for your integers and trying out some divisors that are definitely not prime, iterating by one down from 10^11 will simply not finish in your computer's lifetime is extremely wasteful.

I highly recommend that you read through the example on page 35 of this classic book, where Dijkstra takes you through the process of writing a program printing the first 1000 prime numbers. This example should provide enough mathematical intuition to you to speed up your own calculations, including the part where you start your search from the square root of the number that you are trying to factor.

Answer 4

600851475143 is probably above the precision of your platform's long data type. It requires at least 40 bits to store. You can use this to figure out how many bits you have:

#include <limits.h>

printf("my compiler uses %u bits for the long data type\n", (unsigned int) (CHAR_BIT * sizeof (long)));

Answer 5

You need to add an L as suffix to a number that overflow MAX INT, so this line:

long value, large = 600851475143;

Should be:

long value, large = 600851475143L;
//                              ^

Answer 6

In order to do this you need to establish that the value is prime - i.e. that is has no prime factors.

Now your little piece of code checking 3/5/7 simply isn't good enough - you need to check is value has ANY lower prime factors (for example 11/13/17).

From a strategic perspective if you want to use this analysis you need to check a list of every prime factor you have found so far and check against them as you are checking against the first 3 primes.

An easier (but less efficient) method would be to write an IsPrimeFunction() and check the primality of the each divisor and store the largest.