如何求所有素数的和

我发现了一个很好的解决方案。afmeva很到位。这就是它的工作原理。

function isPrime(val){
  //test if number is prime
  for(var i=2; i < val; i++){
    if(val % i === 0){
      return false;
    }
  }
  return true;
}

在上面的代码中，我们接受一个数字来确定它是否是素数。然后我们从2一直循环到我们的数字减1，因为我们知道我们的数字可以被它自己和1整除。如果我们的值与当前循环值的余数为零，那么我们知道它不是素数，所以爆发并这样说

这篇文章很好地解释了

function sumPrimes(num) {
  var answer = 0;
  //loop through all numbers from 2 to input value
  for(var i=2; i <= num; i++){   
    //sum only prime numbers, skip all others
    if(isPrime(i)){
      answer += i;
    }
  }
  return answer;
}
sumPrimes(977); // 73156

这是另一个很好的资源

function sumPrimes(num) {
    let arr = Array.from({length: num+1}, (v, k) => k).slice(2); 
  
  let onlyPrimes = arr.filter( (n) => { 
    let m = n-1;
    while (m > 1 && m >= Math.sqrt(n)) { 
      if ((n % m) === 0) 
        return false;
        m--;
    }
      return true;
  });
    return onlyPrimes.reduce((a,b) => a+b); 
}
sumPrimes(977);

我见过很多人把所有素数都放入数组中，为了检查一个数字是否为素数，他们从2到数字进行检查，看看是否有余数。你只需要检查奇数，只需要计数到数字的一半，因为一个数字不能被任何大于它的数字整除。这是我的解决方案：

function sumPrimes(num){
    var sum = num>=2?2:0;
    for(var i=3;i<=num;i+=2){
        var isPrime=true;
        for(var j=3;j<(i/2);j++){
            if (i%j==0)
            {
                isPrime=false;
                break;
            }
        }
        sum+=isPrime?i:0;
    }
    return sum;
}

注意：我从j=2开始，因为我们只检查奇数，所以它们永远不会被2整除。

function sumPrimes(num) {
  var sumArr= [];
  for(var i=0;i<=num;i++){
    if(isPrime(i))
      sumArr.push(i);
  }
  sumArr = sumArr.reduce(function(a,b){
    return a+b;
  })
  return sumArr;
}
function isPrime(num) {
    if(num < 2) return false;
    for (var i = 2; i < num; i++) {
        if(num%i === 0)
            return false;
    }
    return true;
}
sumPrimes(10);

这样的东西？

function isPrime(_num) {
	for(var i = 2; i < _num; i++) {
		if(!(_num % i)) {
			return false
		}
	}
	return true;
}
function sumPrimes(_num) {
	var sum = 0;
	for(var i = 2; i <= _num; i++) {
		if(isPrime(i)) {
			sum += i;
		}
	}
	return sum;
}
sumPrimes(20) // 77
sumPrimes(5) // 10

您也可以这样做。

function sumPrimes(num) {
    var sum = 0;
    for (var i = 0; i <= num; i++) {
        if (isPrime(i)) {
            sum += i;
        }
    }
    return sum;
}
function isPrime(n) {
    if (n < 2) { return false; }
    if (n !== Math.round(n)) { return false; }
    var result = true;
    for (var i = 2; i <= Math.sqrt(n); i++) {
        if (n % i === 0) {
            result = false;
        }
    }
    return result;
}

这是我的解决方案。我希望你能发现它很容易理解：

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

这里是我对n个素数的和的解决方案

function sumOfNPrimeNumber(num){
	var sum = 0;
	
	const isPrime = function(n){
		if (isNaN(n) || !isFinite(n) || n%1 || n<2) {
			return false;
		}
		if (n%2==0){
			return (n==2);
		}
		var sqrt = Math.sqrt(n);
		for (var i = 3; i < sqrt; i+=2) {
			if(n%i == 0){
				return false;
			}
		}
		return true;
	}
	const getNextPrime = function* (){
		let nextNumber = 2;
		while(true){
			if(isPrime(nextNumber)){
				yield nextNumber;
			}
			++nextNumber;
		}
	}
	
	const nextPrime = getNextPrime();
	for (var i = 0; i < num; i++) {
		sum = sum + nextPrime.next().value;
	}
	return sum;
}
console.log(sumOfNPrimeNumber(3));

以上所有答案都使用了辅助函数或不是时间效率函数。这是O（n）时间的快速递归解决方案：

// @ signature int -> int
// @ interpr: returns sum of all prime integers <= num
// assume: num is positive integer
function sumPrimes(num) {
  if (num <= 2) {
    return 2;
  }
  let i = 2;
  while (i < num) {
    if (num % i === 0) {
      return sumPrimes(num - 1)
    }
    i++;
  }
  
  return num + sumPrimes(num - 1)
}
// test
sumPrimes(10); // -> 17

以下解决方案使用Eratosthenes筛对所有小于或等于num的素数求和。第一个for循环用true填充大小等于num的数组。第二个for循环将array中的所有非素数设置为false。然后，最后一个for循环简单地遍历array，以求和数组中的值（即array[i]）等于true的所有数组索引i。

/**
 * Sum all primes lower or equal than n.
 * Uses the Eratosthenes Sieve to find all primes under n.
 */
function sumPrimes(num) {
  let array = [];
  let output = 0;
  // Fill an array of boolean with 'true' from 2 to n.
  for (let i = 0; i <= num; i++) {
    array.push(true);
  }
  // Set all multiples of primes to 'false' in the array.
  for (let i = 2; i <= Math.sqrt(num); i++) {
    if (array[i]) {
      for (let j = i * i; j <= num; j += i) {
        array[j] = false;
      }
    }
  }
  // All array[i] set to 'true' are primes, so we just need to add them all.
  for (var i = 2; i <= num; i++) {
    if (array[i]) {
      output += i;
    }
  }
  return output;
}
console.log(sumPrimes(10)); // 17
console.log(sumPrimes(977)); // 73156
console.log(sumPrimes(250_000_000)); // 197558914577

function sumPrimes(num) {
  let output = 0;
  // check if num is a prime number
  function isPrime(num) {
    for(let i = 2; i < num; i++) {
      if(num % i === 0) {
          return false;
        }
      }
      return true;
    }
      for (let i = 2; i <= num; i++) {
        if (isPrime(i)) {
          output += i;
        }
      }
      return output;
    }
    
console.log(sumPrimes(10)); // 17

这就是我为得到素数所做的。我不知道它是否是最有效的，但它有效。这是用Java编写的，但可以很容易地转换为JavaScript。希望这能帮你指明正确的方向。

final int TOTAL = 10;
int primes[] = new int[TOTAL];
int arrPos = 2;
boolean prime = false;
primes[0] = 2;
for (int i = 2; i < TOTAL; i++) {
  prime = false;
  int sqrt = (int) Math.sqrt(i);
  for (int j = 1; j < arrPos && primes[j] < sqrt; j++) {
    if (i % primes[j] != 0) {
      prime = true;
    } else {
      prime = false;
      break;
    }
  }
  if (prime == true) {
    primes[arrPos] = i;
    arrPos++;
  }
}