计算素数的方法

Question

I am trying to figure out how this Java method calculates a prime number but something is confusing me.

public static boolean isPrime(int number){
    for(int divisor =2; divisor <= number / 2; divisor++){
        if (number % divisor ==0){
            return false;
        }
    }
    return true;
}

As you see in the second line in the for loop it shows divisor <= number /2 instead of divisor <= number . Can anyone tell me the reason for that?

Answer 1

First, if you put divisor <= number , you would get no prime numbers at all, because every number is divisible by itself. If the loop does not exit before divisor becomes number , you would get to

number % divisor == 0

condition, and return false .

Whoever wrote this code made an observation that you can stop as soon as you have reached half the number, because if you did not find divisors in the lower half of the interval (2..number/2) , there would be no divisors above half the number either, so you can declare the number prime without trying, unsuccessfully, the rest of the candidate divisors.

However, this is not the best you can do: a stronger condition can be used - you could compare divisor to square root of number . This works, because if you don't have a divisor that is less than or equal to the square root of number, there would be no divisors above the square root as well (it is a good idea to think why this is so).

int stop = Math.sqrt(number);
for(int divisor = 2; divisor <= stop ; divisor++) {
    ...
}

Answer 2

原因是任何数字都不能除以大于一半的除数并得到大于1的除数（当然，如果我们在说整数）。

Answer 3

Any number would not be divisible by a number more than its half.

For example, the last number 10 would be divisible is 5. 10 is not divisible with 6, 7, 8 or 9.

This is why it's good to eliminate the obvious mismatches to improve the performance of the algorithm.

Answer 4

As others have noted, there are no factors of n greater than n/2. A better solution is comparing your iterating variable to the square root of n, as if there are no factors less than or equal to the square root, there can't be any greater than the square root (Note that it is more efficient to compare i*i <= n that i <= Math.sqrt(n)).

An even better approach is the AKS primality test. If the number is 2 or 3, then it obviously must be prime. Otherwise, it can be rewritten in the form (6k+i) where i = -1, 0, 1, 2, 3, 4. Any (6k + 2) or (6k + 4) is divisible by 2, and any (6k + 3) is divisible by three, so the prime numbers must either take the form (6k - 1) or (6k + 1).

public static boolean isPrime(long n) { 
    /* This code uses the AKS primality test
     * http://en.wikipedia.org/wiki/AKS_primality_test
     */
    if (n <= 3) return n > 1;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i*i <=n; i+=6) {
      if (n % i == 0 || n % (i+2) == 0) return false; 
    }
    return true;
  }
}

I used this as a part of my solution to the PrimeCounter problem in Sedgewick's Intro to Programming in Java (although this is in the first chapter before methods are introduced).

public class PrimeCounter {
  public static void main(String[] args) {
    long n = 10000000;
    long count = 0;
    for (long i = 0; i <= n; i++) {
      if (isPrime(i)) count++;
    }
    System.out.println("The number of primes less than "
                         + n + " is " + count);
  }


  public static boolean isPrime(long n) { 
    /* This code uses the AKS primality test
     * http://en.wikipedia.org/wiki/AKS_primality_test
     */
    if (n <= 3) return n > 1;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i*i <=n; i+=6) {
      if (n % i == 0 || n % (i+2) == 0) return false; 
    }
    return true;
  }
}

Answer 5

It's using the fact that if one of the factors is greater than N/2 the other must be smaller than 2.

In fact a massive (asymptotic) gain can be obtained by using the square-root.

That's because if one factor is greater than the square root the other is less.

Sorry Sebri Zouhaier. I'm changing allegiance. The +1 isn't necessary so the best answer is below. I'm sorry to change sides for such a tiny improvement!

Answer 6

A number N cannot have any divisors D that are > N /2 and < N . To see this, note that if D is a divisor of N , then it must equal N / D ₂ for some D ₂ . So the divisors of N are those values of this sequence that are integers: N , N /2, N /3, ... This is a descending sequence. It should be obvious that there can't be any divisors between N and N /2.

In fact, it's common for programs that check for primality to stop at sqrt( N ) instead of N /2. The reason is this: Suppose there's a divisor D such that D > sqrt( N ). Then N / D = D ₂ also must be a divisor of N . And it must be the case that D ₂ < sqrt( N ), because if both D and D ₂ were > sqrt( N ), then D * D ₂ would have to be > N , which is wrong because D * D ₂ = N . This means that there is no need to check possible divisors D > sqrt( N ); if such a divisor existed, we already would have found D ₂ earlier in the loop and proven that N was not prime.

Answer 7

One small caveat to some of the above answers is that 0 and 1 are not prime numbers. You could account for this (for positive integers) with an implementation such as

public static boolean isPrime(int number){
    if (number == 0 || number == 1) 
        return false;
    else
    {
        int stop = (int) Math.sqrt(number);
        for (int divisor = 2; divisor <= stop ; divisor++) 
        {
               if (number % divisor ==0)
                    return false;

        }
            return true;

        }
    }

Answer 8

public static Boolean isPrime(int num){ //method signature. returns Boolean, true if number isPrime, false if not
if(num==2){ //for case num=2, function returns true. detailed explanation underneath
  return(true);
}
for(int i=2;i<=(int)Math.sqrt(num)+1;i++){ //loops through 2 to sqrt(num). All you need to check- efficient
  if(num%i==0){ //if a divisor is found, its not prime. returns false
    return(false);
  }
}
return(true); //if all cases don't divide num, it is prime.

}

---

    // Returns true iff n is prime.  First checks if n is even, handling the
// cases of n=2 (prime) or n is even > 2 (not prime).  Then checks if any
// odd #'s between 3 and sqrt(n), inclusive, are divisors of n, returning
// false if any are.
public static boolean isPrime(int n) {
    if (n < 2) return false;
    if (n % 2 == 0)
        // n is an even, so return true iff n is exactly 2
        return (n == 2);
    for (int i=3; i*i<=n; i+=2)
        if (n % i == 0)
            // i divides evenly into n, so n is not prime
            return false;
    return true;
}