Comment trouver des nombres premiers entre - 100?
En Javascript, comment trouver les nombres premiers compris entre 0 et 100? J'y ai pensé et je ne sais pas comment les trouver. Je pensais faire x% x mais j’ai trouvé le problème évident qui se posait là-dedans.
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());
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;
}
Alors getPrimes(100) retournera un tableau de tous les nombres premiers compris entre 2 et 100 (inclus). Bien sûr, en raison de contraintes de mémoire, vous ne pouvez pas utiliser cela avec des arguments volumineux.
Une implémentation Java ressemblerait beaucoup.
Voici comment je l'ai résolu. Réécrivez-le de Java à JavaScript, alors 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 que celui de 1 et lui-même. En outre, il suffit de vérifier les nombres [2, sqrt (n)].
Voici la démonstration en direct de ce script: http://jsfiddle.net/K2QJp/
Commencez par créer une fonction qui testera si un seul nombre est premier ou non. Si vous souhaitez étendre l'objet Number, 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 parcourt chaque nombre entre 2 et 1 inférieur au nombre et teste s'il existe un nombre dans lequel il n'y a pas de reste si vous divisez le nombre par l'incrément. S'il y en a sans reste, ce n'est pas premier. Si le nombre est inférieur à 2, il n'est pas premier. Sinon, c'est premier.
Faites ensuite une boucle for pour parcourir les nombres de 0 à 100 et testez chaque nombre avec cette fonction. S'il est premier, indiquez le nombre dans le journal.
for(var i = 0; i < 100; i++){
if(isPrime(i)) console.log(i);
}
Quelle que soit la langue utilisée, l'un des meilleurs et des plus accessibles moyens de recherche des nombres premiers dans une plage consiste à utiliser un tamis .
Je ne vais pas vous donner de code, mais c'est un bon point de départ.
Pour une petite gamme, comme la vôtre, le plus efficace serait de pré-calculer les nombres.
J'ai légèrement modifié le Sieve of Sundaram algorithme pour couper les itérations inutiles et il semble être très rapide.
Cet algorithme est en réalité deux fois plus rapide que la solution la plus acceptée @Ted Hopp sous cette rubrique. La résolution des nombres premiers entre 78498 entre 0 et 1 M prend environ 20 ~ 25 ms sous Chrome 55 et <90 ms sous FF 50.1. Aussi @ vitaly-t aura le prochain algorithme principal a l’air intéressant mais aussi beaucoup plus lent.
C'est l'algorithme de base. On pourrait appliquer la segmentation et le threading pour obtenir des résultats superbes.
"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 boucle expliquées:
Tout comme le Sieve of Erasthotenes, l’algorithme Sieve of Sundaram supprime également certains entiers sélectionnés de la liste. Pour sélectionner les nombres entiers à rayer de la règle, on obtient i + j + 2ij ≤ n, où i et j sont deux indices et n le nombre total d'éléments. Une fois tous les i + j + 2ij remplis, les nombres restants sont doublés et oddifiés (2n + 1) afin de 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 .
Le tamis de Sundaram n’est rapide que si les limites de début et de fin des index de boucle sont correctement sélectionnées, de sorte qu’il n’y ait aucune élimination (ou minimisation) redondante (multiple) des non-premiers. Comme nous avons besoin des valeurs i et j pour calculer les nombres à rayer, i + j + 2ij jusqu'à n, voyons comment nous pouvons nous approcher.
i) Il faut donc trouver la valeur maximale que i et j peuvent prendre quand elles sont égales. 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 droite avec t = (Math.sqrt(4+8*n)-2)/4,
j) L'indice de boucle interne j doit partir de i et aller jusqu'au point où il peut aller avec la valeur i actuelle. Pas plus que ça. Puisque nous savons que i + j + 2ij = n, ceci peut facilement être calculé comme suit: u = (n-i)/(1+2*i);
Bien que cela ne supprime pas complètement les passages à niveau redondants, il supprimera "grandement" la redondance. Par exemple, pour n = 50 (pour rechercher des nombres premiers allant jusqu'à 100) au lieu de faire 50 x 50 = 2500, nous ne ferons que 30 itérations au total. Donc, clairement, cet algorithme ne devrait pas être considéré comme un O (n ^ 2) complexité de temps.
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
parmi lesquels il n'y a que 5 doublons. 22, 31, 37, 40, 49. La redondance est d’environ 20% pour n = 100, mais augmente jusqu’à 300% pour n = 10M. Ce qui signifie qu'une optimisation supplémentaire de SoS offre le potentiel nécessaire pour obtenir les résultats encore plus rapidement à mesure que n grandit. Donc, une idée pourrait être la segmentation et de rester petit tout le temps.
Tellement OK .. J'ai décidé d'aller un peu plus loin dans cette quête.
Après un examen minutieux des passages répétés, je me suis rendu compte que, à l'exception de i === 1 cas, si l'une ou les deux valeurs de l'indice i ou j se situent parmi 4,7,10,13,16, 19 ... série, un croisement des doublons est généré. Puis, en laissant la boucle interne tourner uniquement lorsque i%3-1 !== 0, on obtient une réduction supplémentaire de l'ordre de 35 à 40% du nombre total de boucles. Ainsi, par exemple, pour les entiers 1M, le nombre total de tours de la boucle imbriquée a été ramené à environ 1M à partir de 1,4M. Sensationnel..! Nous parlons presque O(n) ici.
Je viens de faire un test. En JS, une boucle vide comptant jusqu'à 1 B prend environ 4000 ms. Dans l’algorithme modifié ci-dessous, la recherche des nombres premiers jusqu’à 100 Mo prend le même temps.
J'ai également implémenté la partie segmentation de cet algorithme dans Push to the workers. Pour pouvoir utiliser plusieurs threads également. Mais ce code suivra un peu plus tard.
Alors permettez-moi de vous présenter le tamis de Sundaram modifié probablement à son meilleur lorsqu'il n'est pas segmenté. Il calculera les nombres premiers entre 0 et 1 M dans environ 15 à 20 ms avec Chrome V8 et Edge ChakraCore.
"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);Eh bien ... enfin je suppose que j'ai mis en place un tamis (qui provient de l'ingénieux tamis de Sundaram) de sorte qu'il soit le tamis JavaScript le plus rapide que j'aurais pu trouver sur Internet, y compris le "tamis de Eratosthenes" "Tamis d'Atkins". En outre, cela est prêt pour les travailleurs Web, multi-threading.
Pensez-y de cette façon. Dans cet humble PC AMD pour un seul thread, il faut 3 300 ms à JS pour compter jusqu'à 10 ^ 9 et le SoS segmenté optimisé suivant m'obtiendra les nombres premiers 50847534 jusqu'à 10 ^ 9 en 14 000 ms. Ce qui signifie 4,25 fois l'opération de comptage. Je pense que c'est impressionnant.
Vous pouvez le tester vous-même;
console.time("tare");
for (var i = 0; i < 1000000000; i++);
console.timeEnd("tare");Et ici je vous présente la meilleure segmentée Seieve of Sundaram.
"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 sais pas si ça va mieux que ça. J'aimerais entendre vos opinions.
Un nombre est un nombre premier s'il n'est pas divisible par d'autres nombres premiers inférieurs au nombre en question.
Donc, cela crée un tableau primes. Teste chaque nouveau candidat impair n pour la division par rapport à un primes trouvé inférieur à n. En tant qu'optimisation, elle ne considère pas les nombres pairs et ajoute le code 2 avant la fin.
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 compris entre 0 et n. Il suffit de vérifier si un nombre x devient divisible par un nombre compris entre 0 - (racine carrée de x). Si nous passons n et que nous trouvons tous les nombres premiers compris 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;
}
Voici le moyen le plus rapide de calculer les nombres premiers en JavaScript, en fonction de la valeur principale 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;
}
Tester
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 les autres alternatives publiées ici, car:
- Il aligne la limite de la boucle sur un entier, ce qui fonctionne beaucoup plus rapidement.
- Il utilise une boucle d'itération plus courte, en sautant des nombres pairs.
Il peut vous donner les 100 000 premiers nombres premiers en environ 130 ms ou les 1 m en 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>"
);
}L’utilisation de la récursion combinée à la règle de racine carrée de ici permet de vérifier 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);
}
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 consiste à transformer votre code existant en une boucle imbriquée. Observez que vous divisez par 2,3,4,5,6 et ainsi de suite ... et transformez-le en boucle.
Étant donné qu’il s’agit d’un devoir et que son but est de vous aider à apprendre la programmation de base, une solution simple, correcte mais quelque peu inefficace devrait suffire.
Et ce code célèbre d'un 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));
Tamis d'Eratosthenes. c'est un peu look mais c'est simple et ça marche!
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);
Utilisation de Sieve of Eratosthenes, 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+)\1+$/.test('o'.repeat(n))Vous pouvez aussi essayer cette méthode, celle-ci est basique mais facile à comprendre:
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 +",");
}
}
Voici le moyen très simple de calculer les nombres premiers entre une plage donnée (1 à limiter).
Solution simple :
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;
}
Pourquoi essayer de supprimer par 4 (et 6,8,10,12) si nous avons déjà essayé de supprimer par 2? Pourquoi essayer de supprimer 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 un nombre impair de 2? Pourquoi essayer d’en supprimer, même au-dessus de 2, par quoi que ce soit?
Éliminez les tests morts et vous obtiendrez un bon test de code pour les nombres premiers inférieurs à 100.
Et votre code est très loin d’être le pire code de tous les temps. Beaucoup de beaucoup d’autres essaient de diviser 100 par 99. Mais le champion absolu générerait tous les produits de 2..96 avec 2..96 pour vérifier si 97 est parmi eux. Celui-là est vraiment incroyablement inefficace.
Tamis d'Eratosthenes bien sûr, c'est beaucoup mieux, et vous pouvez en avoir un - pour les sous 100s - avec pas de tableaux de booléens (et pas de divisions aussi!) :
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"
Voici mon coup de poignard.
Changez le i=0 initial de 0 en ce que vous voulez et le second i<100 de 100 en tout autre pour obtenir des nombres premiers dans une plage 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);
}
}
Je l'ai essayé avec 10000000 - cela prend du temps mais semble être précis.
<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>
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);
Une liste construite en utilisant les nouvelles fonctionnalités de ES6, en particulier avec un générateur . Allez à https://codepen.io/arius/pen/wqmzGp made in Catalan pour les cours avec mes étudiants. J'espère que tu trouves cela utile.
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);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 seconde méthode est meilleure que la première en termes de complexité temporelle
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;
}
Méthode au tamis d'Eratosthenes
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);
});
}
}
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 pas 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;
}
J'ai créé un JSFiddle montrant comment cela devrait fonctionner de manière lisible,
l'idée est d'avoir deux fonctions isPrime et getPrimeNumbers pour séparer les fonctionnalités, ainsi que d'utiliser Math.pow et la valeur initiale de 2, comme il se doit toujours y être, voir le jsfiddle joint 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);
})();
};
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);
}
Voici ma solution en utilisant la méthode Sieve of Eratosthenes:
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);
Ceci 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));
Vous pouvez l'utiliser pour n'importe quelle taille de tableau de nombres premiers. J'espère que cela t'aides
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>Si vous utilisiez l'un des nombreux algorithmes qui vous seront présentés dans ce fil de discussion, il vous incomberait d'apprendre à en mémoriser certains.
Voir Question de l’entrevue: Quel est le moyen le plus rapide de générer un nombre premier récursif?
Commencez par modifier votre code interne pour une autre boucle (for et while) afin de pouvoir répéter le même code pour des valeurs différentes.
Plus spécifiquement pour votre problème, si vous voulez savoir si un n donné est premier, vous devez le 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 l'accélérer et vérifier n uniquement en le divisant par les nombres premiers précédemment trouvés. Un autre moyen d’accélérer le processus est le fait que, à l’exception de 2 et 3, tous les nombres premiers sont 6*k plus ou moins 1.
Voici un moyen de vérifier si le nombre est un 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;
}
Que diriez-vous 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>');
}
J'ai modifié la réponse de Rinto uniquement pour ceux qui ne souhaitent pas utiliser la méthode Prompt et qui souhaitent simplement voir le programme imprimer des nombres premiers. ça marche
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
}
}