Находить сумму простых чисел до 250

Ответ 1

С первичным вычислением вы рассмотрели использование Сито Эратосфена? Это гораздо более элегантный способ определения простых чисел, и, суммируя результат, он прост.

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>

Ответ 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);

Вы также можете использовать это:

Ответ 3

i % factor === 0

Используйте === для сравнения. = - для назначения. Да, я сказал, что тройка равна. Тип принуждения раздражает.

Ответ 4

Вам нужен == или ===: if (i % factor == 0)

Ответ 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
  }

}

Ответ 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;
    }

Ответ 7

СогласноСите Эратосфена, я реализовал код, используя 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(","));

Ответ 8

Вот простой способ прохождения массива и реализации сита Эратосфена...

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);