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

Question

想改进这篇文章吗？ 提供此问题的详细答案，包括引文和解释为什么您的答案是正确的。 没有足够详细信息的答案可能会被编辑或删除。

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

Answer 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 实现看起来非常相似。

Answer 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)] 就足够了。

Answer 3

这是这个脚本的现场演示： 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;
}

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

然后使用 for 循环遍历数字 0 到 100 并使用该函数测试每个数字。 如果是质数，则将数字输出到日志中。

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

Answer 4

无论使用什么语言，在一个范围内寻找素数的最好和最容易获得的方法之一就是使用筛分。

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

对于像您这样的小范围，最有效的方法是预先计算数字。

Answer 5

我稍微修改了Sieve of Sundaram算法以减少不必要的迭代，它似乎非常快。

这个算法实际上比这个主题下最被接受的@Ted Hopp 的解决方案快两倍。 解决 0 - 1M 之间的 78498 个质数在 Chrome 55 中需要 20~25 毫秒，在 FF 50.1 中需要 < 90 毫秒。 另外@vitaly-t 的 get next prime 算法看起来很有趣，但结果也慢得多。

这是核心算法。 人们可以应用分段和线程来获得极好的结果。

 "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 = (ni)/(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);

循环限制解释：

就像 Erasthotenes 的筛选一样，Sundaram 的筛选算法也会从列表中划掉一些选定的整数。 要选择要划掉哪些整数，规则是 i + j + 2ij ≤ n，其中 i 和 j 是两个索引，n 是总元素的数量。 一旦我们划掉每一个 i + j + 2ij，剩下的数字就会被加倍和奇数化 (2n+1) 以显示素数列表。 最后阶段实际上是偶数的自动折扣。 它的证明在这里得到了很好的解释。

Sundaram 的筛选只有在正确选择循环索引开始和结束限制的情况下才能快速进行，这样就不会（或最少）消除（或最小）非素数的冗余（多重）消除。 由于我们需要 i 和 j 值来计算要划掉的数字，因此 i + j + 2ij 到 n 让我们看看如何处理。

i)所以我们必须找到 i 和 j 相等时可以取的最大值。 即 2i + 2i^2 = n。 我们可以使用二次公式轻松求解 i 的正值，即t = (Math.sqrt(4+8*n)-2)/4,的直线t = (Math.sqrt(4+8*n)-2)/4,

j)内循环索引 j 应该从 i 开始并运行到它可以与当前 i 值一致的点。 仅此而已。 因为我们知道 i + j + 2ij = n，所以这可以很容易地计算为u = (ni)/(1+2*i);

虽然这不会完全消除冗余交叉，但它会“极大地”消除冗余。 例如，对于 n = 50（检查最多 100 的素数）而不是 50 x 50 = 2500，我们总共将只进行 30 次迭代。 很明显，这个算法不应该被视为 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

其中只有5个重复。 22、31、37、40、49。对于 n = 100，冗余度约为 20%，但对于 n = 10M，它增加到 ~300%。 这意味着进一步优化 SoS 有可能随着 n 的增长更快地获得结果。 因此，一个想法可能是分段并始终保持 n 小。

所以好吧..我决定更进一步地进行这个任务。

经过对重复交叉的一些仔细检查后，我意识到，除了i === 1情况外，如果i或j索引值中的一个或两个在 4,7,10 之间， 13,16,19...系列，产生重复交叉。 然后仅当i%3-1 !== 0时才允许内部循环转动，从而进一步减少了循环总数的 35-40%。 因此，例如对于 1M 整数，嵌套循环的总轮数从 1.4M 下降到 1M。 哇..！ 我们在这里谈论的几乎是 O(n)。

我刚刚做了一个测试。 在 JS 中，仅仅一个计数到 1B 的空循环就需要 4000 毫秒。 在下面修改后的算法中，找到最多 100M 的素数需要相同的时间。

我还实现了这个算法的分割部分来推送给工作人员。 这样我们也可以使用多个线程。 但该代码稍后将遵循。

因此，让我向您介绍经过修改的 Sundaram 筛网可能在不分段时最好。 它将使用 Chrome V8 和 Edge ChakraCore 在大约 15-20 毫秒内计算 0-1M 之间的素数。

 "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 = (ni)/(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);

嗯...最后我想我已经实现了一个筛子（它起源于巧妙的 Sundaram 筛子），它是我可以在互联网上找到的最快的 JavaScript 筛子，包括“Eratosthenes 的 Odds only Sieve”或“阿特金斯筛”。 这也是为 web 工作者准备的，多线程。

这样想。 在这台不起眼的单线程 AMD PC 中，JS 需要 3,300 毫秒才能计算到 10^9，而以下优化的分段 SoS 将仅在 14,000 毫秒内为我提供 50847534 个素数，达到 10^9。 这意味着只是计数操作的 4.25 倍。 我认为它令人印象深刻。

你可以自己测试一下；

 console.time("tare"); for (var i = 0; i < 1000000000; i++); console.timeEnd("tare");

在这里，我向您介绍最好的 Sundaram 分段 Seieve。

 "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*io] = false; for(var i = 2; i < t; i++){ s = Math.ceil((oi)/(1+2*i)); e = (g+oi)/(1+2*i); if (i%3-1) for(var j = s; j < e; j++) ar[i + j + 2*i*jo] = false; } } else { for(var i = 1; i < (g-1)/3; i++) ar[1+3*i] = false; for(var i = 2; i < t; i++){ e = (gi)/(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);

我不确定它是否会比这更好。 我很想听听你的意见。

Answer 6

如果一个数不能被小于该数的其他素数整除，则该数为素数。

所以这建立了一个primes数组。 测试每个新的奇数候选n与现有发现的小于n primes进行除法。 作为一种优化它不考虑偶数，并预置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);

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

Answer 8

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

Answer 9

Luchian 的回答为您提供了寻找素数的标准技术的链接。

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

鉴于这是作业，而且作业的目的是帮助您学习基本的编程，一个简单、正确但效率稍低的解决方案应该没问题。

Answer 10

• 如果我们已经尝试删除2 ，为什么还要尝试删除4 （和6,8,10,12 ）？
  如果我们已经尝试过删除3 ，为什么还要尝试删除9呢？
  which is greater than ?如果大于为什么要尝试删除11 ？
  为什么要尝试将任何奇数删除2呢？
  为什么要尝试删除任何大于2的偶数？

消除无效的测试，你会得到一个很好的代码，测试低于 100 的素数。

而且您的代码远非有史以来最糟糕的代码。 许多许多人会尝试通过99除以100。 但是绝对冠军会用2..96生成2..96所有2..96来测试97是否在其中。 那一个真的是低得惊人。

Eratosthenes的筛子当然要好得多，你可以有一个 - 低于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"

---

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

换句话说，这是埃拉托塞尼和的增量筛m3 ， m5 ， m7形成素数3,5，和7的倍数的一个隐式优先级队列。

Answer 11

使用递归结合此处的平方根规则，检查数字是否为素数：

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

}

Answer 12

这是在 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;
}

测试

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 ]

它比此处发布的其他替代方案更快，因为：

• 它将循环限制与整数对齐，这样工作得更快；
• 它使用较短的迭代循环，跳过偶数。

它可以在大约 130 毫秒内为您提供前 100,000 个素数，或在大约 4 秒内提供前 1m 个素数。

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

Answer 13

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

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

Answer 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尝试过 - 这需要一些时间，但似乎是准确的。

Answer 16

使用 Eratosthenes 筛， 来源 Rosettacode

最快的解决方案： 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))

Answer 17

这个著名的代码来自一个著名的 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));

Answer 18

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

Answer 19

这是计算给定范围（1 到限制）之间的素数的非常简单的方法。

简单的解决方案：

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

Answer 20

你也可以试试这个方法，这个方法很基础但是很容易理解：

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

Answer 21

我最近想出了一个单行解决方案，它完全可以在 Scrimba 上完成 JS 挑战（如下）。

ES6+

const getPrimes=num=>Array(num-1).fill().map((e,i)=>2+i).filter((e,i,a)=>a.slice(0,i).every(x=>e%x!==0));

< ES6

function getPrimes(num){return ",".repeat(num).slice(0,-1).split(',').map(function(e,i){return i+1}).filter(function(e){return e>1}).filter(function(x){return ",".repeat(x).slice(0,-1).split(',').map(function(f,j){return j}).filter(function(e){return e>1}).every(function(e){return x%e!==0})})};

这是解释的逻辑：

1. 首先，该函数通过使用所需数字 (100) 作为转发器参数的.repeat()函数构建一个所有数字的数组，该数组指向所需数字（在本例中为 100），然后将该数组映射到索引+ 1 获取从 0 到该数字 (0-100) 的数字范围。 这里进行了一些字符串拆分和连接魔术。 如果您愿意，我很乐意进一步解释这一步。

2. 我们从数组中排除 0 和 1，因为它们不应该进行素数测试，以免它们给出误报。 两者都不是主要的。 我们使用.filter()仅对 > 1 (≥ 2) 的数字执行此操作。

3. 现在，我们只为素数过滤 2 和所需数字 (100) 之间所有整数的新数组。 为了仅过滤素数，我们使用了与第一步相同的一些魔法。 我们再次使用.filter()和.repeat()创建一个新数组，从 2 到我们新数字数组中的每个值。 对于每个值的新数组，我们检查是否有任何 ≥ 2 和 < 该数字的数字是该数字的因数。 我们可以使用与模运算符%配对的.every()方法来检查该数字在除以 2 和它本身之间的任何值时是否.every()数。 如果每个值都有余数（ x%e!==0 ），则从 2 到该数字（但不包括该数字，即：[2,99]）的所有值都满足条件，我们可以说该数字是素数. 过滤器函数将所有质数返回到最上面的返回值，从而返回 2 和传递值之间的质数列表。

例如，使用我在上面添加的这些函数之一，返回以下内容：

getPrimes(100);
// => [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]

Answer 22

首先，更改另一个循环（ for和while ）的内部代码，以便您可以为不同的值重复相同的代码。

更具体地针对您的问题，如果您想知道给定的n是否为素数，则需要将其除以 2 和 sqrt(n) 之间的所有值。 如果任何模块为 0，则它不是质数。

如果你想找到所有的素数，你可以加快速度，只通过除以之前找到的素数来检查n 。 另一种加速这个过程的方法是，除了 2 和 3 之外，所有的素数都是6*k加上或小于 1。

Answer 23

如果您打算使用本主题中将要介绍的任何无数算法，那么您应该学会记住其中的一些。

请参阅面试问题：递归生成素数的最快方法是什么？

Answer 24

使用以下函数找出素数：

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
}

Answer 25

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

Answer 26

这是一种测试数字是否为素数的方法。

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

Answer 27

我修改了 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 
    }
}

Answer 28

这样的事情怎么样。

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

Answer 29

这是我的解决方案

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

Answer 30

我创建了一个 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);
  })();
};

Answer 31

这是我使用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);