Wie kann ich die Summe aller Primzahlen?

Arbeite ich an einer übung, um die Summe aller Primzahlen von 2 bis der parameter. Ich habe gearbeitet, so weit in den code, bin aber stecken geblieben. Ich glaube, dass durch die Verwendung der splice-Funktion, ich bin eigentlich überspringen eines Elements aufgrund einer geänderten Indizes.

function sumPrimes(num) {
  var primearray = [];
  var sum = 0;
  for(var i =2; i <= num; i++){
    primearray.push(i);
  }

  for(var j = 0; j < primearray.length; j++) {
    console.log(primearray[j]);
    if ((primearray[j]%2===0) && (primearray[j] >2)) {
      primearray.splice(j,1);
    } else if ((primearray[j]%3===0) && (primearray[j] > 3)) {
      primearray.splice(j,1);
      console.log(primearray);
    } else if ((primearray[j]%5===0) && (primearray[j] > 5)) {
      primearray.splice(j,1);
    } else if ((primearray[j]%7===0) && (primearray[j] > 7)) {
      primearray.splice(j,1);
    }
  }
  sum = primearray.reduce();
  return sum;
}

sumPrimes(30);

Habe ich nicht verwertet, reduzieren " Funktion noch nicht, weil ich arbeite noch immer an der if-else-Anweisungen.

Es ist selten eine gute Idee, um Chaos mit einer Sammlung, während Sie versuchen, zu Durchlaufen es. Warum nicht prüfen, ob eine Zahl eine Primzahl ist, bevor Sie schieben Sie es auf das array?
Wie finde Primzahlen zwischen 0 - 100? in JavaScript
^ Was Matt sagte. Ich denke, Sie können das problem beheben, nur durch Dekrementieren j wenn Sie splice etwas aus der Reihe. Aber ich sehe nicht ein, warum Sie es tun auf diese Weise. Es wird nicht die Skala, auf alle.

InformationsquelleAutor Eric Park | 2015-06-24

arrays javascript

1

Fand ich eine ziemlich gute Lösung für das gleiche problem. afmeva war vor Ort auf. Dies ist, wie es funktioniert.
```
function isPrime(val){

  //test if number is prime
  for(var i=2; i < val; i++){
    if(val % i === 0){
      return false;
    }
  }
  return true;
}
```
Im obigen code wir akzeptieren eine Reihe, um zu bestimmen, ob oder nicht es ist eine Primzahl. Wir haben dann loop aus zwei ganzen Weg, bis unsere Nummer minus eins, weil wir wissen, dass unsere Zahl teilbar durch sich selbst und eins. Wenn der Rest unserer Wert mit der aktuellen loop-Wert null ist, dann wissen wir, es ist nicht prim, so brechen aus und sagen so.

Dieser Artikel erklärt sehr gut,
```
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
```
Hier ist eine weitere gute Ressource

InformationsquelleAutor Nicholas Beaudoin

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

InformationsquelleAutor Peter Eskandar

sowas?

JS:

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

InformationsquelleAutor afmeva

Könnten Sie es auch tun.

JS:

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

InformationsquelleAutor saga

Hier ist meine Lösung. Ich hoffe, Sie finden es einfach zu interpretieren:

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

InformationsquelleAutor Yup.

JS:

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

InformationsquelleAutor Iffy

hier ist meine Lösung, um die Summe von n Primzahl

JS:

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

InformationsquelleAutor ganesh phirke

-1

Dies ist, was ich getan habe, um Primzahlen. Ich weiß nicht, ob es das effizienteste, aber es funktioniert. Dies ist in Java, aber kann leicht umgewandelt JavaScript. Hoffentlich wird dies helfen, zeigen Sie in die richtige Richtung.
```
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++;
  }
}
```
- Ich würde nur eine leichte Veränderung dieser, in der inneren Schleife ist es nicht notwendig, den ganzen Weg zu gehen, durch die aktuelle Liste der Primzahlen nur bis zur Quadratwurzel der Zahl, die Sie überprüfen möchten, so ändern Sie es zu... for (int j = 1; j<arrPos && Primzahlen[j]^2<i; j++)
- Ah, danke. Ich hab nie darüber nachgedacht, dass bevor.
- Und würde ich eine Liste statt einem array, ich würde also nicht zu befürchten, halten eine separate arrPos und die Zuweisung ein array, der mehr Elemente, als ich brauche.
- Ich Stimme mit Ihnen überein, aber wenn TOTAL klein ist es nicht wirklich wichtig ist.
- 1 ist nicht prim.
- Danke für den Fang, die.
InformationsquelleAutor imtheman

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.