Question

var sum = 0

for (i = 0; i < 250; i++) {

    function checkIfPrime() {

        for (factor = 2; factor < i; factor++) {
            if (i % factor = 0) {
                sum = sum;
            }
            else {
                sum += factor;
            }
        }
    }
}

document.write(sum);

我正在尝试检查250以下的所有素数的总和。我收到一个错误，说我在if (i % factor = 0)语句中无效我知道是在原始语句中创建的，但是在那里在if语句中引用它的任何方法吗？

Answer 1

使用素数计算时，您是否考虑过使用Sieve of Eratosthenes？这是一种更优雅的方法来确定素数，并且总结结果很简单。

var sieve = new Array();
var maxcount = 250;
var maxsieve = 10000;

// Build the Sieve, marking all numbers as possible prime.
for (var i = 2; i < maxsieve; i++)
    sieve[i] = 1;

// Use the Sieve to find primes and count them as they are found.
var primes = [ ];
var sum = 0;
for (var prime = 2; prime < maxsieve && primes.length < maxcount; prime++)
{
    if (!sieve[prime]) continue;
    primes.push(prime); // found a prime, save it
    sum += prime;
    for (var i = prime * 2; i < maxsieve; i += prime)
        sieve[i] = 0; // mark all multiples as non prime
}

document.getElementById("result").value =
      "primes: " + primes.join(" ") + "\n"
    + "count: " + primes.length + "\n"
    + "sum: " + sum + "\n";

#result {
    width:100%;
    height:180px
}

<textarea id="result">
</textarea>

（编辑）使用更新的算法，现在有两个最大的参与：

maxcount 是您希望查找的素数的最大数量
maxsieve 是一个大到足以包含 maxcount 素数的筛子的猜测

您必须通过实际检查真实的计数来验证这一点，因为有两个终止条件（1）我们达到筛网的极限并且找不到更多的质数，或者（2）我们实际上找到了我们正在寻找的东西。

如果你要将数字增加到远远大于250的数字，那么Sieve不再可行，因为它将消耗大量的内存。无论如何，我认为这一切都有道理吗？此时你真的需要自己玩Sieve而不是依赖我对它的解释。

Answer 2

function sumPrimes(num) {
  var allprimes=[];
  for(i=2;i<=num;i++){
       var notPrime = true;
        for(j=2 ;j<=i;j++){
            if(i%j===0 && i!==j){
                notPrime = false;
            }
          }

    if(notPrime === true){
        allprimes.push(i);
    }
  }

  var addPrimes = allprimes.reduce(function(a,b){
     return a+b;
  });

  console.log(addPrimes);
}

sumPrimes(250);

你可以同样使用它;

Answer 3

i % factor === 0

使用===进行比较。 =用于分配。是的我说三等于。类型强制是令人讨厌的。

Answer 4

您需要==或===：if (i % factor == 0)

Answer 5

这是一个相当不错的方法。它不像筛子那么先进，但它是一个不错的起点。注意：我使用的是ES6语法。

 /*
 * Sum the first n prime numbers
 *
 * @param n (integer)
 * @return integer 
 *
 */
function sumNprimes(n){
  const arr = [];
  let i = 2

  while (arr.length < n) {
    if (isPrime(i)) {
      arr.push(i)
    }
    i++
  } 
  return arr.reduce( (x,y) => x+y );

  /*
  * @param n (integer)
  * @return Boolean
  *
  */
  function isPrime(n) {

    if ( n < 2 ) {
      return false
    }

    for ( let i = 2; i <= Math.sqrt(n); i++ ) {
      if ( n % i === 0 ) {
          return false;
      } 
    }
    return true
  }

}

Answer 6

所以我不得不面对类似的挑战，这是我的解决方案，我希望你觉得它有用：

 function sumPrimes(num) {

      // determine if a number is prime
      function isPrime(n) {
        if (n === 2) return true;
        if (n === 3) return true;
        if (n % 2 === 0) return false;
        if (n % 3 === 0) return false;

        var  i = 5;
        var  w = 2;
        while (i * i <= n) {
            if (n % i === 0) {
                return false;
            }
            i += w;
            w = 6 - w;
        }
        return true;
      }

      // subtract 1 for 'not being prime' in my context
      var sum = isPrime(num) ? num - 1 : -1;

      for (var x = 0; x < num; x++) {
        if (isPrime(x) === true) {
          sum += x;
        }
      }

      return sum;
    }

Answer 7

按照“ Sieve of Eratosthenes”，我已经使用JS实现了代码：

function isPrime(n){
  return ((n/2 === 1 || n/3 === 1 || n/5 === 1 || n/7 === 1)?true:(n%2===0 || n%3 === 0 || n%5 ===0 || n%7 === 0)?false:true);
};

var val = 250;

let outArr = [];
for(let i=2;i<val;i++){
  if(isPrime(i)){
    outArr.push(i);
  }  
}
console.log("Prime number between 0 - "+val+" : "+outArr.join(","));

Answer 8

这是遍历数组并实现Eratosthenes筛子的简单方法...

function sumPrimes(num) {
  var t, v = [],
    w = [],
    x = [],
    y = [],
    z = 0;
  //enumerating Vee array starts at 2 as first prime number
  for (let a = 2; a <= num; a++) {
    v.push(a)
  }
  //creating a moving loop by splicing its first index
  for (let i = 0; i < v.length; i) { //ensure all items spliced 
    t = v[i]; // t as prime to be removed from Vee array 
    x.push(t); // x storage of primes
    z += t //  total of peculiar primes
    w.push(v.splice(i, 1)) //tested to move all one by one
    // prompt(v) //tested that v loses its v[i] every iteration
    //= now trying to remove others using remainder (%) vs prime t
    for (let vi in v) {
      v[vi] % t === 0 ? y.push(v.splice(vi, 1)) : ""; //recursive removal of composite items by prime t
    }
  }
  return z // returns sum of primes
}
sumPrimes(250);

您生成以2作为第一个素数的数组，您可以使用％=== 0筛选按剩余质数删除项的数组。您通过使用下一个素数循环遍历剩余数组，直到最后一个剩余素数被推送到素数数组。添加所有素数以获得总和。

找到250以下的素数之和

8 个答案: