使用埃拉托色尼筛法的最大素数

Question

I managed to solve the problem but I am exceeding the time limit.

What to fix : If the given number n is very large it takes ridiculous amount of time.

Question : Is there a way I can tweak the code to get the last prime number faster?

const n = 126;
let lastPrime = 0;

for (let j = 2; j <= n; j++) {
    let counter = 0;
    for (let i = 1; i <= j; i++) {
        if (j % i === 0) counter++;
    }
    if (counter === 2) lastPrime = j;
}

print(lastPrime); // Biggest prime number of 126 is 113

Thanks!

Answer 1

There are plenty of optimizations to be done here - a quick read here ( https://math.stackexchange.com/questions/889712/the-fastest-way-to-count-prime-number-that-smaller-or-equal-n/893767 ) would help.

But for starters, you can change a few things in your code to make it trivially faster:

Step 1: Reduce the number of outer iterations, since we know all even numbers are non-prime.

for (let j = 3; j <= n; j += 2) {
...
}

Step 2: Reduce the inner-loop by only iterating up to a max of Sqrt of the max number. Also break out of the inner loop once we find even one factor. No need to iterate till the end. These two will give you the biggest wins.

let prime = true;    
for (let i = 2; i <= Math.sqrt(j); i++) { 
  if (j % i === 0) {
    prime = false;
    break;
  }
}
if (prime) {
  lastPrime = j;
}

Step 3: Stop computing Math.sqrt(j) since you already know the previous max value. sqrt is a (relatively) expensive operation. We can avoid it by making use of previous value.

let maxBound = 2;
let maxSquare = maxBound * maxBound;

for (let j = 3; j <= n; j += 2) {
  if (maxSquare < j) {
    maxBound++;
    maxSquare = maxBound * maxBound;
  }
  for (let i = 2; i <= maxBound; i++) {
  ...
  }
}

Step 4: If all you want is the biggest prime, walk the loop backwards and break as soon as you find one prime.

And here's the finished program which should be approximately 2 orders of magnitude faster than yours. Note that while I provided some trivial optimizations for your program, this will always pale in comparison to algorithmic optimizations that you can find here: https://math.stackexchange.com/a/893767

function getMaxPrime(n) {
  for (let j = n; j >= 3; j --) {
    let prime = true;
    for (let i = 2; i <= Math.sqrt(j); i++) {
      if (j % i === 0) {
        prime = false;
        break;
      }
    }
    if (prime) {
      maxPrime = j;
      break;
    }
  }

  console.log(maxPrime);
}

Answer 2

A basic question I ask myself when looking at sieve code is: "does this code use the modulo (%) operator?" If it does, it isn't the Sieve of Eratosthenes. You're doing trial division, which is vastly slower. Now there are certainly places and reasons for trial division, but based on your question title, you intended to use the SoE.

See Wikipedia pseudocode for example. The only operations are the two loops that involve only simple additions, a test, and a set. That's it. No multiplies, no divides, no modulos. This is absolutely key to why the algorithm is fast. The inner loop also quickly becomes sparse, in the sense that the increment keeps getting larger, so we actually run the inner loop code fewer times as we go on. Contrast to the initial code you posted, where the inner loop is running more times.

To do the basic SoE, you need a small array, then exactly and only 4 lines of code to do the sieving, with the outer loop going to sqrt(n). Then you can examine the array which will have only primes left marked. In your case, you can walk it backwards and return when you find the first occurrence. There are countless methods for optimization, but it's surprising how fast the simple basic SoE is for relatively small n (eg under 10^9, after which you really need to do a segmented SoE).

All that said, you got working code, which is a great first step. It's much easier to try different methods once you have something working.