用 O(n) 解决第七个问题

Question

我已经解决了seventh problem of Euler，上面写着：

通过列出前六个素数：2、3、5、7、11 和 13，我们可以 看到第 6 个素数是 13。

第 10001 个素数是多少？

我使用它解决了它，并且在我保存表兄弟的数组中，当它达到 10001 的长度时，我返回那个数字。该算法需要 1300 毫秒，我认为这非常低效，我在实现中具体做了什么？

var start = performance.now();

function eratosthenes(n) {
  var arr = [2], acc = 0; 
// matrix to save the found prime numbers and mark their multiples
  for(var i = 3; true; i += 2) { // loop
    if(arr.length === n) return arr[arr.length - 1]; // if the array length is equal to n return the last number
    if(!resolve(arr, i)) { // check if is multiple of the prime numbers, already found.
      arr.push(i); // if isnt multiple, save it
    }
  }
}

function resolve(array, n) {
  return array.some(cur => !(n%cur));
}
console.log(eratosthenes(10001)); // Tooks 1300 ms

var end = performance.now();
var time = end - start;

console.log(time);

Answer 1

如果是代码编写练习，最好探索早期的答案。

但是，如果您想要一个简单而快速的解决方案，那么您可以使用我创建的 prime-lib 来解决它：

import {generatePrimes} from 'prime-lib';

const seekIndex = 10_001; // index of the prime being sought
const start = Date.now();
let a, c = 0;
const i = generatePrimes({boost: seekIndex + 1});
while ((a = i.next()) && !a.done && c++ < seekIndex) ;

console.log(`Prime: ${a.value}, took ${Date.now() - start}ms`);

在我的电脑上它会吐出来：

Prime: 104759, took 5ms

而使用现代 RXJS，这变得更加简单：

import {generatePrimes} from 'prime-lib';
import {from, last} from 'rxjs';

const seekIndex = 10_001; // index of the prime being sought
const i = generatePrimes({boost: seekIndex + 1});
from(i).pipe(last()).subscribe(console.log);
//=> 104759

Answer 2

这与 גלעד ברקן 的答案具有相似的运行时间（实际上在我的机器上快了大约 10%），但不依赖于在开始之前知道近似的 max。它执行一系列 Eratosthenes 直到最大值（从 2 开始），然后加倍 max，根据先前找到的素数初始化数组中的新元素并重复。

function eratosthenes(n) {
    let prev_max = 1, max = 2, i, j;
    const primes = [], is_prime = new Array(max+1).fill(true);
    while( true ) {
      for ( i = prev_max + 1; i <= max; i++){
        if ( ! is_prime[i] ) continue;

        primes.push( i );

        if ( primes.length === n )
            return i;

        for ( j = i + i; j <= max; j += i )
            is_prime[j] = false;
      }

      const next_max = max*2;
      is_prime.length = next_max + 1;
      is_prime.fill( true, max + 1, next_max );

      for ( i = 0; i < primes.length; i++ ) {
        const prime = primes[i];
        for ( j = max + prime - max%prime; j <= next_max; j += prime )
          is_prime[j] = false;
      }
      prev_max = max;
      max = next_max;
   }
}

var start = performance.now(); 
console.log(eratosthenes(10001)); 
var end = performance.now();
var time = end - start;

console.log(time);

Answer 3

应 JaromandaX 的要求，这是 Eratosthenes 筛的代码。在我的浏览器上是 51 毫秒（OP 解决方案是 750 毫秒）

var max = 1000000;

function eratosthenes(n) {
   var arr = [], count = 0;
   for (var i = 0; i < max; i++){
   	   arr.push(true);
   }
   for (var i = 2; i < max; i++){
   	   if(arr[i]){
 
   	   	   count++;
   	   	   if(count == n){
 
   	   	   	  return i;
   	   	   } 
   	   	   for (var j = i + i; j < max; j += i ){
   	   	   	    arr[j] = false;
   	   	   }
   	   }
   }
    
}
var start = performance.now(); 
console.log(eratosthenes(10001)); 
var end = performance.now();
var time = end - start;

console.log(time);

Answer 4

欧拉筛，Pham 知道这个 :) 12ms

Uchu，我看不出你的代码在哪里标记倍数。这不就是埃拉托色尼筛应该做的吗？

JavaScript代码（这段代码其实是btilly对code的改编，优化了我的一个想法）：

var start = performance.now();
n = 115000
a = new Array(n+1)
total = 0
s = []
p = 1
count = 0
while (p < n){
  p = p + 1

  if (!a[p]){
    count = count + 1
    if (count == 10001){
      console.log(p);
      end = performance.now();
      time = end - start;

      console.log(time);
      break;
    }
    a[p] = true
    s.push(p)

    limit = n / p
    new_s = []

    for (i of s){
      j = i
      while (j <= limit){
        new_s.push(j)
        a[j*p] = true;
        j = j * p
      }
    }
    s = new_s
  }
}