Comment trouver des nombres premiers entre 0 et 100?

voici un exemple d'implémentation de tamis en 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;
}

puis getPrimes(100) renverra un tableau de tous les nombres premiers entre 2 et 100 (inclusivement). Bien sûr, en raison de contraintes de mémoire, vous ne pouvez pas utiliser cela avec de grands arguments.

une implémentation Java ressemblerait beaucoup.

voilà comment je l'ai résolu. Je l'ai réécrit de Java à JavaScript, donc excusez-moi s'il y a une erreur de syntaxe.

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

un nombre, n , est un nombre premier s'il n'est divisible par aucun autre Nombre autre que par 1 et lui-même. De plus, il suffit de vérifier les nombres [2, sqrt(n)].

Voici la démo en direct de ce script: http://jsfiddle.net/K2QJp/

tout d'Abord, faire une fonction qui teste si un nombre est premier ou pas. Si vous voulez étendre l'objet nombre vous pouvez, mais j'ai décidé de garder le code aussi simple que possible.

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

ce script passe par chaque nombre entre 2 et 1 moins que le nombre et les tests s'il y a un nombre dans lequel il n'y a pas de reste si vous divisez le nombre par l'incrément. S'il est sans reste, il n'est pas premier. Si le nombre est inférieur à 2, il n'est pas premier. Sinon, il est premier.

puis faire une boucle pour boucle à travers les nombres de 0 à 100 et tester chaque nombre avec cette fonction. S'il est premier, affiche le nombre dans le journal.

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

quelle que soit la langue, l'un des meilleurs moyens et les plus accessibles de trouver des nombres premiers dans une gamme est d'utiliser un tamis .

ne va pas vous donner de code, mais c'est un bon point de départ.

Pour une petite gamme, comme la vôtre, la plus efficace serait de pré-calculer les nombres.

j'ai légèrement modifié le tamis de Sundaram algorithme pour couper les itérations inutiles et il semble être très rapide.

cet algorithme est en fait deux fois plus rapide que le plus accepté la solution de @Ted Hopp sous ce thème. Résoudre les 78498 nombres premiers entre 0-1M prend environ 20~25 msec dans Chrome 55 et < 90 msec dans FF 50.1. Aussi @vitaly-t get next premier algorithme semble intéressant, mais les résultats aussi beaucoup plus lent.

C'est l'algorithme de base. On pourrait appliquer la segmentation et le filetage pour obtenir de superbes résultats.

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

les limites de la boucle expliquées:

tout comme le tamis des Érasthotènes, le tamis de L'algorithme de Sundaram croise aussi quelques entiers sélectionnés de la liste. Pour sélectionner les nombres à rayer règle i + j + 2ij ≤ n, où i et j sont deux indices et n est le nombre de total des éléments. Une fois que nous avons barré chaque i + j + 2ij, les nombres restants sont doublés et oddifiés (2n+1) pour révéler une liste de nombres premiers. La dernière étape est en fait l'actualisation automatique des nombres pairs. C'est la preuve est magnifiquement expliqué ici .

de Sundaram n'est rapide que si les limites de début et de fin des indices de boucle sont correctement sélectionnées de telle sorte que il ne doit pas y avoir (ou peu) d'élimination redondante (multiple) des non-primes. Comme nous avons besoin de valeurs i et j Pour calculer les nombres à barrer, i + j + 2ij jusqu'à n voyons comment nous pouvons approcher.

i) nous devons donc trouver la valeur maximale que i et j peuvent prendre lorsqu'ils sont égaux. Qui est 2i + 2i^2 = N. Nous pouvons facilement résoudre la valeur positive pour i en utilisant la formule quadratique et c'est la ligne avec t = (Math.sqrt(4+8*n)-2)/4,

j) l'indice de boucle interne j doit commencer par i et remonter jusqu'au point où il peut aller avec la valeur courante I. Pas plus que cela. Comme nous savons que i + j + 2ij = n, cela peut facilement être calculé comme u = (n-i)/(1+2*i);

bien que cela n'éliminera pas complètement les passages redondants, cela éliminera" grandement " la redondance. Par exemple pour n = 50 (pour vérifier les nombres premiers jusqu'à 100) au lieu de faire 50 x 50 = 2500, nous ferons seulement 30 itérations au total. Donc clairement, cet algorithme ne devrait pas être considéré comme un O(N^2) de complexité temporelle.

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

dont il n'y a que 5 doubles. 22, 31, 37, 40, 49. La redondance est d'environ 20% pour n = 100 mais elle augmente à ~300% pour n = 10M. Ce qui signifie une optimisation supplémentaire de SoS porte le potentiel pour obtenir les résultats encore plus rapidement que n croît. Donc une idée pourrait être la segmentation et de garder n petit tout le temps.

So OK.. J'ai décidé de prendre cette quête un peu plus loin.

après un examen attentif des croisements répétés, j'ai pris conscience du fait que, à l'exception du cas i === 1 , si l'un ou l'autre des indices i ou j ou les deux se situent entre 4,7,10,13,16,19... série, un croisement double est généré. Ensuite, en permettant à la boucle intérieure de tourner seulement quand i%3-1 !== 0 , une autre réduction comme 35-40% du total nombre de boucles est atteint. Ainsi, par exemple, pour les entiers de 1m, le nombre total de tours de la boucle imbriquée a chuté à environ 1m à partir de 1,4 M. Wow..! On parle presque de O (n) ici.

je viens de faire un test. Dans JS, juste une boucle vide comptant JUSQU'à 1B prend comme 4000ms. Dans l'algorithme modifié ci-dessous, trouver les nombres premiers jusqu'à 100M prend le même temps.

j'ai également mis en œuvre la partie segmentation de cet algorithme pour pousser aux travailleurs. De sorte que nous serons en mesure d'utiliser plusieurs threads. Mais ce code suivra un peu plus tard.

alors permettez-moi de vous présenter le tamis modifié de Sundaram probablement à son meilleur quand non segmenté. Il calcule les nombres premiers entre 0 et 1 m en 15 à 20 m environ avec du Chrome V8 et du Chakracore de bord.

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

bien... enfin, je suppose que j'ai mis en œuvre un tamis (qui est originaire du tamis ingénieux de Sundaram) tel que c'est le tamis JavaScript le plus rapide que j'aurais pu trouver sur internet, y compris le "tamis Odds only D'Eratosthenes" ou le "tamis D'Atkins". Ceci est également prêt pour les travailleurs web, multi-threading.

pensez-y. Dans cet humble PC AMD pour un seul thread, il faut 3 300 ms pour JS juste pour compter jusqu'à 10^9 et le SoS segmenté optimisé suivant m'obtiendra les 50847534 nombres premiers jusqu'à 10^9 seulement en 14 000 ms. Ce qui veut dire 4,25 fois le fonctionnement d'un simple comptage. Je pense que c'est impressionnant.

, Vous pouvez le tester par vous-même;

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

et ici je vous présente à la Seieve segmentée de Sundaram à son meilleur.

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

Je ne suis pas sûr que ce soit mieux que ça. J'aimerais entendre vos opinions.

Un nombre est premier s'il n'est pas divisible par d'autres nombres premiers plus faible que le nombre en question.

donc cela construit un tableau primes . Tester chaque nouveau candidat Impair n pour la division par rapport à primes existant trouvé inférieur à n . Comme une optimisation, il ne considère même pas les nombres et prépare 2 comme une étape finale.

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

pour trouver des nombres premiers entre 0 et N. Vous avez juste à vérifier si un nombre x devient divisible par un nombre entre 0 - (racine carrée de x). Si nous passons n et que nous trouvons tous les nombres premiers entre 0 et n, la logique peut être implémentée comme -

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

la réponse de Luchian vous donne un lien vers la technique standard pour trouver des nombres premiers.

une approche moins efficace, mais plus simple est de transformer votre code existant en une boucle imbriquée. Observez que vous divisez par 2,3,4,5,6 et ainsi de suite ... et tourner en boucle.

étant donné qu'il s'agit d'un travail à domicile, et étant donné que le but du travail à domicile est de vous aider à apprendre la programmation de base, une solution qui est simple, correcte mais quelque peu inefficace devrait être fine.

en utilisant la récursion combinée avec la règle de racine carrée de ici , vérifie si un nombre est Premier ou non:

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

}

voici le moyen le plus rapide de calculer des nombres premiers en JavaScript, basé sur la valeur première précédente.

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

Test

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

Sortie

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

il est plus rapide que d'autres alternatives publiées ici, parce que:

• il aligne la limite de boucle sur un entier, ce qui fonctionne beaucoup plus vite;
• il utilise une boucle d'itération plus courte, sautant des nombres pairs.

il peut vous donner les 100.000 premiers nombres premiers en environ 130 m, ou les premiers nombres premiers 1m en environ 4 secondes.

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

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

tamis D'Eratosthène. son petit look mais son simple et il fonctionne!

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

Voici mon coup de poignard.

changez l'initiale i=0 de 0 à ce que vous voulez, et le second i<100 de 100 à n'importe quoi pour obtenir des nombres premiers dans une gamme différente.

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

j'ai essayé avec 10000000 - cela prend un certain temps mais semble être exact.

Pourquoi essayer la suppression par 4 (et 6,8,10,12 ) si nous avons déjà essayé de supprimer par 2 ? Pourquoi essayer la suppression par 9 si déjà essayé de supprimer par 3 ? Pourquoi essayer de supprimer par 11 si 11 * 11 = 121 > 100 ? Pourquoi essayer de supprimer n'importe quel nombre impair par 2 ? Pourquoi essayer de supprimer n'importe quel même ci-dessus 2 par quoi que ce soit?

éliminez les tests morts et vous obtiendrez un bon test de code pour les nombres premiers en dessous de 100 .

et votre code est très loin d'être le pire des codes. Beaucoup beaucoup d'autres tenteraient de diviser 100 par 99 . Mais le champion absolu générerait tous les produits de 2..96 avec 2..96 pour tester si 97 est parmi eux. celui-là est étonnamment inefficace.

tamis de Eratosthènes bien sûr est beaucoup mieux, et vous pouvez en avoir un-pour le sous 100s - avec pas de rangées de booléens (et pas de divisions trop!) :

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"

et ce fameux code d'une célèbre 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));

une liste construite en utilisant les nouvelles fonctionnalités de ES6, en particulier avec générateur. Aller à https://codepen.io/arius/pen/wqmzGp fait en Catalan pour les cours avec mes élèves. J'espère que vous le trouverez utile.

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


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

utilisant un tamis D'Eratosthènes, source sur Rosettacode

solution la plus rapide: 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+)+$/.test('o'.repeat(n))

tout d'abord, changez votre code intérieur pour une autre boucle ( for et while ) de sorte que vous puissiez répéter le même code pour des valeurs différentes.

Plus spécifique pour votre problème, si vous voulez savoir si un n est premier, vous devez diviser pour toutes les valeurs entre 2 et sqrt(n). Si l'un des modules est 0, il n'est pas premier.

si vous voulez trouver tous les nombres premiers, Vous pouvez accélérer et vérifier n seulement en divisant par le déjà trouvé des nombres premiers. Une autre façon d'accélérer le processus est le fait que, mis à part 2 et 3, Tous les nombres premiers sont 6*k plus ou moins 1.

il vous appartient, Si vous allez utiliser l'un des algorithmes de gazillion que vous allez être présenté dans ce fil, d'apprendre à mémoriser certains d'entre eux.

voir question D'entrevue: Quelle est la façon la plus rapide de générer des nombres premiers de façon récursive?

utilisez la fonction suivante pour trouver les nombres premiers:

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
}

vérifier que le nombre est Premier ou non avec la fonction JS

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

Voici une façon de vérifier si le nombre est le nombre premier.

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

j'ai modifié la réponse de Rinto juste pour ceux qui ne veulent pas utiliser la méthode prompt et veulent juste voir le programme imprimer des nombres premiers . son fonctionnement

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

Que dirais-tu de quelque chose comme ça.

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

C'est ma solution

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

j'ai créé un JSFiddle montrant comment il devrait fonctionner d'une manière lisible,

l'idée est d'avoir deux fonctions isPrime et getprimenumber pour séparer les fonctionnalités, ainsi que l'utilisation de mathématiques.pow et la valeur initiale de 2, comme il se doit d'être toujours là, de voir le jsfiddle attaché 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);
  })();
};

voici ma solution en utilisant le tamis de la méthode des Eratosthènes:

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

Voici la méthode Brute-force iterative et la méthode Sieve of Eratosthenes pour trouver des nombres premiers jusqu'à N. La performance de la deuxième méthode est meilleure que la première en termes de complexité de temps

Brute-force itérative

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

tamis D'Ératosthène méthode

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

Vous pouvez l'utiliser pour n'importe quelle taille de table de nombres premiers. Espérons que cette aide

 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>

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