Как найти простые числа от 0 до 100?

Ответ 1

Вот пример реализации сита в 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;
}

Затем getPrimes(100) вернет массив всех простых чисел между 2 и 100 (включительно). Конечно, из-за ограничений памяти вы не можете использовать это с большими аргументами.

Реализация Java будет выглядеть очень похоже.

Ответ 2

Вот как я это решил. Переписал его с Java на JavaScript, поэтому извините меня, если есть синтаксическая ошибка.

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

Число, n, является простым, если оно не делится никаким другим числом, отличным от 1 и самого. Кроме того, достаточно проверить числа [2, sqrt (n)].

Ответ 3

Вот живая демонстрация этого script: http://jsfiddle.net/K2QJp/

Сначала создайте функцию, которая будет проверять, является ли одно число простым или нет. Если вы хотите расширить объект Number, который вы можете, но я решил просто сохранить код как можно более простым.

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

Это script проходит через каждое число между 2 и 1 меньше числа и тестов, если есть любое число, в котором нет остатка, если вы разделите число на приращение. Если есть любой без остатка, он не является простым. Если число меньше 2, оно не является простым. В противном случае это просто.

Затем создайте цикл for для цикла через числа от 0 до 100 и проверьте каждый номер с помощью этой функции. Если он является простым, выведите номер в журнал.

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

Ответ 4

Независимо от языка, один из лучших и наиболее доступных способов нахождения простых чисел в диапазоне использует sieve.

Не буду давать вам код, но это хорошая отправная точка.

Для небольшого диапазона, такого как ваш, наиболее эффективным будет предварительное вычисление чисел.

Ответ 5

Я немного изменил алгоритм Sieve of Sundaram, чтобы отрезать ненужные итерации, и это кажется очень быстрым.

Этот алгоритм на самом деле в два раза быстрее, чем наиболее приемлемое @Ted Hopp решение в этом разделе. Решение 78498 простых чисел между 0 - 1М занимает примерно 20 ~ 25 мс в Chrome 55 и < 90 мс в FF 50.1. Кроме того, @vitaly-t получает следующий первичный алгоритм, выглядит интересным, но также и намного медленнее.

Это основной алгоритм. Для получения превосходных результатов можно применить сегментацию и потоки.

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

Ответ 6

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

Итак, это создает массив primes. Проверяет каждый новый нечетный кандидат n для деления на существующий найденный primes ниже n. В качестве оптимизации он не рассматривает четные числа и prepends 2 как последний шаг.

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

Ответ 7

Чтобы найти простые числа от 0 до n. Вам просто нужно проверить, является ли число x делимым на любое число между 0 - (квадратный корень из x). Если мы передадим n и найдем все простые числа между 0 и n, логика может быть реализована как -

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

Ответ 8

Ответ Лучиана дает вам ссылку на стандартную технику поиска простых чисел.

Менее эффективным, но более простым подходом является превращение существующего кода в вложенный цикл. Обратите внимание, что вы делите на 2,3,4,5,6 и так далее... и превратите это в цикл.

Учитывая, что это домашнее задание, и учитывая, что цель домашней работы - помочь вам изучить базовое программирование, простое, правильное, но несколько неэффективное решение должно быть прекрасным.

Ответ 9

Здесь самый быстрый способ вычисления простых чисел в JavaScript, основанный на предыдущем начальном значении.

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

Выход

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

Это быстрее, чем другие альтернативы, опубликованные здесь, потому что:

• Он выравнивает предел цикла с целым числом, которое работает быстрее;
• Он использует более короткий цикл итерации, пропуская четные числа.

Он может дать вам первые 100 000 простых чисел примерно за 130 мс или первые 1 м числа за 4 секунды.

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

Ответ 10

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)

Ответ 11

Зачем пытаться удалять на 4 (и 6,8,10,12), если мы уже пытались удалить на 2? Зачем пытаться удалить на 9, если уже попытался удалить 3? Зачем пытаться удалять на 11, если 11 * 11 = 121 > 100? Зачем пытаться удалить лишнее число на 2? Зачем пытаться удалять любые даже выше 2 вообще?

Устраните мертвые тесты, и вы получите хорошее тестирование кода для простых чисел ниже 100.

И ваш код очень далек от худшего кода. Многие другие попытаются делить 100 на 99. Но абсолютный чемпион будет генерировать все продукты 2..96 с помощью 2..96, чтобы проверить, является ли среди них 97. Этот действительно поразительно неэффективен.

Сито Eratoshenes, конечно, намного лучше, и вы можете иметь один - для менее 100 - с нет массивов булевых (и без делений тоже!):

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"

Ответ 12

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

Ответ 13

Используя рекурсию в сочетании с правилом квадратного корня из здесь, проверяет, является ли число простым или нет:

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

}

Ответ 14

Решето Эратосфена. его бит выглядит, но его просто и он работает!

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

Ответ 15

Здесь мой удар по нему.

Измените начальный i=0 с 0 на нужный, а второй i<100 от 100 до любого, чтобы получить простые числа в другом диапазоне.

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

Я попробовал его с помощью 10000000 - требуется некоторое время, но кажется точным.

Ответ 16

И этот знаменитый код от знаменитого 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));

Ответ 17

Список, построенный с использованием новых функций ES6, особенно с генератором. Перейдите в https://codepen.io/arius/pen/wqmzGp, сделанный на каталонском языке для занятий с моими учениками. Надеюсь, вы сочтете это полезным.

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

Ответ 18

Сначала измените свой внутренний код на другой цикл (for и while), чтобы вы могли повторить один и тот же код для разных значений.

Более конкретно для вашей проблемы, если вы хотите знать, является ли заданный n простым, вам нужно разделить его для всех значений между 2 и sqrt (n). Если какой-либо из модулей равен 0, он не является простым.

Если вы хотите найти все простые числа, вы можете ускорить его и проверить n только путем деления на ранее найденные простые числа. Другим способом ускорения процесса является тот факт, что, кроме 2 и 3, все простые числа 6*k плюс или меньше 1.

Ответ 19

Было бы так, если вы собираетесь использовать любой из алгоритмов gazillion, которые вам будут представлены в этом потоке, чтобы научиться запоминать некоторые из них.

См. Вопрос для интервью: какой самый быстрый способ рекурсивно генерировать простое число?

Ответ 20

Используйте следующую функцию для поиска простых чисел:

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
}

Ответ 21

проверить, что число просто или не с функцией 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;    
        }

Ответ 22

Вот способ проверить, является ли число простым числом.

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

Ответ 23

Я изменил ответ Rinto только тем, кто не хочет использовать метод подсказки, и просто хочу видеть, что программа печатает простые числа. его работа

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

Ответ 24

Как насчет чего-то подобного.

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

Ответ 25

Это мое решение

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

Ответ 26

Я создал JSFiddle, показывающий, как он должен работать читаемым способом,

идея состоит в том, чтобы иметь две функции isPrime и getPrimeNumbers для разделения функциональности, а также с использованием Math.pow и начального значения 2, так как она всегда должна быть там, см. приложение jsfiddle 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);
  })();
};

Ответ 27

Вот мое решение, использующее метод 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 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);

Ответ 28

Вот метод Brute-force iterative и Sieve of Eratosthenes для нахождения простых чисел до n. Производительность второго метода лучше первого с точки зрения временной сложности

Итеративный метод грубой силы

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

Метод решета Эратосфена

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

Ответ 29

Вы можете использовать это для любого размера массива простых чисел. Надеюсь, что это поможет

 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>

Ответ 30

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