Javascript 如何找到0-100之间的素数？

在Javascript中，如何找到0-100之间的素数？我已经考虑过了，我不知道如何找到它们。我想做x%x，但我发现了明显的问题。 这就是我到目前为止所做的： 但不幸的是，这是有史以来最糟糕的代码

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

var prime=函数（）{
var-num；
对于（num=0；num<101；num++）{
如果（数值%2==0）{
打破
}
else if（num%3==0）{
打破
}
else if（num%4==0）{
打破
}
else if（num%5==0）{
打破
}
else if（num%6==0）{
打破
}
else if（num%7==0）{
打破
}
else if（num%8==0）{
打破
}
else if（num%9==0）{
打破
}
else if（num%10==0）{
打破
}
else if（num%11==0）{
打破
}
else if（num%12==0）{
打破
}
否则{
返回num；
}
}
};
log（prime（））；

无论使用哪种语言，查找某一范围内的素数的最佳且最容易获得的方法之一是使用

不会给你代码，但这是一个很好的起点

---

对于较小的范围，例如您的范围，最有效的方法是预计算数字。

首先，更改另一个循环的内部代码（

For

和

while

），以便可以对不同的值重复相同的代码

更具体地说，对于您的问题，如果您想知道给定的

n

是否为素数，则需要将其除以2和sqrt（n）之间的所有值。如果任何模块为0，则它不是素数

---

如果你想找到所有的素数，你可以加快速度，只需除以之前找到的素数就可以检查

n

。另一种加速过程的方法是，除了2和3之外，所有的素数都是

6*k

加上或小于1。

Luchian的答案提供了一个到寻找素数的标准技术的链接

一种效率较低但更简单的方法是将现有代码转换为嵌套循环。注意，你正在除以2，3，4，5，6等等。。。把它变成一个循环

---

考虑到这是家庭作业，并且家庭作业的目的是帮助您学习基本编程，一个简单、正确但有点低效的解决方案应该是好的

以下是此脚本的现场演示：

首先，制作一个函数，测试单个数字是否为素数。如果你想扩展Number对象，你可以，但是我决定让代码尽可能简单

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

函数isPrime（num）{
如果（num<2）返回false；
对于（变量i=2；i

此脚本遍历小于该数字的2到1之间的每个数字，并测试如果将该数字除以增量，是否有任何数字没有余数。如果有没有余数，它就不是素数。如果数字小于2，则它不是素数。否则，它就是素数

然后在数字0到100之间进行for循环，并使用该函数测试每个数字。如果是prime，则将数字输出到日志

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

for（变量i=0；i<100；i++）{
if（isPrime（i））console.log（i）；
}

我是这样解决的。将它从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;
}

函数isPrime（n）
{
如果（n<2）返回false；
/**
*如果整数不能被任何小于或等于其平方根的素数整除，则该整数为素数
**/
var q=数学地板（数学sqrt（n））；
对于（var i=2；i

如果我们已经尝试用2删除，为什么还要用4（和6,8,10,12）删除呢？

如果我们已经尝试按3删除，为什么还要按9删除？

如果11*11=121大于100，为什么要尝试用11删除？

为什么要用2来删除任何奇数？

为什么要尝试删除任何大于2的偶数

消除死测试，你会得到一个好的代码，测试100以下的素数

而且你的代码远不是有史以来最差的代码。许多其他人会尝试用100除以99。但是绝对冠军会用
2..96
和
2..96
生成所有乘积，以测试97是否在其中。这真的是非常低效的

当然，筛子要好得多，你可以有一个——100以下——带：

控制台日志（2）
变量m3=9，m5=25，m7=49，i=3
对于（；i<100；i+=2）
{
如果（i！=m3&&i！=m5&&i！=m7）console.log（i）
其他的
{
如果（i==m3）m3+=6
如果（i==m5）m5+=10
如果（i==m7）m7+=14
}
}“完成”

---

这是Eratosthenes的筛子，如果我们跳过复合物，这就是代码所做的。生成复合物和跳过它们的时间（通过检查相等性）混合到一个时间轴中。通常的筛子首先生成复合物并将其标记在一个数组中，然后扫描数组。在这里，这两个阶段合并为一个，以避免使用任何数组（这仅仅是因为我们预先知道上限的平方根-10，并且只使用它下面的素数，即3,5,7-和2的倍数，即evens，预先隐式跳过）

---

换句话说，这是一个埃拉托斯坦的增量筛选，

m3

，

m5

，

m7

形成了一个由素数3、5和7的倍数构成的隐式优先级队列。

如果你要使用本线程中将要介绍的无数算法中的任何一种，你应该学会这样记忆我喜欢他们

---

请参见以下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（最大值）{
变量筛=[]，i，j，素数=[]；
对于（i=2；i使用以下函数找出素数：

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
}

函数素数（）{
变量
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
}

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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