Generieren müssen prime zahlen in JavaScript

Ich Schreibe ein JavaScript zu generieren, die Primzahlen von 2 bis 100. Aber Es funktioniert nicht und kann nicht heraus.

wirst du mir helfen bitte?

var array = new Array(100);

for (var i=2 ; i<=array.length-1; i++) {
    if((i%2===0) || (i%3===0))
        continue;
    document.writeln(i+",");
}

Ich veränderte meine Antwort, aber jetzt ist es nicht druckt 2 & 3; wie kann ich 2 & 3...
Ergebnis :

5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97

Bitte eine bessere Beschreibung als "es funktioniert nicht". Was erwartest du, was der code tun und was tut es eigentlich?
1) Dein code prüft nur, um zu sehen, wenn die Zahl ist teilbar durch 2 oder 3 ist, 2) den Wert false zurück, nach der ersten Zahl, die nicht 'prime' gefunden. 3) Sie nie hinzufügen, neue Primzahlen zu array 4) selbst wenn Sie es hinzufügen Primzahlen zu array erhöhen Sie prime durch array[i] die überspringen viele Primzahlen.
warum "i++", statt "i+=2", sind auch zahlen, die jemals Primzahl? Sie können auch nur brauchen, untersuchen der Vergangenheit nur die Hälfte der Anzahl Ihrer Prüfung sind für einen prime...
danke, ich werde versuchen Sie es und lassen Sie wissen 🙂
2 ist der nur noch prime. In der Regel ist hard codiert als prime und der code wird davon ausgegangen, alle anderen sind ungerade.

InformationsquelleAutor NilR | 2014-02-23

  1. 7
    function isPrime(num) {
    for ( var i = 2; i < num; i++ ) {
        if ( num % i === 0 ) {
            return false;
        }
    }
    return true;
}

function display(n) {
    var arr = [2];
    for ( var i = 3; i < n; i+=2 ) {
        if ( isPrime(i) ) {
            arr.push(i);
        }
    }
    console.log(arr); //use arr result on your own
}

display(100);

    HINWEIS: Angeben n parameter in display - Funktion und Holen Sie sich die Primzahlen von 2 bis n ...

    Check-out JSFiddle

    Updateing: Beachten Sie, dass das obige Skript ist korrekt und ich bin verlassen, es ist, obwohl das hinzufügen der gleichen Funktion mit einer Funktionalität zusätzlich:

    function prime(n,flag) {
    ( typeof flag === "undefined" || flag === false ) ? flag = false : flag = true;

    function isPrime(num) {
        if ( num === 0 || num === 1 ) {
            return false;
        }
        for ( var i = 2; i < num; i++ ) {
            if ( num % i === 0 ) {
                return false;
            }
        }
        return true;
    }

    if ( flag ) {
        var arr = [2];
        for ( var i = 3; i <= n; i+=2 ) {
            if ( isPrime(i) ) {
                arr.push(i);
            }
        }
        return arr;
    } else {
        return isPrime(n);
    }
}

    Erklärung: prime Funktion erwartet zwei Parameter, der erste ist erforderlich, und die zweite ist optional. Wenn nur der erste parameter angegeben ist die Funktion zurück true oder false basierend auf der Anzahl gehört oder nicht-Primzahlen. Wenn der zweite parameter angegeben wird, wie true (oder jede andere Art außer undefined und false) - Funktion zurück array von Primzahlen aus 2 zu n. Zum Beispiel:

    console.log(prime(2)); //returns true ( 2 is prime )
console.log(prime(8)); //returns false ( 8 isn't prime )

console.log(prime(100,true)); //returns [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
    Ihre Lösung ist eher ineffizient. Die display-Schleife besser gestartet 3 und um 2 erhöht und isPrime braucht nur eine Division durch Primzahlen.
    Aktualisiert...
    Getestet hab ich die verstrichene Zeit zwischen Lösung diskutiert algorithmen und Unterschied tritt auf, sinnvoll etwa 100 Millisekunden, wenn N ist 100000
    Obwohl es variiert sehr stark...
    Sie brauchen nur zu überprüfen, bis zu der Quadratwurzel der num.

    InformationsquelleAutor tnanoba

  2. 3
    var enterNumber = prompt("Enter number: ");

for(var i=1; i<=enterNumber ;i++){

        var isPrime = true;

        for(var j=2; j<i; j++){
            if(i%j === 0){
                isPrime = false;
            }
        }
        if(isPrime === true){
            console.log(i);
        }
    }

    InformationsquelleAutor Kamil Bagi

  3. 2

    Ursprünglichen code hat zahlreiche Mängel. Zur Umsetzung der Sieb des Eratosthenes, die Sie brauchen, um hinzuzufügen, jede prime, finden Sie in ein array, und testen Sie dann die nächsten Kandidaten prime gegen jede Primzahl, die Sie bisher gefunden habe. Wenn der Kandidat nicht teilbar durch jede der Primzahlen in dem array, dann ist es eine Primzahl, und Sie können es hinzufügen, um Ihre array von Primzahlen.

    Hier ist eine funktionierende version (Demonstration):

    function start() {    
    var array = [2, 3];
    for (var i = 5; i <= 100; i += 2) {
        if (array.every(function(p) { return i % p; })) {
            array.push(i);
        }
    }
    var result = array.join(",");
    document.getElementById("output").innerHTML = result;
}
start();

    Beachten Sie, dass dies hängt davon ab, Array.der Prototyp.alle wurde in ECMAScript 5.

    Streng gesprochen ist dies nicht der SoE. Sie testen jede Zahl mehrere Male, die gegen den Zweck von SoE. Blick auf die zweite Lösung meiner Antwort, die eine SoE.

    InformationsquelleAutor p.s.w.g

  4. 1

    Haben Sie eine Menge von Möglichkeiten, dies zu erreichen.

    Waren Sie im Grunde auf dem richtigen Weg, allerdings, Sie haben zu prüfen, jede Zahl, ob es teilbar durch jede Primzahl, die Sie bestimmt so weit:

    var primes = [2],isPrime;

for (var i=3;i<100;i+=2){
    isPrime = true;
    //test the number you are examaning against
    //all the primes you found so far
    for (var j = 0;j<primes.length;j++){
        if (i%primes[j]==0){
            isPrime=false;
            break;
        }
    }
    if(isPrime){primes.push(i)}
}
console.log(primes);

    Das Ergebnis sehen Sie hier

    Oder verwenden Sie den Sieb des Eratosthenes die Art aus allen zahlen zu vermeiden, dupliziert tests.

    Eine echte Umsetzung des SoE:

    //initialize the array first
var numbers = [], primes = [], maxNumber = 100;

for(var i = 2;i<=maxNumber;i++){
 numbers.push(i);   
}

while(numbers.length){
    primes.push(numbers.shift());
    numbers = numbers.filter(
        function(i){return i%primes[primes.length-1]!=0}
    );
}

console.log(primes);

    Demo

    InformationsquelleAutor Christoph

  5. 0

    könnte dies ein effizienter Weg :

    function calcPrimes(max){
    var primes = [];
    for(var i=2; i<=max; i++){
        var isPrime = true; 
        for(var j=0; j<primes.length; j++){
            var p = primes[j];
            if( i % p === 0){
                //it is divisible by another prime, so it's not prime
                isPrime=false;
                break;
            }
            //you don't need to check primes bigger than sqrt(i)
            if(p*p > i)
                break;
         }
        if(isPrime)
            primes.push(i);
    }
    console.log(JSON.stringify(primes))
    console.log(primes.length)
}
calcPrimes(100);

    InformationsquelleAutor SinaX

  6. 0

    Hier ist ein Beispiel, wie Sie erzeugen eine unbegrenzte Anzahl von Primzahlen, mit Hilfe einer Variante des Sieb des Eratosththenes. Es ist eine wahre SoE, und führt keine trial-Abteilung, um zu bestimmen, ob eine Zahl eine Primzahl ist. Es sieht vielleicht ein wenig seltsam, aber das ist, weil es ist entworfen, um zu arbeiten, ohne irgendeine Obere Schranke.

    <input type=button value="Start" onClick="do_cancel(); do_once()">
<input type=button value="Stop" onClick="do_cancel()">
<table id="mytable"></table>

<script>
'use strict';
(function () {
    var ptable = document.getElementById("mytable");
    var prow = [2, 3];
    function insertPrimeIntoTable(prime) {
        prow.push(prime);
        if( prow.length < 10 ) return false;
        var tr = document.createElement('tr');
        for( var i = 0; i < prow.length; ++i ) {
            var cell = document.createElement('td');
            cell.appendChild( document.createTextNode( prow[i] ) );
            tr.appendChild( cell );
        }
        ptable.appendChild( tr );
        prow = [];
        return true;
    };

    var factors = [];
    function insertPrimeIntoSieve( factor ) {
        var where = factor;
        while( factors[where] )
            where += factor;
        /* while( factors.length < where ) factors.push(0); */
        factors[ where ] = factor;
    }

    var primes = [];
    var a_prime = 3, a_squared_prime = 9, maybe_prime = 3;
    var canceller;
    function do_once() {
        var factor = factors[0];
        maybe_prime += 2;
        if( factor ) {
            //if( 0 != (maybe_prime % factor) )
            // throw "Unexpected remainder.";
            insertPrimeIntoSieve( factor );
        } else if( maybe_prime < a_squared_prime ) {
            insertPrimeIntoTable( maybe_prime );
            primes.push( maybe_prime );
        } else if( maybe_prime == a_squared_prime ) {
            insertPrimeIntoSieve( a_prime );
            a_prime = primes.shift();
            a_squared_prime = a_prime * a_prime;
        } else {
            throw "Critical math failure:  Programmer or compiler is innumerate.";
        }
        factors.shift();
        canceller = window.setTimeout( do_once, 5 );
    };
    function do_cancel() {
        if( canceller ) window.clearTimeout( canceller );
        canceller = null;
    }
    window.do_once = do_once;
    window.do_cancel = do_cancel;
})();
</script>

    InformationsquelleAutor BenGoldberg

  7. 0
    function isPrime(num) {
    if (num % 2 == 0) {
        return false;
    }

    let n = Math.sqrt(num);

    for ( var i = 3; i <= n; i += 2 ) {
        if ( num % i === 0 ) {
            return false;
        }
    }

    return true;
}

function print(n) {
    var arr = [2];
    for ( var i = 3; i < n; i+=2 ) {
        if ( isPrime(i) ) {
            arr.push(i);
        }
    }
    console.log(arr);
}

print(100);

    InformationsquelleAutor user8640104

  8. 0
    Please try this,
var a = [...Array(100).keys()];
var primeNumbers = a.map(v => { 
    if (v % 2 === 0 || v % 3 === 0) { 
      if (v === 2 || v === 3) {
       return v;
      } else {
       return;
      } 
    } else {
      return v;
    }
});

primeNumbers.filter(val => val);

you will get 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97

    InformationsquelleAutor Pundalik MP

  9. 0

    Ich weiß, diese Frage 2014, aber nur im Fall, wenn OP oder jemand Fragen, wie zu erzeugen kleine Primzahlen mit Javascript, ich haben gemeinsam die kleinen JS-code in https://github.com/HMaxF/generate-small-prime-number.

    In meinem macbook pro, die ich erzeugen kann, die alle Primzahlen von 2 bis 100 Millionen, die in rund 25 Sekunden, aber Ihre Maschine in Folge variieren.

    InformationsquelleAutor hmaxf2

Schreibe einen Kommentar