saber - obtener numero primo javascript
¿Cómo encontrar números primos entre 0-100? (30)
¿Por qué intentar eliminar por 4 (y 6,8,10,12 ) si ya intentamos eliminar por 2 ? ¿Por qué intentar eliminar por 9 si ya se intentó eliminar por 3 ? ¿Por qué intentar eliminar por 11 si 11 * 11 = 121> 100 ? ¿Por qué intentar eliminar cualquier número impar por 2 en absoluto? ¿Por qué intentar borrar cualquier incluso por encima de 2 por cualquier cosa?
Elimina las pruebas inactivas y obtendrás un buen código de prueba para números primos por debajo de 100 .
Y su código está muy lejos de ser el peor código jamás creado. Muchos otros intentarían dividir 100 entre 99 . Pero el campeón absoluto generaría todos los productos de 2..96 con 2..96 para probar si 97 está entre ellos. Ese realmente es asombrosamente ineficiente.
Sieve sieve por supuesto, es mucho mejor, y puedes tener uno - para menores de 100 años - sin matrices de booleanos (¡y sin divisiones!) :
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"
En Javascript, ¿cómo puedo encontrar números primos entre 0 y 100? lo he pensado, y no estoy seguro de cómo encontrarlos. Pensé en hacer x% x pero encontré el problema obvio con eso. esto es lo que tengo hasta ahora: pero desafortunadamente es el peor código de todos.
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());
Al usar recursividad combinada con la regla de raíz cuadrada desde here , se verifica si un número es primo o no:
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);
}
Aquí está mi puñalada.
Cambia la inicial i=0 de 0 a lo que quieras, y la segunda i<100 de 100 a lo que sea para obtener primos en un rango diferente.
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);
}
}
Lo intenté con 10000000 , lleva algo de tiempo pero parece ser preciso.
Aquí está mi solución usando el método 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);
Aquí están el método Brute-force iterative y el método Sieve of Eratosthenes para encontrar números primos hasta n. El rendimiento del segundo método es mejor que el primero en términos de complejidad de tiempo
Fuerza bruta iterativa
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;
}
Tamiz del método de 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);
});
}
}
Aquí hay un ejemplo de una implementación de criba 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;
}
Entonces getPrimes(100) devolverá una matriz de todos los números primos entre 2 y 100 (inclusive). Por supuesto, debido a restricciones de memoria, no puede usar esto con argumentos grandes.
Una implementación de Java sería muy similar.
Aquí hay una manera de probar si el número es el número primo.
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;
}
Así es como lo resolví. Lo reescribí de Java a JavaScript, así que discúlpeme si hay un error de sintaxis.
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 número, n , es primo si no es divisible por ningún otro número más que por 1 y sí mismo. Además, es suficiente verificar los números [2, sqrt (n)].
Creé un JSFiddle que muestra cómo debería funcionar de forma legible,
La idea es tener dos funciones isPrime y getPrimeNumbers para separar la funcionalidad, además de utilizar Math.pow y el valor inicial de 2, ya que siempre debe estar allí, consulte jsfiddle attached 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);
})();
};
Cualquiera que sea el idioma, una de las mejores y más accesibles formas de encontrar números primos dentro de un rango es usar un sieve .
No voy a darte código, pero este es un buen punto de partida.
Para un rango pequeño, como el tuyo, el más eficiente sería calcular previamente los números.
Esta es la forma más rápida de calcular números primos en JavaScript, en función del valor principal anterior.
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;
}
Prueba
var value = 0, result = [];
for (var i = 0; i < 10; i++) {
value = nextPrime(value);
result.push(value);
}
console.log("Primes:", result);
Salida
Primes: [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]
Es más rápido que otras alternativas publicadas aquí, porque:
- Alinea el límite del bucle con un entero, que funciona mucho más rápido;
- Utiliza un ciclo de iteración más corto, omitiendo números pares.
Puede proporcionarle los primeros 100.000 números primos en aproximadamente 130 ms, o los primeros números primos de 1 m en aproximadamente 4 segundos.
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>"
);
}
Esta es mi 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));
He modificado ligeramente el algoritmo Sieve of Sundaram para cortar las iteraciones innecesarias y parece ser muy rápido.
Este algoritmo es en realidad dos veces más rápido que la share más aceptada bajo este tema. La resolución de los primos 78498 entre 0 - 1M toma como 20 ~ 25 mseg en Chrome 55 y <90 mseg en FF 50.1. También @ vitaly-t''s obtiene el primer algoritmo que se ve interesante pero también resulta mucho más lento.
Este es el algoritmo central. Uno podría aplicar segmentación y subprocesamiento para obtener resultados excelentes.
"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);
Los límites de bucle explicados:
Al igual que el Tamiz de Erasthotenes, el algoritmo Tamiz de Sundaram también tacha algunos enteros seleccionados de la lista. Para seleccionar qué números enteros para tachar la regla es i + j + 2ij ≤ n donde i y j son dos índices yn es el número total de elementos. Una vez que tachamos cada i + j + 2ij, los números restantes se duplican y se oddifican (2n + 1) para revelar una lista de números primos. La etapa final es de hecho el descuento automático de los números pares. La prueba está maravillosamente explicada here .
Sieve of Sundaram es solo rápido si los índices de inicio y finalización de los bucles se seleccionan correctamente de modo que no haya eliminación (o mínima) redundante (múltiple) de los no primos. Como necesitamos los valores de iyj para calcular los números para tachar, i + j + 2ij hasta n veamos cómo podemos acercarnos.
i) Entonces tenemos que encontrar el valor máximo que i y j pueden tomar cuando son iguales. Que es 2i + 2i ^ 2 = n. Podemos resolver fácilmente el valor positivo para i usando la fórmula cuadrática y esa es la línea con t = (Math.sqrt(4+8*n)-2)/4,
j) El índice de bucle interno j debe comenzar desde iy correr hasta el punto en que puede ir con el valor i actual. No mas que eso. Como sabemos que i + j + 2ij = n, esto se puede calcular fácilmente como u = (ni)/(1+2*i);
Si bien esto no eliminará por completo los cruces redundantes, eliminará "en gran medida" la redundancia. Por ejemplo, para n = 50 (para verificar los primos hasta 100) en lugar de hacer 50 x 50 = 2500, haremos solo 30 iteraciones en total. Entonces, claramente, este algoritmo no debe considerarse como una complejidad de tiempo O (n ^ 2).
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
entre los cuales solo hay 5 duplicados. 22, 31, 37, 40, 49. La redundancia es de alrededor del 20% para n = 100, sin embargo aumenta a ~ 300% para n = 10M. Lo que significa que una mayor optimización de SoS tiene el potencial para obtener los resultados incluso más rápido a medida que n crece. Entonces, una idea podría ser la segmentación y mantenerse pequeño todo el tiempo.
Muy bien ... He decidido llevar esta búsqueda un poco más allá.
Después de un examen cuidadoso de los cruces repetidos, he tomado conciencia del hecho de que, a excepción de i === 1 caso, si uno o ambos del índice i o j están entre 4,7,10, 13,16,19 ... series, se genera un cruce duplicado. Luego, permitiendo que el bucle interno gire solo cuando i%3-1 !== 0 , se logra un corte adicional como 35-40% del número total de bucles. Entonces, por ejemplo, para los enteros de 1M, el recuento total de turnos anidados bajó a 1M de 1.4M. Guau..! Estamos hablando casi de O (n) aquí.
Acabo de hacer una prueba. En JS, solo un bucle vacío que cuenta hasta 1B lleva como 4000ms. En el algoritmo modificado a continuación, encontrar los números primos hasta 100M toma la misma cantidad de tiempo.
También implementé la parte de segmentación de este algoritmo para impulsar a los trabajadores. Para que podamos usar múltiples hilos también. Pero ese código seguirá un poco más tarde.
Así que permítanme presentarles el Tamiz de Sundaram modificado probablemente en su mejor momento cuando no está segmentado. Calculará los números primos entre 0-1M en aproximadamente 15-20ms con Chrome V8 y 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);
Bueno ... finalmente creo que he implementado un tamiz (que se originó a partir de la ingeniosa Sieve de Sundaram) de modo que es el tamiz de JavaScript más rápido que pude haber encontrado en Internet, incluyendo el "Probable solo tamiz de Eratóstenes" o el "Tamiz de Atkins". También esto está listo para los trabajadores de la web, multi-threading.
Piénsalo de esta manera. En esta humilde PC AMD para un solo hilo, se necesitan 3.300 ms para JS solo para contar hasta 10 ^ 9 y los siguientes SoS segmentados optimizados me darán los números primos 50847534 hasta 10 ^ 9 solo en 14,000 ms. Lo que significa 4.25 veces la operación de solo contar. Creo que es impresionante.
Puedes probarlo por ti mismo;
console.time("tare");
for (var i = 0; i < 1000000000; i++);
console.timeEnd("tare");
Y aquí les presento a la segmentada Seieve of Sundaram en su mejor momento.
"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);
No estoy seguro de si es mejor que esto. Me encantaría escuchar tus opiniones.
La respuesta de Luchian le da un enlace a la técnica estándar para encontrar primos.
Un enfoque menos eficiente, pero más simple es convertir su código existente en un bucle anidado. Observe que está dividiendo por 2,3,4,5,6 y así sucesivamente ... y conviértalo en un ciclo.
Dado que esto es tarea, y dado que el objetivo de la tarea es ayudarte a aprender programación básica, una solución que sea simple, correcta pero algo ineficiente debería estar bien.
Modifiqué la respuesta de Rinto solo para aquellos que no quieren usar el método de solicitud y solo quieren que el programa imprima números primos. esta funcionando
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
}
}
Para encontrar números primos entre 0 y n. Solo tiene que verificar si un número x se puede dividir por cualquier número entre 0 - (raíz cuadrada de x). Si pasamos ny para encontrar todos los números primos entre 0 y n, la lógica se puede implementar como:
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;
}
Primero, cambie su código interno por otro ciclo ( for y while ) para que pueda repetir el mismo código para diferentes valores.
Más específico para su problema, si desea saber si un n dado es primo, debe dividirlo para todos los valores entre 2 y sqrt (n). Si alguno de los módulos es 0, no es primo.
Si quiere encontrar todos los primos, puede acelerarlo y verificar n solo dividiendo por los primos encontrados previamente. Otra forma de acelerar el proceso es el hecho de que, además de 2 y 3, todos los números primos son 6*k más o menos 1.
Qué tal algo como esto.
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>'');
}
Tamiz de Eratóstenes. su aspecto poco pero es simple y funciona!
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);
Te conviene, si vas a utilizar cualquiera de los algoritmos de gazillion que te presentarán en este hilo, para aprender a memorizar algunos de ellos.
Un número es primo si no es divisible por otros primos inferiores al número en cuestión.
Entonces esto crea una matriz de primes . Prueba cada nuevo candidato impar n para la división contra los primes encontrados existentes menores que n . Como optimización, no considera los números pares y precede a 2 como paso final.
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);
Una lista creada con las nuevas funciones de ES6, especialmente con generador. Vaya a https://codepen.io/arius/pen/wqmzGp en catalán para las clases con mis alumnos. Espero que le sea útil.
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);
Use la siguiente función para averiguar los números primos:
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
}
Y este famoso código de un famoso 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));
compruebe que el número es primo o no con la función 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;
}
Aquí está la demostración en vivo de este script: http://jsfiddle.net/K2QJp/
Primero, realice una función que probará si un número único es primo o no. Si desea ampliar el objeto Number, puede hacerlo, pero decidí mantener el código lo más simple posible.
function isPrime(num) {
if(num < 2) return false;
for (var i = 2; i < num; i++) {
if(num%i==0)
return false;
}
return true;
}
Este script pasa por cada número entre 2 y 1 menos que el número y prueba si hay algún número en el que no haya restos si divide el número por el incremento. Si hay alguno sin un resto, no es primo. Si el número es menor que 2, no es primo. De lo contrario, es primordial.
Luego haz un ciclo para recorrer los números del 0 al 100 y prueba cada número con esa función. Si es primo, muestra el número en el registro.
for(var i = 0; i < 100; i++){
if(isPrime(i)) console.log(i);
}
You can use this for any size of array of prime numbers. Espero que esto ayude
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>
<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>
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);
}
var isPrime = n => n>1&&Array.from({length:Math.floor(Math.sqrt(n))-1},(_,i)=>i+2).every(m=>n%m);
// or
var isPrime = n => n>1&&!/^(oo+)/1+$/.test(''o''.repeat(n)) // inefficient for big numbers
Array.from({length:101}, (_,i)=>i).filter(isPrime)