Код

var c = 100;
var j = 2;
var numerosPrimos = [];

for (; j < c; j++) {

  if (primo(j)) {
    numerosPrimos.push(j);
  }
  
}

console.log(numerosPrimos);

function primo(numero) {

  for (var i = 2; i < numero; i++) {

    if (numero % i === 0) {
      return false;
    }

  }

  return numero !== 1;
}

Объяснение

Примечание. Простые числа — это числа, которые могут делиться только на себя и на единицу.

Поэтому мы создали функцию:

function primo(numero) {

  for (var i = 2; i < numero; i++) {

    if (numero % i === 0) {
      return false;
    }

  }

  return numero !== 1;
}

Что на более естественном языке делает следующее:

Имея a, numeroмы итерируем от 2 до значения, numero - 1и на каждой итерации мы проверяем, делится ли какое-либо из этих чисел на numero, если да, мы возвращаемся, FALSEв противном случае мы проверяем, что введенное число не равно 1, поскольку это не считается простым числом. И если оцениваемое число не равно 1, то мы возвращаем TRUE, в противном случае возвращаем FALSE.

Поэтому в этом цикле:

for (; j < c; j++) {

  if (primo(j)) {
    numerosPrimos.push(j);
  }

}

Мы начинаем перебирать каждый из номеров итераций, проверяя функцию primo(), является ли число простым, и добавляем его в массив.

Обновлять

Из-за комментариев, которые я видел, кажется, что вам не было ясно, как работает этот алгоритм, я продолжаю объяснять его вам шаг за шагом.

Имея следующую функцию:

Запустите сниппет, чтобы посмотреть, как он работает шаг за шагом.

function primo(numero) {

  console.log("Has pasado el numero: " + numero);
  console.log("Inicio bucle desde 2 hasta " + (numero - 1));

  for (var i = 2; i < numero; i++) {

    console.log("Modulo entre " + numero + " y " + i + " = " + (numero % i));

    if (numero % i === 0) {
      console.log(i + " es un multiplo de " + numero);
      console.log(numero + " no es un numero primo porque " + i + " es un multiplo");
      return false;
    }

  }

  if (numero === 1) {
    console.log("Me has pasado el numero 1, recuerda que NO es un numero primo");
  } else {
    console.log("Como el numero ingresado no tuvo mas múltiplos entonces determinamos que SI es un numero primo.");
  }

  console.log("-------------------------------------");
}

primo(2);
primo(4);
primo(5);
primo(10);

Вычисление простых чисел всегда было очень интересной темой с точки зрения эффективности, поскольку среди практических приложений, требующих очень больших простых чисел, есть криптография. Одним из наиболее часто используемых алгоритмов в этой области является алгоритм RSA .

ПРОБЛЕМА

Требуется вычислить количество простых чисел, которые существуют в диапазоне N положительных целых чисел.

РЕШЕНИЕ

В приближении вашего решения у нас есть классическое условное определение, является ли число простым или нет:

const elementos = 100;
const primos = [];
let iteraciones = 0;

for(let candidato = 2; candidato <= elementos; candidato++) {
    let primo = true;
    for(let divisor=2; divisor < candidato; divisor++) {
        iteraciones++;
        if(candidato%divisor === 0) {
            primo = !primo;
            break;
        }
    }
    if(primo) primos.push(candidato);
}

console.log(`iteraciones: ${iteraciones}`);
console.log(primos);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Этот алгоритм может быть более эффективным. Если мы анализируем часть, где мы делим кандидата на делитель, мы делаем ряд ненужных дополнительных делений. Для этого случая при значении N=100 у нас всего 1133 итерации!!!

Объяснение

Составное число n — это любое не простое натуральное число , которое можно записать в виде:

n = a * b; { con a y b distintos de 1 y además si a >= b  entonces b <= sqrt(n) y viceversa}

Это означает, что и a, и b (делители n ) имеют максимальное значение, которое зависит друг от друга.

Тогда нет необходимости перебирать все значения от 2 до n в поисках возможных делителей n , достаточно перебирать до квадратного корня из n . И поскольку в большинстве случаев это не будет точным, мы можем пропустить десятичную часть и по умолчанию выполнять итерацию только до ближайшего целого числа.

Улучшение предыдущего алгоритма будет заключаться в следующем:

const elementos = 100;
const primos = [];
let iteraciones = 0;

for(let candidato = 2; candidato <= elementos; candidato++) {
    let primo = true;
    let maximoDivisor = Math.floor(Math.sqrt(candidato));
    for(let divisor=2; divisor <= maximoDivisor; divisor++) {
        iteraciones++;
        if(candidato%divisor == 0) {
            primo = !primo;
            break;
        }
    }
    if(primo) primos.push(candidato);
}
console.log(`iteraciones: ${iteraciones}`);
console.log(primos);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Мы сократили количество итераций до 236 итераций!!! чтобы получить тот же результат. Можно ли сделать его еще более эффективным?

загадка Эратосфена

В решете Эратосфена вас просят записать все натуральные числа от 2 до N , затем, начиная с 2, вы проходите по всему списку, отмечая (вычеркивая) все числа, кратные 2. Затем вы делаете то же самое с следующее значение списка, которое не было зачеркнуто (например, 3), и так далее, пока мы не вычеркнем все составные числа от 2 до N. В конце концов, числа, которые не были зачеркнуты на нашем экране, будут именно теми простыми числами, которые мы ищем.

Алгоритм будет примерно таким:

1. Список создается со всеми числами от 2 до N .
2. Итерации от i=2 до i <= Math.floor(Math.sqrt(N)) (из того, что мы видели ранее)
3. Если i не было зачеркнуто, выполняется итерация от j=i до Math.floor(N/i) и перечеркиваются все числа, кратные i ( i*j ) в списке.
4. Когда итерация шага 2 будет завершена, простыми числами будут те, которые не были вычеркнуты в списке.

Пример (взято из Википедии):

Чтобы реализовать этот алгоритм в Javascript, мы можем сделать следующее:

1. Создается список элементов от 2 до N :

const elementos = 100;
const criba = (new Array(elementos - 1)).fill(1);

В приведенном выше коде мы создали Массив из 99 элементов (от 2 до N есть N - 1 элементов), и мы заполнили этот Массив единицами.

2. Итерации от i=2 до i<=Math.floor(Math.sqrt(N)) :

const maxDivisor = Math.floor(Math.sqrt(elementos));
for(let i = 2; i <= maxDivisor; i++) { ... }

Приведенный выше код вычисляет квадратный корень из N и создает цикл for , который переходит от 2 к этому значению.

3. Если i не было зачеркнуто, выполняется итерация от j=i до Math.floor(N/i) и перечеркиваются все числа, кратные i ( i*j ) в списке.

//dentro del bucle for

// i representa el número que estamos probando, su posición en la lista es: i - 2
// si criba[i - 2] vale 1 significa que no ha sido tachado
if(criba[i - 2]) {
  //iteramos hasta Math.floor(elementos/i) ya que multiplicaremos i por j (múltiplos de i)
  //entre i y N hay N/i múltiplos
  for(let j = i; j <= Math.floor(elementos/i); j++){
    criba[(i*j) - 2] = 0; // recordar que debemos restar 2 para indicar el índice correcto
  }
}

В приведенном выше коде каждое кратное итерируемому значению вычеркивается путем установки его значения в списке равным нулю.

4. Когда итерация шага 2 будет завершена, простыми числами будут те, которые не были вычеркнуты в списке.

const primos = [];

criba.forEach((primo, index) => {
  if(primo) primos.push(index + 2);
});
console.log(primos);

В приведенном выше коде создается массив , называемый простыми числами , и выполняется обход сита. Для каждого не зачеркнутого элемента (значение которого равно 1) его позиция, прибавленная к 2 ( индекс + 2 ) , сохраняется в Массиве простых чисел , что и будет значением простого числа.

Реализация этого алгоритма может быть:

const elementos = 100;
const primos = [];
const criba = (new Array(elementos - 1)).fill(1);
let iteraciones = 0;

const maxDivisor = Math.floor(Math.sqrt(elementos));

for(let i = 2; i <= maxDivisor; i++) {
  if(criba[i - 2]) {
    for(let j = i; j <= Math.floor(elementos/i); j++){
      criba[(i*j) - 2] = 0;
      iteraciones++;
    }
  }
  iteraciones++;
}
criba.forEach((element, index) => {
  if(element) primos.push(index + 2);
});

console.log(`iteraciones: ${iteraciones}`);
console.log(primos);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Обратите внимание, что этот алгоритм даже более эффективен, чем два предыдущих, так как, если исключить тот факт, что мы должны создать список чисел, а затем пройти его, чтобы получить простые числа, результат достигается всего за 113 итераций!!! .

Я надеюсь, что это проясняет различные способы достижения цели, причем Решето Эратосфена является одним из самых эффективных.

Использование генератора (ES6)

Одна из возможностей состоит в том, чтобы использовать генератор, чтобы просто перебирать его и возвращать следующее простое число в последовательности на каждой итерации.

Идея проста, и нет необходимости хранить простые значения, что делается, чтобы взять идею, поднятую в сите Эратосфена, и создать итерируемую структуру, которая реализует метод next(), таким образом, что каждый вызов указанного метода возвращает простое значение, и поэтому мы можем отобразить первые nпростые целые числа.

Во-первых, нужно иметь способ перебора натуральных чисел с заданным начальным значением. Мы можем написать функцию-генератор, которая возвращает последовательность натуральных чисел (из значения n) каждый раз, когда next()вызывается функция в последовательности.

Например:

// generador de números naturales
const naturales = function* (inicio) {
  inicio = inicio < 1 ? (inicio === 0 ? 1 : -inicio) : inicio; // los naturales no son negativos
  
  yield inicio;
  yield* naturales(inicio + 1);
}

// creamos la secuencia que empiece en 1
const seq = naturales(1);

// mostramos los primeros 10 naturales:
for (let i = 0; i< 10; ++i) {
  console.log(seq.next().value);
}

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

Ahora necesitamos crear una función generadora que tome cada valor de la secuencia de números naturales y dado un primo, me devuelva todos los valores que no sean múltiplos de dicho primo. Esto es una criba sobre una secuencia de valores.

Por ejemplo:

const criba = function* (seq, primo) {
  for (let num of seq) {
    if (num % primo !== 0) {
      yield num;
    }
  }
}

Esta función recorre una secuencia de números y devuelve aquellos que no sean múltiplos de primo.

Ahora que tenemos estas 2 funciones que devuelven una secuencia, podemos escribir otra función generadora que a partir de un valor inicial devuelva el siguiente valor primo. Esto lo logramos reescribiendo la secuencia de valores naturales por aquella que tenga los valores no múltiplos del primo anterior.

Por ejemplo:

const primos = function* (seq) {
  let primo = seq.next().value;
  yield primo;
  seq = criba(seq, primo);
  yield* primos(seq);
}

En esta función se recibe una secuencia que (idealmente) inicia en un valor primo (supongamos el 2). Luego, por cada valor de la misma, crea una nueva secuencia que contiene sólo los números que no son múltiplos del primo generado, y devuelve dicho valor en cada llamado a next().

Un ejemplo del código anterior funcionando para mostrar los primeros 10 primos sería:

const naturales = function* (inicio) {
  inicio = inicio < 1 ? (inicio === 0 ? 1 : -inicio) : inicio; // los naturales no son negativos
  yield inicio;
  yield* naturales(inicio + 1);
}

const criba = function* (seq, primo) {
  for (let num of seq) {
    if (num % primo !== 0) {
        yield num;
    }
  }
}

const primos = function* (seq) {
  let primo = seq.next().value;
  yield primo;
  seq = criba(seq, primo);
  yield* primos(seq);
}

const p = primos(naturales(2));

// mostrar los primeros 10 valores primos
for(let i = 0; i < 10; ++i) {
  console.log(p.next().value);
}

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

Si bien este algoritmo tal vez no sea tan eficiente como los presentados con anterioridad, es otra forma de obtener valores primos usando generadores de Javascript para obtener una secuencia que siempre devolverá un valor primo cada vez que se llame al método next().

1. Eratosthenes algorithm encontrar todos los numeros debajo de n
2. iniciamos un array para todos los numeros en true
3. eliminamos del array los multiplos
4. agregamos a otro array los que no tienen multiplos

function eratosthenes(n) {
  var array = [],
    upperLimit = Math.sqrt(n), //(1)
    output = [];

  for (var i = 0; i < n; i++) { //(2)
    array.push(true);
  }

  for (var i = 2; i <= upperLimit; i++) {
    if (array[i]) {
      for (var j = i * i; j < n; j += i) {
        array[j] = false; //(3)
      }
    }
  }

  for (var i = 2; i < n; i++) {
    if (array[i]) {
      output.push(i); //(4)
    }
  }
  return output;
};
console.log(eratosthenes(30))

Tambien existe este algoritmo https://en.wikipedia.org/wiki/Sieve_of_Atkin es moderno para hallar los numeros primos

Вам лучше знать, что числа в парах кроме 2 не простые, выносим их из формулы; Нам нужно было бы получить нечетные числа, которые могут быть 3, 5, 7, 9, но мы знаем, что 9 кратно 3, и мы его испускаем, у нас остались бы только 3, 5 и 7, так как мы уже знаем числа. от 1 до 10, которые являются простыми числами, мы можем их опустить и начать с 11, добавляя два к двум, и поэтому нам не нужно проверять, является ли оно четным

var cantidad = 100,j=2;

function espar( x ) {
  return !( x & 1 );
}
function esMultiplo( x , multiplo ) {
  return (x % multiplo) == 0;
}

for(var i=11;i<cantidad;i+=2) {
    if (esMultiplo(i , 3) || esMultiplo(i , 5) || esMultiplo(i , 7)){
      continue;
   }
  console.log(i)         
}

Bueno yo me base en esta formula, Lo saque de la pagina: http://www.ceiploreto.es/sugerencias/ceibal/Primo_o_compuesto/cmo_saber_si_un_nmero_es_primo.html!

Use la consola para apreciar el resultado. Lo que hice fue crear dos funciones: La primera se encarga de evaluar si es o no es un numero primo. Y la segunda se encarga de que numero a que numero deseas saber los números primos.

 /* Esta primera función es la encargada de saber si el
numero ingresado es un numero primo; si en caso es primo
devuelve el numero y en caso que no lo es no devuelve
nada*/

const puederSerPrimo = (numero = undefined) => {

  /*Lo que hago aquí es que 0 y 1 decir que no son
  números primos, ya que al mandar un return sin nada
  entonces no estaríamos enviando ningún valor.*/

  if (numero === 0) return
  if (numero === 1) return
  /*El return vacío no enviara nada al array*/

  /* Lo que hice aquí fue colocar las bases de los
  números primos */
  let basesDePrimos = [2, 3, 5, 7, 11, 13]

  /* Con la ayuda de un for reviso si el numero
  ingresado es igual que alguna base de los primos */
  for (let z = 0; z <= basesDePrimos.length; z++) {
    while (numero === basesDePrimos[z]) {
      return console.log(`El ${numero} si es primo.`)
    }
  }

  /* Lo que hice aquí declarar una una variable
  divisiones para así con la ayuda de un while
  controlar el  numero de las divisiones */
  let divisiones = 0

  /* El numero de divisiones no puede ser mayor que la
  cantidad de números de las bases de los primos*/
  while (divisiones < basesDePrimos.length) {

    /* El for hace que avance 1 por 1 de casilla de el
    Array basesDePrimos*/
    for (let n = 0; n <= basesDePrimos.length; n++) {

      /* El signo % saca el residuo de una división y
      si en caso el residuo es 0, significa que no es
      un numero primo */
      let residuo = numero % basesDePrimos[n]

      while (residuo === 0) {
        return
        /*El return vacío no enviara nada al array*/
      }
    }

    /* Con divisiones++ hago que incremente el valor de
    divisiones dentro del while ya que si no
    incrementamos el valor haremos un bucle infinito*/
    divisiones++
  }

  /* Por ende si el numero al dividirse con las bases
  de los primos no obtuvo un residuo de 0, sacamos la
  conclusión que es un numero primo*/
  return console.log(`El ${numero} si es primo.`)

}

/* Esta función se encarga de saber de que numero a que
numero deseamos saber los números primos; también llama
a la función anterior y con la ayuda del for recorremos
1 por 1 los números*/
const numeroDePrimos = (inicio, final) => {
  for (let v = inicio; v <= final; v++) {

    /* Con la ayuda de un Array vacío y el push imprimo
    en la consola los numero primos encontrados*/
    let primos = []
    primos.push(puederSerPrimo(v))

  }
}

/* Aquí declaro el inicio y el final de todos los
numero que deseo saber si son primos*/
numeroDePrimos(0, 100);

Aquí la misma respuesta pero sin comentarios

  const puederSerPrimo = (numero = undefined) => {

  if (numero === 0) return
  if (numero === 1) return

  let basesDePrimos = [2, 3, 5, 7, 11, 13]

  for (let z = 0; z <= basesDePrimos.length; z++) {
    while (numero === basesDePrimos[z]) {
      return console.log(`El ${numero} si es primo.`)
    }
  }

  let divisiones = 0

  while (divisiones < basesDePrimos.length) {

    for (let n = 0; n <= basesDePrimos.length; n++) {

      let residuo = numero % basesDePrimos[n]

      while (residuo === 0) {
        return
      }
    }

    divisiones++
  }

  return console.log(`El ${numero} si es primo.`)

}

const numeroDePrimos = (inicio, final) => {
  for (let v = inicio; v <= final; v++) {

    let primos = []
    primos.push(puederSerPrimo(v))

  }
}

numeroDePrimos(0, 100);

Y si en caso quisieras imprimir en la consola todos los números de inicio a fin y aparezca si es o no es un numero primo entonces:

 const puederSerPrimo = (numero = undefined) => {
  if (numero === undefined) return console.warn(`No se 
  puede dejar vacio`)
  if (numero === 0) return console.log(`El numero 
  ${numero} no es primo.`)
  if (numero === 1) return console.log(`El numero 
  ${numero} no es primo.`)
  if (!numero) return console.error(`No se puede
  colocar texto`)

  let basesDePrimos = [2, 3, 5, 7, 11, 13]

  for (let z = 0; z <= basesDePrimos.length; z++) {
    while (numero === basesDePrimos[z]) {
      return console.log(`El ${numero} si es primo.`)
    }
  }

  divisiones = 0

  while (divisiones < 6) {

    for (let n = 0; n <= basesDePrimos.length; n++) {

      let residuo = numero % basesDePrimos[n]

      while (residuo === 0) {
        return console.log(`El ${numero} no es primo.`)
      }
    }
    divisiones++
  }

  return console.log(`El ${numero} si es primo.`)

}

const numeroDePrimos = (inicio, final) => {
  for (let v = inicio; v <= final; v++) {
    let primos = []
    primos.push(puederSerPrimo(v))

  }
}

numeroDePrimos(0, 100);

Я только добавляю к пустым возвратам console.log со строкой Templai, чтобы добавить значения, и я также добавляю два if в начале. Я надеюсь, что это было полезно для вас. Ваше здоровье !!!

Para calcular los semiprimos de un numero a, a un numero b

function findSemiprimes(rangeStart, rangeEnd) {
  let inicio = rangeStart
  let final = rangeEnd
  // configuramos el inicio 
  if (final < inicio) {
    inicio = rangeEnd
    final = rangeStart
  }

  // calculamos los primos dentro del rango
  let primos = []
  for (let i = 1; i <= final; i++) {
    if (isPrime(i)) {
      primos.push(i)
    }
  }

  let semiPrimos = []

  for (const primo of primos) {
    let primos2 = []
    for (let i = 2; i <= primo; i++) {
      if (isPrime(i)) primos2.push(i)
    }
    for (const primo2 of primos2) {
      let posible = primo * primo2
      if (posible <= final) {
        if (semiPrimos.indexOf(posible) <= 0) {
          semiPrimos.push(posible)
        }
      }
    }

  }

  semiPrimos.sort(function (a, b) {
    return a - b;
  })
  semiPrimos = semiPrimos.filter(primo => primo >= inicio)
  return semiPrimos
}


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

function main() {
  const result = findSemiprimes(20, 100);
  console.log("result:", result)
}

main()

var rango = parseInt(prompt("Ingrese un rango"));
var contador = 0;
const primos = [];
while(contador<=rango){
    var primo = contador;
    if (typeof primo== "number"){
        var ceros = 0;
        for(var i=1; i<=primo; i++){
            if(primo%i==0){
                ceros++;
            }
        }
        if(primo==0 || primo==1){
            primos[i]=null
        }
        else if(ceros==2){
            primos[i]=primo;
        }
    }else{
        alert("Numero incorrecto")
    }
    contador++;
}
// var cadena = primos.toString();
// var a = cadena.replace(/,/g, "")
// var n_Primos = a.length;
document.write(primos);

function esPrimo(n) {
  let i = 1;
  while (n % ++i != 0);
  return n == i;
}

for (let i = 2; i < 100; i++)
  if (esPrimo(i))
    console.log(i);