it-swarm.com.de

Wie finde ich Primzahlen zwischen - 100?

Wie würde ich in Javascript Primzahlen zwischen 0 und 100 finden? Ich habe darüber nachgedacht und weiß nicht, wie ich sie finden kann. Ich dachte darüber nach, x% x zu machen, aber ich hatte das offensichtliche Problem damit.

var prime = function (){
var num;
for (num = 0; num < 101; num++){
    if (num % 2 === 0){
        break;
    }
    else if (num % 3 === 0){
        break;
    }
    else if (num % 4=== 0){
        break;
    }
    else if (num % 5 === 0){
        break;
    }
    else if (num % 6 === 0){
        break;
    }
    else if (num % 7 === 0){
        break;
    }
    else if (num % 8 === 0){
        break;
    }
    else if (num % 9 === 0){
        break;
    }
    else if (num % 10 === 0){
        break;
    }
    else if (num % 11 === 0){
        break;
    }
    else if (num % 12 === 0){
        break;
    }
    else {
        return num;
    }
}
};
console.log(prime());
48
user1599757

Hier ist ein Beispiel für eine Siebimplementierung in JavaScript:

function getPrimes(max) {
    var sieve = [], i, j, primes = [];
    for (i = 2; i <= max; ++i) {
        if (!sieve[i]) {
            // i has not been marked -- it is prime
            primes.Push(i);
            for (j = i << 1; j <= max; j += i) {
                sieve[j] = true;
            }
        }
    }
    return primes;
}

Dann gibt getPrimes(100) ein Array aller Primzahlen zwischen 2 und 100 (einschließlich) zurück. Aufgrund von Speicherbeschränkungen können Sie dies natürlich nicht mit großen Argumenten verwenden.

Eine Java-Implementierung würde sehr ähnlich aussehen.

67
Ted Hopp

So habe ich es gelöst. Schreibe es von Java in JavaScript um, also entschuldige mich, wenn ein Syntaxfehler vorliegt. 

function isPrime (n)
{
    if (n < 2) return false;

    /**
     * An integer is prime if it is not divisible by any prime less than or equal to its square root
     **/

    var q = Math.floor(Math.sqrt(n));

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

    return true;
}

Eine Zahl n ist eine Primzahl, wenn sie nicht durch eine andere Zahl als durch 1 und sich selbst teilbar ist. Es ist auch ausreichend, die Zahlen [2, sqrt (n)] zu überprüfen.

50
DavidS

Hier ist die Live-Demo dieses Skripts: http://jsfiddle.net/K2QJp/

Erstellen Sie zunächst eine Funktion, die testet, ob eine einzelne Zahl eine Primzahl ist oder nicht. Wenn Sie das Number-Objekt erweitern möchten, können Sie dies tun, aber ich habe beschlossen, den Code so einfach wie möglich zu halten.

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

Dieses Skript durchläuft jede Zahl zwischen 2 und 1 weniger als die Nummer und prüft, ob es eine Zahl gibt, bei der es keinen Rest gibt, wenn Sie die Zahl durch das Inkrement teilen. Wenn es einen ohne Rest gibt, ist es keine Primzahl. Wenn die Anzahl weniger als 2 ist, ist es keine Primzahl. Ansonsten ist es Primzahl.

Machen Sie dann eine for-Schleife, um die Zahlen von 0 bis 100 zu durchlaufen und testen Sie jede Zahl mit dieser Funktion. Wenn es Primzahl ist, geben Sie die Nummer in das Protokoll ein.

for(var i = 0; i < 100; i++){
    if(isPrime(i)) console.log(i);
}
26
Evan Kennedy

Unabhängig von der Sprache ist die Verwendung eines Sieve eine der besten und am besten zugänglichen Möglichkeiten, Primzahlen innerhalb eines Bereichs zu finden.

Ich werde Ihnen keinen Code geben, aber dies ist ein guter Ausgangspunkt.

Für einen kleinen Bereich, wie den Ihren, wäre die effizienteste Berechnung die Anzahl.

9
Luchian Grigore

Ich habe den Sieve of Sundaram -Algorithmus leicht modifiziert, um die unnötigen Iterationen zu reduzieren, und er scheint sehr schnell zu sein.

Dieser Algorithmus ist zwei Mal schneller als der meist akzeptierte @Ted Hopps Lösung unter diesem Thema. Das Lösen der 78498-Primzahlen zwischen 0 und 1 M dauert in Chrome 55 20 bis 25 ms und in FF 50.1 <90 ms. @ Vitaly-ts kommt zum nächsten Prim-Algorithmus sieht interessant aus, ist aber auch viel langsamer.

Dies ist der Kernalgorithmus. Man könnte Segmentierung und Threading anwenden, um hervorragende Ergebnisse zu erzielen.

"use strict";
function primeSieve(n){
  var a = Array(n = n/2),
      t = (Math.sqrt(4+8*n)-2)/4,
      u = 0,
      r = [];
  for(var i = 1; i <= t; i++){
    u = (n-i)/(1+2*i);
    for(var j = i; j <= u; j++) a[i + j + 2*i*j] = true;
  }
  for(var i = 0; i<= n; i++) !a[i] && r.Push(i*2+1);
  return r;
}

var primes = [];
console.time("primes");
primes = primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);

Die Loop-Grenzen erklärt:

Genau wie beim Sieve of Erasthotenes durchkreuzt der Sieve of Sundaram-Algorithmus einige ausgewählte Ganzzahlen aus der Liste. Um auszuwählen, welche Ganzzahlen die Regel durchstreichen soll, gilt i + j + 2ij ≤ n, wobei i und j zwei Indizes sind und n die Anzahl der Gesamtelemente ist. Wenn wir alle i + j + 2ij streichen, werden die verbleibenden Zahlen verdoppelt und ungerundet (2n + 1), um eine Liste von Primzahlen anzuzeigen. Die letzte Stufe ist in der Tat die automatische Abzinsung der geraden Zahlen. Es ist ein Beweis dafür, dass hier .

Das Sieben von Sundaram ist nur dann schnell, wenn die Start- und Endgrenzen der Schleifenindizes korrekt ausgewählt sind, so dass keine (oder minimale) redundante (mehrfache) Eliminierung der Nicht-Primzahlen erfolgt. Da wir i- und j-Werte benötigen, um die durchzustreichenden Zahlen zu berechnen, zeigen i + j + 2ij bis n, wie wir uns nähern können.

i) Wir müssen also den maximalen Wert finden, den i und j annehmen können, wenn sie gleich sind. Welches ist 2i + 2i ^ 2 = n. Wir können den positiven Wert für i leicht lösen, indem Sie die quadratische Formel verwenden. Dies ist die Zeile mit t = (Math.sqrt(4+8*n)-2)/4,.

j) Der innere Schleifenindex j sollte von i beginnen und bis zu dem Punkt laufen, an dem er mit dem aktuellen i-Wert gehen kann. Nicht mehr als das. Da wir wissen, dass i + j + 2ij = n ist, kann dies leicht als u = (n-i)/(1+2*i); berechnet werden.

Dadurch werden die redundanten Kreuzungen zwar nicht vollständig beseitigt, die Redundanz jedoch "weitgehend" beseitigt. Zum Beispiel für n = 50 (zur Überprüfung auf Primzahlen bis zu 100) werden anstelle von 50 x 50 = 2500 insgesamt nur 30 Iterationen durchgeführt. Dieser Algorithmus sollte also nicht als O (n ^ 2) -Komplexität betrachtet werden.

i  j  v
1  1  4
1  2  7
1  3 10
1  4 13
1  5 16
1  6 19
1  7 22  <<
1  8 25
1  9 28
1 10 31  <<
1 11 34
1 12 37  <<
1 13 40  <<
1 14 43
1 15 46
1 16 49  <<
2  2 12
2  3 17
2  4 22  << dupe #1
2  5 27
2  6 32
2  7 37  << dupe #2
2  8 42
2  9 47
3  3 24
3  4 31  << dupe #3
3  5 38
3  6 45
4  4 40  << dupe #4
4  5 49  << dupe #5

darunter gibt es nur 5 Duplikate. 22, 31, 37, 40, 49. Die Redundanz beträgt für n = 100 etwa 20%, steigt jedoch für n = 10M auf ~ 300%. Dies bedeutet, dass eine weitere Optimierung von SoS das Potential trägt, um mit wachsendem n noch schneller Ergebnisse zu erzielen. Eine Idee könnte also die Segmentierung sein und n die ganze Zeit klein halten.

Also OK .. Ich habe mich entschlossen, diese Suche ein bisschen weiter zu gehen.

Nach eingehender Prüfung der wiederholten Kreuzungen bin ich mir der Tatsache bewusst, dass mit Ausnahme von i === 1 der Indexwert i oder j unter 4,7,10,13,16 liegt. 19 ... wird eine doppelte Kreuzung erzeugt. Wenn die innere Schleife dann nur gedreht werden kann, wenn i%3-1 !== 0, wird ein weiterer Rückgang um 35-40% von der Gesamtzahl der Schleifen erreicht. So ist zum Beispiel bei 1M-Ganzzahlen die Gesamtzahl der geschachtelten Schleifen von 1,4M auf 1M gefallen. Beeindruckend..! Wir reden hier fast O(n).

Ich habe gerade einen Test gemacht. In JS dauert eine leere Schleife, die bis zu 1B zählt, 4000ms. In dem unten beschriebenen modifizierten Algorithmus dauert das Finden der Primzahlen bis zu 100 M dieselbe Zeit.

Ich habe auch den Segmentierungsteil dieses Algorithmus für Push an die Arbeiter implementiert. Damit wir auch mehrere Threads verwenden können. Dieser Code wird jedoch später folgen.

Darf ich Ihnen das modifizierte Sieve von Sundaram vorstellen, am besten, wenn es nicht segmentiert ist. Mit Chrome V8 und Edge ChakraCore werden die Primzahlen in etwa 15-20 ms zwischen 0-1M berechnet.

"use strict";
function primeSieve(n){
  var a = Array(n = n/2),
      t = (Math.sqrt(4+8*n)-2)/4,
      u = 0,
      r = [];
  for(var i = 1; i < (n-1)/3; i++) a[1+3*i] = true;
  for(var i = 2; i <= t; i++){
    u = (n-i)/(1+2*i);
    if (i%3-1) for(var j = i; j < u; j++) a[i + j + 2*i*j] = true;
  }
  for(var i = 0; i< n; i++) !a[i] && r.Push(i*2+1);
  return r;
}

var primes = [];
console.time("primes");
primes = primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);

Nun ja ... ich schätze, ich habe ein Sieb (das aus dem genialen Sieb von Sundaram stammt) so implementiert, dass es das schnellste JavaScript-Sieb ist, das ich über das Internet finden konnte, einschließlich der "Odds Only Sieve of Eratosthenes" oder der "Sieb von Atkins". Auch das ist für die Web Worker bereit, Multi-Threading.

Denk es so. In diesem bescheidenen AMD-PC für einen einzelnen Thread dauert es 3.300 ms, bis JS nur bis 10 ^ 9 zählt, und das folgende optimierte segmentierte SoS bringt mir die 50847534-Primzahlen bis zu 10 ^ 9 nur in 14.000 ms. Was 4.25-fache Operation bedeutet, nur zu zählen. Ich finde es beeindruckend.

Sie können es selbst testen.

console.time("tare");
for (var i = 0; i < 1000000000; i++);
console.timeEnd("tare");

Und hier stelle ich euch das segmentierte Seieve of Sundaram vom Feinsten vor.

"use strict";
function findPrimes(n){
  
  function primeSieve(g,o,r){
    var t = (Math.sqrt(4+8*(g+o))-2)/4,
        e = 0,
        s = 0;
    
    ar.fill(true);
    if (o) {
      for(var i = Math.ceil((o-1)/3); i < (g+o-1)/3; i++) ar[1+3*i-o] = false;
      for(var i = 2; i < t; i++){
        s = Math.ceil((o-i)/(1+2*i));
        e = (g+o-i)/(1+2*i);
        if (i%3-1) for(var j = s; j < e; j++) ar[i + j + 2*i*j-o] = false;
      }
    } else {
        for(var i = 1; i < (g-1)/3; i++) ar[1+3*i] = false;
        for(var i = 2; i < t; i++){
          e = (g-i)/(1+2*i);
          if (i%3-1) for(var j = i; j < e; j++) ar[i + j + 2*i*j] = false;
        }
      }
    for(var i = 0; i < g; i++) ar[i] && r.Push((i+o)*2+1);
    return r;
  }
  
  var cs = n <= 1e6 ? 7500
                    : n <= 1e7 ? 60000
                               : 100000, // chunk size
      cc = ~~(n/cs),                     // chunk count
      xs = n % cs,                       // excess after last chunk
      ar = Array(cs/2),                  // array used as map
  result = [];
  
  for(var i = 0; i < cc; i++) result = primeSieve(cs/2,i*cs/2,result);
  result = xs ? primeSieve(xs/2,cc*cs/2,result) : result;
  result[0] *=2;
  return result;
}


var primes = [];
console.time("primes");
primes = findPrimes(1000000000);
console.timeEnd("primes");
console.log(primes.length);

Ich bin mir nicht sicher, ob es noch besser wird. Ich würde gerne Ihre Meinungen hören.

8
Redu

Eine Zahl ist eine Primzahl, wenn sie nicht durch andere Primzahlen teilbar ist, die niedriger als die betreffende Zahl sind.

Dadurch wird ein primes-Array aufgebaut. Prüft jeden neuen ungeraden Kandidaten n auf Division gegen vorhandene primes, die niedriger als n sind. Als Optimierung werden keine geraden Zahlen berücksichtigt und 2 als letzten Schritt vorangestellt. 

var primes = [];
for(var n=3;n<=100;n+=2) {
  if(primes.every(function(prime){return n%prime!=0})) {
    primes.Push(n);
  }
}
primes.unshift(2);
5
weston

Primzahlen zwischen 0 und n finden. Sie müssen nur prüfen, ob eine Zahl x durch eine beliebige Zahl zwischen 0 - (Quadratwurzel von x) teilbar ist. Wenn wir n übergeben und alle Primzahlen zwischen 0 und n finden, kann die Logik als - implementiert werden. 

  function findPrimeNums(n)
    { 
       var x= 3,j,i=2,
       primeArr=[2],isPrime;
       for (;x<=n;x+=2){
           j = (int) Math.sqrt (x);
           isPrime = true;
           for (i = 2; i <= j; i++)
           {
                if (x % i == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime){
                primeArr.Push(x);
            }

        }   

        return primeArr;
    }
3
Vaibhav

Hier ist der schnellste Weg zum Berechnen von Primzahlen in JavaScript basierend auf dem vorherigen Primwert.

function nextPrime(value) {
    if (value > 2) {
        var i, q;
        do {
            i = 3;
            value += 2;
            q = Math.floor(Math.sqrt(value));
            while (i <= q && value % i) {
                i += 2;
            }
        } while (i <= q);
        return value;
    }
    return value === 2 ? 3 : 2;
}

Prüfung

var value = 0, result = [];
for (var i = 0; i < 10; i++) {
    value = nextPrime(value);
    result.Push(value);
}
console.log("Primes:", result);

Ausgabe

Primes: [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]

Es ist schneller als andere hier veröffentlichte Alternativen, weil:

  • Sie richtet das Loop-Limit an eine ganze Zahl aus, die wesentlich schneller arbeitet.
  • Es verwendet eine kürzere Iterationsschleife und überspringt gerade Zahlen.

Sie können die ersten 100.000 Primzahlen in etwa 130 ms oder die ersten 1m Primzahlen in etwa 4 Sekunden erhalten.

 function nextPrime(value) {
        if (value > 2) {
            var i, q;
            do {
                i = 3;
                value += 2;
                q = Math.floor(Math.sqrt(value));
                while (i <= q && value % i) {
                    i += 2;
                }
            } while (i <= q);
            return value;
        }
        return value === 2 ? 3 : 2;
    }

    var value, result = [];
    for (var i = 0; i < 10; i++) {
        value = nextPrime(value);
        result.Push(value);
    }

    display("Primes: " + result.join(', '));

    function display(msg) {
        document.body.insertAdjacentHTML(
            "beforeend",
            "<p>" + msg + "</p>"
        );
    }

2
vitaly-t

Durch Verwendung der Rekursion in Kombination mit der Quadratwurzelregel aus here wird geprüft, ob eine Zahl eine Primzahl ist oder nicht:

function isPrime(num){

    // An integer is prime if it is not divisible by any prime less than or equal to its square root
    var squareRoot = parseInt(Math.sqrt(num));
    var primeCountUp = function(divisor){
        if(divisor > squareRoot) {
            // got to a point where the divisor is greater than 
            // the square root, therefore it is prime
            return true;
        }
        else if(num % divisor === 0) {
            // found a result that divides evenly, NOT prime
            return false;
        }
        else {
            // keep counting
            return primeCountUp(++divisor);
        }
    };

    // start @ 2 because everything is divisible by 1
    return primeCountUp(2);

}
2
Neal

Die Antwort von Luchian gibt Ihnen einen Link zu der Standardtechnik für das Finden von Primzahlen.

Ein weniger effizienter, aber einfacher Ansatz besteht darin, aus Ihrem vorhandenen Code eine geschachtelte Schleife zu machen. Beachten Sie, dass Sie durch 2,3,4,5,6 teilen und so weiter ... und machen Sie daraus eine Schleife.

In Anbetracht dessen, dass dies Hausaufgaben sind und das Ziel der Hausaufgaben darin besteht, Ihnen beim Erlernen der grundlegenden Programmierung zu helfen, sollte eine einfache, korrekte, aber ineffiziente Lösung in Ordnung sein. 

2
Stephen C

Und dieser berühmte Code von einem berühmten JS Ninja

var isPrime = n => Array(Math.ceil(Math.sqrt(n)+1)).fill().map((e,i)=>i).slice(2).every(m => n%m);

console.log(Array(100).fill().map((e,i)=>i+1).slice(1).filter(isPrime));
1
kevin ternet

Sieb von Eratosthenes. es sieht ein bisschen aus, aber es ist einfach und es funktioniert! 

function count_prime(arg) {

    arg = typeof arg !== 'undefined' ? arg : 20; //default value
    var list = [2]
    var list2 = [0,1]
    var real_prime = []

    counter = 2
    while (counter < arg ) {
        if (counter % 2 !== 0) {
            list.Push(counter)
        }
        counter++
    }

    for (i = 0; i < list.length - 1; i++) {
        var a = list[i]
        for (j = 0; j < list.length - 1; j++) {
            if (list[j] % a === 0 && list[j] !== a) {
                list[j] = false;       // assign false to non-prime numbers
            }
        }
        if (list[i] !== false) { 
            real_prime.Push(list[i]);  // save all prime numbers in new array
        }
    }
 }
window.onload=count_prime(100);
1
longJOURNEY

Verwendung von Sieat von Eratosthenes, Quelle auf Rosettacode

schnellste Lösung: https://repl.it/@caub/getPrimes-bench

function getPrimes(limit) {
    if (limit < 2) return [];
    var sqrtlmt = limit**.5 - 2;
    var nums = Array.from({length: limit-1}, (_,i)=>i+2);
    for (var i = 0; i <= sqrtlmt; i++) {
        var p = nums[i]
        if (p) {
            for (var j = p * p - 2; j < nums.length; j += p)
                nums[j] = 0;
        }
    }
    return nums.filter(x => x); // return non 0 values
}
document.body.innerHTML = `<pre style="white-space:pre-wrap">${getPrimes(100).join(', ')}</pre>`;

// for fun, this fantasist regexp way (very inefficient):
// Array.from({length:101}, (_,i)=>i).filter(n => n>1&&!/^(oo+)\1+$/.test('o'.repeat(n))

1
caub

Sie können diese Methode auch ausprobieren, diese ist einfach, aber einfach zu verstehen:

 var tw = 2, th = 3, fv = 5, se = 7; 

 document.write(tw + "," + th + ","+ fv + "," + se + ",");


for(var n = 0; n <= 100; n++)
{

  if((n % tw !== 0) && (n % th !==0) && (n % fv !==0 ) && (n % se !==0))

  {
      if (n == 1)
      {
          continue;
      }

    document.write(n +",");
  }
}
1
monika

Hier ist der sehr einfache Weg, Primzahlen zwischen einem bestimmten Bereich (1 bis Limit) zu berechnen.

Einfache Lösung :

    public static void getAllPrimeNumbers(int limit) {

        System.out.println("Printing prime number from 1 to " + limit);

        for(int number=2; number<=limit; number++){
            //***print all prime numbers upto limit***
            if(isPrime(number)){
                System.out.println(number);
            }
        }
    }


    public static boolean isPrime(int num) {
        if (num == 0 || num == 1) {
            return false;
        }
        if (num == 2) { 
            return true;
        }

        for (int i = 2; i <= num / 2; i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
1
ManishS

Warum sollten Sie versuchen, mit 4 (und 6,8,10,12) zu löschen, wenn Sie bereits mit 2 gelöscht haben? Warum sollten Sie versuchen, mit 9 zu löschen, wenn Sie bereits versucht haben, mit 3 zu löschen? Warum sollten Sie versuchen, mit 11 if zu löschen 11 * 11 = 121> 100 ? Warum sollten Sie versuchen, eine ungerade Zahl durch 2 zu löschen? Warum sollten Sie versuchen, sogar über 2 etwas zu löschen?

Beseitigen Sie keine Tests, und Sie erhalten einen guten Code-Test für Primzahlen unter 100

Und Ihr Code ist weit davon entfernt, der schlechteste Code überhaupt zu sein. Viele viele andere würden versuchen, 100 durch 99 zu teilen. Der absolute Champion würde jedoch alle Produkte von 2..96 mit 2..96 generieren, um zu prüfen, ob 97 unter ihnen ist. Das eine ist wirklich erstaunlich ineffizient. 

Sieve of Eratosthenes ist natürlich viel besser, und Sie können eine - für die unter 100s - mit keine Arrays von Booleans (und keine spaltungen auch!) :

console.log(2)
var m3=9, m5=25, m7=49, i=3
for( ; i<100; i+=2 )
{
    if( i!=m3 && i!=m5 && i!=m7) console.log(i)
    else
    {
        if( i==m3 ) m3+=6
        if( i==m5 ) m5+=10
        if( i==m7 ) m7+=14
    }
} "DONE"
1
Will Ness

Hier ist mein Stich.

Ändern Sie den ursprünglichen i=0 von 0 in einen beliebigen Bereich und den zweiten i<100 von 100 in einen beliebigen Wert, um Primzahlen in einem anderen Bereich zu erhalten.

for(var i=0; i<100; i++){
    var devisableCount = 2;
        for(var x=0; x<=i/2; x++){
            if(i !== 1 && i !== 0 && i !== x){
                if(i%x === 0){
                   devisableCount++;
                 }
            }
        }
    if(devisableCount === 3){
        console.log(i);
    }
}

Ich habe es mit 10000000 ausprobiert - es dauert einige Zeit, scheint aber genau zu sein.

1
shanehoban
<code>
<script language="javascript">
   var n=Prompt("Enter User Value")
     var x=1;
       if(n==0 || n==1) x=0;
          for(i=2;i<n;i++)
           {
          if(n%i==0)
       {
     x=0;
     break;
       }
           }
           if(x==1)
             {
                alert(n +" "+" is prime");
             }
             else
             {
                alert(n +" "+" is not prime");
             }


          </script>

1
Rinto
            var n=100;
            var counter = 0;
            var primeNumbers = "Prime Numbers: ";
            for(var i=2; i<=n; ++i)
            {
                counter=0;
                for(var j=2; j<=n; ++j)
                {
                    if(i>=j && i%j == 0)
                    {
                        ++counter;
                    }

                }
                if(counter == 1)
                    {
                        primeNumbers = primeNumbers + i + "  ";
                    }

            }
            console.log(primeNumbers);
1
Rahul

Eine Liste, die mit den neuen Funktionen von ES6 erstellt wurde, insbesondere mit dem Generator . Gehen Sie zu https://codepen.io/arius/pen/wqmzGp , das in Katalanisch für Klassen mit meinen Schülern erstellt wurde. Ich hoffe du findest es nützlich.

function* Primer(max) { 
  const infinite = !max && max !== 0;
  const re = /^.?$|^(..+?)\1+$/; 
  let current = 1;
 
  while (infinite || max-- ) {
      if(!re.test('1'.repeat(current)) == true) yield current;
      current++
  };
};


let [...list] = Primer(100); 
console.log(list);

1
arius

Hier sind die Brute-force iterative-Methode und Sieve of Eratosthenes-Methode, um Primzahlen bis n zu finden. Die Leistung der zweiten Methode ist hinsichtlich der zeitlichen Komplexität besser als die erste

Brute-Force-Iterativ

function findPrime(n) {
  var res = [2],
      isNotPrime;

  for (var i = 3; i < n; i++) {
    isNotPrime = res.some(checkDivisorExist);
    if ( !isNotPrime ) {
      res.Push(i);
    }
  }

  function checkDivisorExist (j) {
    return i % j === 0;
  }

  return res;
}

Sieb der Eratosthenes-Methode

function seiveOfErasthones (n) {
  var listOfNum =range(n),
      i = 2;

  // CHeck only until the square of the prime is less than number
  while (i*i < n && i < n) {
    listOfNum = filterMultiples(listOfNum, i);
    i++;
  }

  return listOfNum;


  function range (num) {
    var res = [];
    for (var i = 2; i <= num; i++) {
      res.Push(i);
    }
    return res;
  }

  function filterMultiples (list, x) {
    return list.filter(function (item) {
      // Include numbers smaller than x as they are already prime
      return (item <= x) || (item > x && item % x !== 0);
    });
  }
}
0
Aditya Singh

Verwenden Sie die folgende Funktion, um Primzahlen herauszufinden: 

function primeNumbers() {
    var p
    var n = document.primeForm.primeText.value
    var d
    var x
    var prime
    var displayAll = 2 + " "
    for (p = 3; p <= n; p = p + 2) {
        x = Math.sqrt(p)
        prime = 1
        for (d = 3; prime && (d <= x); d = d + 2)
        if ((p % d) == 0) prime = 0
        else prime = 1
        if (prime == 1) {
            displayAll = displayAll + p + " "
        }
    }
    document.primeForm.primeArea.value = displayAll
}
0
user1598202

Überprüfen Sie, ob die Nummer mit der JS-Funktion Primzahl ist oder nicht

function isPrime(num)
        {
            var flag = true;
            for(var i=2; i<=Math.ceil(num/2); i++)
            {
                if((num%i)==0)
                {
                    flag = false;
                    break;
                }
            }
            return flag;    
        }
0
Satish Sharma

Ich habe ein JSFiddle erstellt, das zeigt, wie es auf lesbare Weise funktionieren sollte. 

die Idee ist, zwei Funktionen zu haben, isPrime und getPrimeNumbers, um die Funktionalität zu trennen, sowie Math.pow und den Anfangswert von 2 zu verwenden, da es immer vorhanden sein sollte. Siehe jsfiddle als Anhang. jsFiddle

window.onload = function() {
  (function() {
    var cont = document.getElementById('MainContainer');
    var curEl = document.createElement('span');
    var primeNumbers = [2];

    function fillContent() {
        var primeNumbersContent = document.createTextNode(JSON.stringify(primeNumbers));
        curEl.appendChild(primeNumbersContent);
        cont.appendChild(curEl);
    }

    function isPrime(n) {
        var divisor = 2;
        while (n > divisor) {
            if (Math.pow(divisor, 2) > n) {
                return true;
            }
            if (n % divisor == 0 || Math.sqrt(divisor) > n) {
                return false;
            } else {
                divisor++;
            }
        }
        return true;
    }

    function getPrimeNumbers(range) {
        for (var i = 3; i <= range; i+=2) {
            if (isPrime(i)) {
                primeNumbers.Push(i);
            }
        }
        fillContent(primeNumbers);
    }
    getPrimeNumbers(11);
  })();
};
0
user5589903
public static void main(String[] args) {
    int m = 100;
    int a[] =new int[m];
    for (int i=2; i<m; i++)
        for (int j=0; j<m; j+=i)
            a[j]++;
    for (int i=0; i<m; i++)
        if (a[i]==1) System.out.println(i);
}
0

Hier ist meine Lösung mit Sieve of Eratosthenes-Methode:

function gimmePrimes(num) {
  numArray = [];
  // first generate array of numbers [2,3,...num]
  for (i = 2; i <= num; ++i) {
    numArray.Push(i);
  }

  for (i = 0; i < numArray.length; ++i) {
    //this for loop helps to go through each element of array

    for (j = numArray[i]; j < numArray[numArray.length - 1]; ++j) {
      //get's the value of i'th element
      for (k = 2; j * k <= numArray[numArray.length - 1]; ++k) {
        //find the index of multiples of ith element in the array
        index = numArray.indexOf(j * k);
        if (index > -1) { //remove the multiples
          numArray.splice(index, 1);
        }
      }

    }
  }
  return numArray; //return result
}
gimmePrimes(100);
0
Nigel

Dies ist meine Lösung

//find all prime numbers
function showMePrimeNumbers(start, end){
    var primes = [];
    for(var number = start; number < end; number++){
        var primeNumberDividers = []; //there should only be 2: 1 & number
        for(var divider = 1; divider <= number; divider++){
            if(number % divider === 0){
                primeNumberDividers.Push(divider);
            }      
        }
        if(primeNumberDividers.length === 2){
            primes.Push(number);
        }
    }
    return primes;
}

console.log(showMePrimeNumbers(1, 100));           
0
codeepic

Sie können dies für eine beliebige Anzahl von Primzahlen verwenden. Hoffe das hilft

 function prime() {
   var num = 2;

   var body = document.getElementById("solution");

   var len = arguments.length;
   var flag = true;

   for (j = 0; j < len; j++) {

     for (i = num; i < arguments[j]; i++) {

       if (arguments[j] % i == 0) {
         body.innerHTML += arguments[j] + " False <br />";
         flag = false;
         break;

       } else {
         flag = true;

       }

     }
     if (flag) {
       body.innerHTML += arguments[j] + " True <br />";

     }

   }

 }

 var data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

 prime.apply(null, data);
<div id="solution">

</div>

0
Aslam

Wenn Sie einen der gazillion-Algorithmen verwenden, mit denen Sie in diesem Thread vorgestellt werden, sollten Sie einige davon lernen. 

Siehe Interviewfrage: Wie kann ich Primzahlen am schnellsten rekursiv generieren?

0
alvonellos

Ändern Sie zunächst Ihren inneren Code für eine andere Schleife (for und while), damit Sie denselben Code für verschiedene Werte wiederholen können.

Wenn Sie wissen möchten, ob eine gegebene n eine Primzahl ist, müssen Sie sie für alle Werte zwischen 2 und sqrt (n) aufteilen. Wenn eines der Module 0 ist, ist es kein Primer.

Wenn Sie alle Primzahlen finden möchten, können Sie sie beschleunigen und n nur überprüfen, indem Sie die zuvor gefundenen Primzahlen teilen. Eine weitere Möglichkeit, den Prozess zu beschleunigen, ist die Tatsache, dass alle Primzahlen außer 2 und 3 6*k plus oder weniger 1 sind.

0
SJuan76

Hier ist ein Weg, um zu testen, ob Nummer Primzahl ist. 

function isPrime(numb){
  if (numb % 2 == 0) return false;
  for (var i=3; i<= Math.sqrt(numb); i = i + 2) {
    if (numb % i == 0) {
     return false;
    }
  }
  return true;
}
0
Bray

Wie wäre es mit so etwas.

next_prime:
for (var i = 2; i < 100; i++){
    for (var e = 2; e < i; e++){
        if (i % e === 0) continue next_prime;
    }
    console.log(i + '<br>');
}
0
barrakuda

Ich habe die Antwort von Rinto nur für diejenigen modifiziert, die die Prompt-Methode nicht verwenden möchten und das Programm nur Primzahlen drucken lassen wollen. es funktioniert 

for (n = 0; n < 100; n++) {
    var x = 1;
    if (n == 0 || n == 1) x = 0;
    for (i = 2; i < n; i++) {
        if (n % i == 0) {
            x = 0;
            break;
        }
    }
    if (x == 1) {
        // if prime print the numbers 
        document.write(n);
    } else {
        // if not prime print the number do nothing 
    }
}
0
Humphrey