blocks|key|3873565|text|无论使用哪种语言，在一个范围内查找素数的最佳和最易访问的方法之一就是使用sieve。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3873566|我不打算给你代码，但这是一个很好的起点。|3873567|对于像您这样的小范围，最有效的方法是预先计算数字。|3873568|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes^0|10|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

<p>Whatever the language, one of the best and most accessible ways of finding primes within a range is using a <a href="http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes">sieve</a>.</p>

<p>Not going to give you code, but this is a good starting point.</p>

<p>For a small range, such as yours, the most efficient would be pre-computing the numbers.</p>


blocks|key|5290849|text|首先，更改另一个循环(for和while)的内部代码，以便可以对不同的值重复相同的代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5290850|更具体地说，如果您想知道给定的n是否是质数，则需要在2和sqrt(n)之间对所有值进行除以。如果任一模为0，则它不是素数。|5290851|如果你想找到所有的素数，你可以加快速度，并只通过除以之前找到的素数来检查n。另一种加速这个过程的方法是，除了2和3之外，所有的素数都是6*k加或减1。|5290852|entityMap^0|B|3|F|5|0|F|1|0|10|1|1V|3|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$]]

<p>First, change your inner code for another loop (<code>for</code> and <code>while</code>) so you can repeat the same code for different values.</p>

<p>More specific for your problem, if you want to know if a given <code>n</code> is prime, you need to divide it for all values between 2 and sqrt(n). If any of the modules is 0, it is not prime.</p>

<p>If you want to find all primes, you can speed it and check <code>n</code> only by dividing by the previously found primes. Another way of speeding the process is the fact that, apart from 2 and 3, all the primes are <code>6*k</code> plus or less 1.</p>


blocks|key|3873638|text|Luchian的回答给你提供了一个寻找素数的标准技术的链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3873639|一种效率较低但更简单的方法是将现有代码转换为嵌套循环。观察你正在除以2,3,4,5,6，等等...然后把它变成一个循环。|3873640|鉴于这是家庭作业，并且家庭作业的目的是帮助您学习基本编程，一个简单、正确但有点低效的解决方案应该是可以的。|3873641|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

<p>Luchian's answer gives you a link to the standard technique for finding primes.</p>

<p>A less efficient, but simpler approach is to turn your existing code into a nested loop.  Observe that you are dividing by 2,3,4,5,6 and so on ... and turn that into a loop.</p>

<p>Given that this is homework, and given that the aim of the homework is to help you learn basic programming, a solution that is simple, correct but somewhat inefficient should be fine.  </p>


blocks|key|3873702|text|这里是该脚本的实时演示：+|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3873703|首先，创建一个函数来测试单个数字是否为质数。如果您想扩展Number对象，您可以这样做，但我决定让代码尽可能简单。|3873704|function+isPrime(num)+{
++++if(num+<+2)+return+false;
++++for+(var+i+=+2;+i+<+num;+i%2B%2B)+{
++++++++if(num%25i==0)
++++++++++++return+false;
++++}
++++return+true;
}|code-block|syntax|javascript|3873705|此脚本遍历2到1之间的每个小于该数字的数字，并测试如果将该数字除以增量，是否存在没有余数的任何数字。如果有一个没有余数的，它就不是素数。如果数字小于2，则它不是质数。否则，它就是质数。|3873706|然后创建一个for循环，循环遍历数字0到100，并使用该函数测试每个数字。如果是质数，则将该数字输出到日志中。|3873707|for(var+i+=+0;+i+<+100;+i%2B%2B){
++++if(isPrime(i))+console.log(i);
}|3873708|entityMap^0|0|C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

<p><strong>Here is the live demo of this script: <a href="http://jsfiddle.net/K2QJp/" rel="noreferrer">http://jsfiddle.net/K2QJp/</a></strong></p>

<p>First, make a function that will test if a single number is prime or not. If you want to extend the Number object you may, but I decided to just keep the code as simple as possible.</p>

<pre><code>function isPrime(num) {
    if(num &lt; 2) return false;
    for (var i = 2; i &lt; num; i++) {
        if(num%i==0)
            return false;
    }
    return true;
}
</code></pre>

<p>This script goes through every number between 2 and 1 less than the number and tests if there is any number in which there is no remainder if you divide the number by the increment. If there is any without a remainder, it is not prime. If the number is less than 2, it is not prime. Otherwise, it is prime.</p>

<p>Then make a for loop to loop through the numbers 0 to 100 and test each number with that function. If it is prime, output the number to the log.</p>

<pre><code>for(var i = 0; i &lt; 100; i++){
    if(isPrime(i)) console.log(i);
}
</code></pre>


blocks|key|5290973|text|下面是我如何解决这个问题的。将其从Java重写为JavaScript，所以如果有语法错误，请原谅。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5290974|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%2B%2B)
++++{
++++++++if+(n+%25+i+==+0)
++++++++{
++++++++++++return+false;
++++++++}
++++}

++++return+true;
}|code-block|syntax|javascript|5290975|一个数，n，如果它不能被除1和它本身之外的任何其他数整除，则它是质数。另外，检查数字2，sqrt(n)就足够了。|offset|length|style|CODE|5290976|entityMap^0|0|0|4|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>Here's how I solved it. Rewrote it from Java to JavaScript, so excuse me if there's a syntax error.    </p>

<pre><code>function isPrime (n)
{
    if (n &lt; 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 &lt;= q; i++)
    {
        if (n % i == 0)
        {
            return false;
        }
    }

    return true;
}
</code></pre>

<p>A number, <code>n</code>, is a prime if it isn't divisible by any other number other than by 1 and itself. Also, it's sufficient to check the numbers [2, sqrt(n)].</p>


blocks|key|3873775|text|如果你打算使用这篇文章中将要呈现给你的无数算法中的任何一种，那么你应该学会记住其中的一些算法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3873776|请参阅Interview+question+:+What+is+the+fastest+way+to+generate+prime+number+recursively?|offset|length|3873777|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4551731/interview-question-what-is-the-fastest-way-to-generate-prime-number-recursivel^0|0|3|2A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

<p>It would behoove you, if you're going to use any of the gazillion algorithms that you're going to be presented with in this thread, to learn to memoize some of them. </p>

<p>See <a href="https://stackoverflow.com/questions/4551731/interview-question-what-is-the-fastest-way-to-generate-prime-number-recursivel">Interview question : What is the fastest way to generate prime number recursively?</a></p>


blocks|key|1763424|text|下面是一个在JavaScript中实现sieve的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763425|function+getPrimes(max)+{
++++var+sieve+=+[],+i,+j,+primes+=+[];
++++for+(i+=+2;+i+<=+max;+%2B%2Bi)+{
++++++++if+(!sieve[i])+{
++++++++++++//+i+has+not+been+marked+--+it+is+prime
++++++++++++primes.push(i);
++++++++++++for+(j+=+i+<<+1;+j+<=+max;+j+%2B=+i)+{
++++++++++++++++sieve[j]+=+true;
++++++++++++}
++++++++}
++++}
++++return+primes;
}|code-block|syntax|javascript|1763426|然后，getPrimes(100)将返回一个由2到100之间(包括2和100)的素数组成的数组。当然，由于内存的限制，您不能将其与大参数一起使用。|offset|length|style|CODE|1763427|Java实现看起来非常类似。|1763428|entityMap^0|0|0|3|E|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<p>Here's an example of a sieve implementation in JavaScript:</p>

<pre><code>function getPrimes(max) {
    var sieve = [], i, j, primes = [];
    for (i = 2; i &lt;= max; ++i) {
        if (!sieve[i]) {
            // i has not been marked -- it is prime
            primes.push(i);
            for (j = i &lt;&lt; 1; j &lt;= max; j += i) {
                sieve[j] = true;
            }
        }
    }
    return primes;
}
</code></pre>

<p>Then <code>getPrimes(100)</code> will return an array of all primes between 2 and 100 (inclusive). Of course, due to memory constraints, you can't use this with large arguments.</p>

<p>A Java implementation would look very similar.</p>


blocks|key|3873911|text|使用下面的函数找出质数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3873912|function+primeNumbers()+{
++++var+p
++++var+n+=+document.primeForm.primeText.value
++++var+d
++++var+x
++++var+prime
++++var+displayAll+=+2+%2B+"+"
++++for+(p+=+3;+p+<=+n;+p+=+p+%2B+2)+{
++++++++x+=+Math.sqrt(p)
++++++++prime+=+1
++++++++for+(d+=+3;+prime+&&+(d+<=+x);+d+=+d+%2B+2)
++++++++if+((p+%25+d)+==+0)+prime+=+0
++++++++else+prime+=+1
++++++++if+(prime+==+1)+{
++++++++++++displayAll+=+displayAll+%2B+p+%2B+"+"
++++++++}
++++}
++++document.primeForm.primeArea.value+=+displayAll
}|code-block|syntax|javascript|3873913|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Use following function to find out prime numbers :    </p>

<pre><code>function primeNumbers() {
    var p
    var n = document.primeForm.primeText.value
    var d
    var x
    var prime
    var displayAll = 2 + " "
    for (p = 3; p &lt;= n; p = p + 2) {
        x = Math.sqrt(p)
        prime = 1
        for (d = 3; prime &amp;&amp; (d &lt;= 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></pre>


blocks|key|3873915|text|<html>
<head>
<script+type="text/javascript">
function+primeNumber()+{
+x=document.getElementById('txt_field').value;
++for+(i=1;+i<=parseInt(x);+i%2B%2B)+{
++var+flag=0,flag1=0;+
++++for+(j=2;+j<i;+j%2B%2B)+{
++++++if(i%25j==0){
+++++++flag=1;
++++++if(i==x)
+++++++flag1=1;
++++++}
++++}
+++if(flag==0)
++++document.write(i%2B'<br>');
++}
+++if(flag1==0)+
++++document.write('Its+a+prime+number.');
+++else+
++++document.write('Its+not+a+prime+number.');
}
</script>
</head>

<body>
+<input+id="txt_field"+type="text"+name="field"+/>
+<input+type="button"+name="submit"+value="Submit"+onclick="primeNumber();"+/>
</body>
</html>|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3873916|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>&lt;html&gt;
&lt;head&gt;
&lt;script type="text/javascript"&gt;
function primeNumber() {
 x=document.getElementById('txt_field').value;
  for (i=1; i&lt;=parseInt(x); i++) {
  var flag=0,flag1=0; 
    for (j=2; j&lt;i; j++) {
      if(i%j==0){
       flag=1;
      if(i==x)
       flag1=1;
      }
    }
   if(flag==0)
    document.write(i+'&lt;br&gt;');
  }
   if(flag1==0) 
    document.write('Its a prime number.');
   else 
    document.write('Its not a prime number.');
}
&lt;/script&gt;
&lt;/head&gt;

&lt;body&gt;
 &lt;input id="txt_field" type="text" name="field" /&gt;
 &lt;input type="button" name="submit" value="Submit" onclick="primeNumber();" /&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>


blocks|key|3873928|text|<code>
<script+language="javascript">
+++var+n=prompt("Enter+User+Value")
+++++var+x=1;
+++++++if(n==0+%7C%7C+n==1)+x=0;
++++++++++for(i=2;i<n;i%2B%2B)
+++++++++++{
++++++++++if(n%25i==0)
+++++++{
+++++x=0;
+++++break;
+++++++}
+++++++++++}
+++++++++++if(x==1)
+++++++++++++{
++++++++++++++++alert(n+%2B"+"%2B"+is+prime");
+++++++++++++}
+++++++++++++else
+++++++++++++{
++++++++++++++++alert(n+%2B"+"%2B"+is+not+prime");
+++++++++++++}


++++++++++</script>|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3873929|​|unstyled|3873930|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>&lt;code&gt;
&lt;script language="javascript"&gt;
   var n=prompt("Enter User Value")
     var x=1;
       if(n==0 || n==1) x=0;
          for(i=2;i&lt;n;i++)
           {
          if(n%i==0)
       {
     x=0;
     break;
       }
           }
           if(x==1)
             {
                alert(n +" "+" is prime");
             }
             else
             {
                alert(n +" "+" is not prime");
             }


          &lt;/script&gt;
</code></pre>

<p></p>


blocks|key|1763484|text|使用递归与here中的平方根规则相结合，检查数字是否为质数：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1763485|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+%25+divisor+===+0)+{
++++++++++++//+found+a+result+that+divides+evenly,+NOT+prime
++++++++++++return+false;
++++++++}
++++++++else+{
++++++++++++//+keep+counting
++++++++++++return+primeCountUp(%2B%2Bdivisor);
++++++++}
++++};

++++//+start+@+2+because+everything+is+divisible+by+1
++++return+primeCountUp(2);

}|code-block|syntax|javascript|1763486|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11967564/561731^0|5|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>Using recursion combined with the square root rule from <a href="https://stackoverflow.com/a/11967564/561731">here</a>, checks whether a number is prime or not:</p>

<pre><code>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 &gt; 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);

}
</code></pre>


blocks|key|5291083|text|用JS函数检查数字是否为质数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291084|function+isPrime(num)
++++++++{
++++++++++++var+flag+=+true;
++++++++++++for(var+i=2;+i<=Math.ceil(num/2);+i%2B%2B)
++++++++++++{
++++++++++++++++if((num%25i)==0)
++++++++++++++++{
++++++++++++++++++++flag+=+false;
++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}
++++++++++++return+flag;++++
++++++++}|code-block|syntax|javascript|5291085|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>check the number is prime or not with JS function</p>

<pre><code>function isPrime(num)
        {
            var flag = true;
            for(var i=2; i&lt;=Math.ceil(num/2); i++)
            {
                if((num%i)==0)
                {
                    flag = false;
                    break;
                }
            }
            return flag;    
        }
</code></pre>


blocks|key|5291103|text|下面是一种测试number是否为质数的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291104|function+isPrime(numb){
++if+(numb+%25+2+==+0)+return+false;
++for+(var+i=3;+i<=+Math.sqrt(numb);+i+=+i+%2B+2)+{
++++if+(numb+%25+i+==+0)+{
+++++return+false;
++++}
++}
++return+true;
}|code-block|syntax|javascript|5291105|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is a way to test if number is prime number. </p>

<pre><code>function isPrime(numb){
  if (numb % 2 == 0) return false;
  for (var i=3; i&lt;= Math.sqrt(numb); i = i + 2) {
    if (numb % i == 0) {
     return false;
    }
  }
  return true;
}
</code></pre>


blocks|key|1763542|text|我修改了Rinto的答案，只是为了那些不想使用prompt方法而只想看到程序打印质数的人。它起作用了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763543|for+(n+=+0;+n+<+100;+n%2B%2B)+{
++++var+x+=+1;
++++if+(n+==+0+%7C%7C+n+==+1)+x+=+0;
++++for+(i+=+2;+i+<+n;+i%2B%2B)+{
++++++++if+(n+%25+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+
++++}
}|code-block|syntax|javascript|1763544|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I modified Rinto's answer just for those who don't want to use the prompt method and just want to see the program print prime numbers . its working </p>

<pre><code>for (n = 0; n &lt; 100; n++) {
    var x = 1;
    if (n == 0 || n == 1) x = 0;
    for (i = 2; i &lt; 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 
    }
}
</code></pre>


blocks|key|1763549|text|找到0到n之间的质数。你只需要检查数字x是否能被0-(x的平方根)之间的任何数字整除。如果我们传递n和来查找0到n之间的所有质数，则逻辑可以实现为-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763550|++function+findPrimeNums(n)
++++{+
+++++++var+x=+3,j,i=2,
+++++++primeArr=[2],isPrime;
+++++++for+(;x<=n;x%2B=2){
+++++++++++j+=+(int)+Math.sqrt+(x);
+++++++++++isPrime+=+true;
+++++++++++for+(i+=+2;+i+<=+j;+i%2B%2B)
+++++++++++{
++++++++++++++++if+(x+%25+i+==+0){
++++++++++++++++++++isPrime+=+false;
++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}
++++++++++++if(isPrime){
++++++++++++++++primeArr.push(x);
++++++++++++}

++++++++}+++

++++++++return+primeArr;
++++}|code-block|syntax|javascript|1763551|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>To find prime numbers between 0 to n. You just have to check if a number x is getting divisible by any number between 0 - (square root of x). If we pass n and to find all prime numbers between 0 and n,  logic can be implemented as -  </p>

<pre><code>  function findPrimeNums(n)
    { 
       var x= 3,j,i=2,
       primeArr=[2],isPrime;
       for (;x&lt;=n;x+=2){
           j = (int) Math.sqrt (x);
           isPrime = true;
           for (i = 2; i &lt;= j; i++)
           {
                if (x % i == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime){
                primeArr.push(x);
            }

        }   

        return primeArr;
    }
</code></pre>


blocks|key|5291132|text|埃拉托色尼的筛子。它的比特外观，但它的简单和它的工作！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291133|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+%25+2+!==+0)+{
++++++++++++list.push(counter)
++++++++}
++++++++counter%2B%2B
++++}

++++for+(i+=+0;+i+<+list.length+-+1;+i%2B%2B)+{
++++++++var+a+=+list[i]
++++++++for+(j+=+0;+j+<+list.length+-+1;+j%2B%2B)+{
++++++++++++if+(list[j]+%25+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);|code-block|syntax|javascript|5291134|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Sieve of Eratosthenes. its  bit look but its simple and it works!  </p>

<pre><code>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 &lt; arg ) {
        if (counter % 2 !== 0) {
            list.push(counter)
        }
        counter++
    }

    for (i = 0; i &lt; list.length - 1; i++) {
        var a = list[i]
        for (j = 0; j &lt; list.length - 1; j++) {
            if (list[j] % a === 0 &amp;&amp; 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);
</code></pre>


blocks|key|3874014|text|有人试过这个吗？它简单而高效...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3874015|function+Prime(num)+{
++if+(num+<=+2)return+false;
++for(var+i+=+2;+i+<+num;+i%2B%2B){
++++if+(num+%25+i+==+0)+return+false;
++}
++return+true;
}

function+PrimeWithin(userinput){
++for(var+i+=+2;+i+<+userinput;+i%2B%2B){
++++if(Prime(i)){
++++++++console.log(i);
++++}
++}
}

PrimeWithin(500);|code-block|syntax|javascript|3874016|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Did anyone try this? It's simple and efficient ...</p>

<pre><code>function Prime(num) {
  if (num &lt;= 2)return false;
  for(var i = 2; i &lt; num; i++){
    if (num % i == 0) return false;
  }
  return true;
}

function PrimeWithin(userinput){
  for(var i = 2; i &lt; userinput; i++){
    if(Prime(i)){
        console.log(i);
    }
  }
}

PrimeWithin(500);
</code></pre>


blocks|key|1504541|text|不如这样吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504542|next_prime:
for+(var+i+=+2;+i+<+100;+i%2B%2B){
++++for+(var+e+=+2;+e+<+i;+e%2B%2B){
++++++++if+(i+%25+e+===+0)+continue+next_prime;
++++}
++++console.log(i+%2B+'<br>');
}|code-block|syntax|javascript|1504543|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>How about something like this.</p>

<pre><code>next_prime:
for (var i = 2; i &lt; 100; i++){
    for (var e = 2; e &lt; i; e++){
        if (i % e === 0) continue next_prime;
    }
    console.log(i + '&lt;br&gt;');
}
</code></pre>


blocks|key|3874026|text|这是我的solution|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3874027|//find+all+prime+numbers
function+showMePrimeNumbers(start,+end){
++++var+primes+=+[];
++++for(var+number+=+start;+number+<+end;+number%2B%2B){
++++++++var+primeNumberDividers+=+[];+//there+should+only+be+2:+1+&+number
++++++++for(var+divider+=+1;+divider+<=+number;+divider%2B%2B){
++++++++++++if(number+%25+divider+===+0){
++++++++++++++++primeNumberDividers.push(divider);
++++++++++++}++++++
++++++++}
++++++++if(primeNumberDividers.length+===+2){
++++++++++++primes.push(number);
++++++++}
++++}
++++return+primes;
}

console.log(showMePrimeNumbers(1,+100));+++++++++++|code-block|syntax|javascript|3874028|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/ka8ypt5v/^0|4|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>This is my <a href="http://jsfiddle.net/ka8ypt5v/" rel="nofollow">solution</a></p>

<pre><code>//find all prime numbers
function showMePrimeNumbers(start, end){
    var primes = [];
    for(var number = start; number &lt; end; number++){
        var primeNumberDividers = []; //there should only be 2: 1 &amp; number
        for(var divider = 1; divider &lt;= number; divider++){
            if(number % divider === 0){
                primeNumberDividers.push(divider);
            }      
        }
        if(primeNumberDividers.length === 2){
            primes.push(number);
        }
    }
    return primes;
}

console.log(showMePrimeNumbers(1, 100));           
</code></pre>


blocks|key|5291175|text|如果一个数不能被比这个数小的其他素数整除，那么这个数就是素数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291176|这样就构建了一个primes数组。针对发现的低于n的现有n，测试每个新的奇数候选primes以进行划分。作为一种优化，它不考虑偶数，并将2作为最后一步。|offset|length|style|CODE|5291177|var+primes+=+[];
for(var+n=3;n<=100;n%2B=2)+{
++if(primes.every(function(prime){return+n%25prime!=0}))+{
++++primes.push(n);
++}
}
primes.unshift(2);|code-block|syntax|javascript|5291178|entityMap^0|0|8|6|O|1|S|1|14|6|1W|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

<p>A number is a prime if it is not divisible by other primes lower than the number in question.</p>

<p>So this builds up a <code>primes</code> array. Tests each new odd candidate <code>n</code> for division against existing found <code>primes</code> lower than <code>n</code>. As an optimization it does not consider even numbers and prepends <code>2</code> as a final step. </p>

<pre><code>var primes = [];
for(var n=3;n&lt;=100;n+=2) {
  if(primes.every(function(prime){return n%prime!=0})) {
    primes.push(n);
  }
}
primes.unshift(2);
</code></pre>


blocks|key|5291186|text|这是我对它的尝试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291187|将初始i=0从0更改为您想要的任何值，并将第二个i<100从100更改为任何值，以获得不同范围内的素数。|offset|length|style|CODE|5291188|for(var+i=0;+i<100000;+i%2B%2B){
++++var+devisableCount+=+2;

++++for(var+x=0;+x<=i/2;+x%2B%2B){
++++++++if+(devisableCount+>+3)+{
++++++++++++break;
++++++++}
++++++++if(i+!==+1+&&+i+!==+0+&&+i+!==+x){
++++++++++++if(i%25x+===+0){
+++++++++++++++devisableCount%2B%2B;
+++++++++++++}
++++++++}
++++}

++++if(devisableCount+===+3){
++++++++console.log(i);
++++}
}|code-block|syntax|javascript|5291189|我用10000000试过了--它需要一些时间，但看起来是准确的。|5291190|entityMap^0|0|3|3|O|5|0|0|2|8|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

<p>Here's my stab at it.</p>
<p>Change the initial <code>i=0</code> from 0 to whatever you want, and the the second <code>i&lt;100</code> from 100 to whatever to get primes in a different range.</p>
<pre><code>for(var i=0; i&lt;100000; i++){
    var devisableCount = 2;

    for(var x=0; x&lt;=i/2; x++){
        if (devisableCount &gt; 3) {
            break;
        }
        if(i !== 1 &amp;&amp; i !== 0 &amp;&amp; i !== x){
            if(i%x === 0){
               devisableCount++;
             }
        }
    }

    if(devisableCount === 3){
        console.log(i);
    }
}
</code></pre>
<p>I tried it with <code>10000000</code> - it takes some time but appears to be accurate.</p>


blocks|key|1763676|text|这里有一种在JavaScript中快速计算素数的方法，基于先前的素数值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763677|function+nextPrime(value)+{
++++if+(value+>+2)+{
++++++++var+i,+q;
++++++++do+{
++++++++++++i+=+3;
++++++++++++value+%2B=+2;
++++++++++++q+=+Math.floor(Math.sqrt(value));
++++++++++++while+(i+<=+q+&&+value+%25+i)+{
++++++++++++++++i+%2B=+2;
++++++++++++}
++++++++}+while+(i+<=+q);
++++++++return+value;
++++}
++++return+value+===+2+?+3+:+2;
}|code-block|syntax|javascript|1763678|测试|1763679|var+value+=+0,+result+=+[];
for+(var+i+=+0;+i+<+10;+i%2B%2B)+{
++++value+=+nextPrime(value);
++++result.push(value);
}
console.log("Primes:",+result);|1763680|输出|1763681|Primes:+[+2,+3,+5,+7,+11,+13,+17,+19,+23,+29+]|1763682|它比这里发布的其他替代方案更快，因为：|1763683|1763684|它将循环限制与整数对齐，速度更快；|unordered-list-item|1763685|它使用更短的迭代循环，跳过偶数。|1763686|1763687|它可以在大约130毫秒内给出第一个100,000个素数，或者在大约4秒内给出第一个1m个素数。|1763688|​|1763689|+function+nextPrime(value)+{
++++++++if+(value+>+2)+{
++++++++++++var+i,+q;
++++++++++++do+{
++++++++++++++++i+=+3;
++++++++++++++++value+%2B=+2;
++++++++++++++++q+=+Math.floor(Math.sqrt(value));
++++++++++++++++while+(i+<=+q+&&+value+%25+i)+{
++++++++++++++++++++i+%2B=+2;
++++++++++++++++}
++++++++++++}+while+(i+<=+q);
++++++++++++return+value;
++++++++}
++++++++return+value+===+2+?+3+:+2;
++++}

++++var+value,+result+=+[];
++++for+(var+i+=+0;+i+<+10;+i%2B%2B)+{
++++++++value+=+nextPrime(value);
++++++++result.push(value);
++++}

++++display("Primes:+"+%2B+result.join(',+'));

++++function+display(msg)+{
++++++++document.body.insertAdjacentHTML(
++++++++++++"beforeend",
++++++++++++"<p>"+%2B+msg+%2B+"</p>"
++++++++);
++++}|1763690|1763691|更新|1763692|Here's+a+solution+that's+10+times+faster+than+this+one。|offset|length|1763693|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/vitaly-t/primes-generator^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1I|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1K|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1M|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1Q|8|@]|9|@]|A|$]]|$1|U|3|V|5|T|7|1R|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1T|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1U|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|13|3|10|5|6|7|1W|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1X|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1Y|8|@]|9|@$18|1Z|19|20|1|21]]|A|$]]|$1|1A|3|-4|5|6|7|22|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]]]

<p>Here's a fast way to calculate primes in JavaScript, based on the previous prime value.</p>
<pre><code>function nextPrime(value) {
    if (value &gt; 2) {
        var i, q;
        do {
            i = 3;
            value += 2;
            q = Math.floor(Math.sqrt(value));
            while (i &lt;= q &amp;&amp; value % i) {
                i += 2;
            }
        } while (i &lt;= q);
        return value;
    }
    return value === 2 ? 3 : 2;
}
</code></pre>
<h3>Test</h3>
<pre><code>var value = 0, result = [];
for (var i = 0; i &lt; 10; i++) {
    value = nextPrime(value);
    result.push(value);
}
console.log(&quot;Primes:&quot;, result);
</code></pre>
<h3>Output</h3>
<pre><code>Primes: [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]
</code></pre>
<p>It is faster than other alternatives published here, because:</p>
<ul>
<li>It aligns the loop limit to an integer, which works way faster;</li>
<li>It uses a shorter iteration loop, skipping even numbers.</li>
</ul>
<p>It can give you the first 100,000 primes in about 130ms, or the first 1m primes in about 4 seconds.</p>
<p><div class="snippet" data-lang="js" data-hide="true" data-console="false" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code> function nextPrime(value) {
        if (value &gt; 2) {
            var i, q;
            do {
                i = 3;
                value += 2;
                q = Math.floor(Math.sqrt(value));
                while (i &lt;= q &amp;&amp; value % i) {
                    i += 2;
                }
            } while (i &lt;= q);
            return value;
        }
        return value === 2 ? 3 : 2;
    }

    var value, result = [];
    for (var i = 0; i &lt; 10; i++) {
        value = nextPrime(value);
        result.push(value);
    }

    display("Primes: " + result.join(', '));

    function display(msg) {
        document.body.insertAdjacentHTML(
            "beforeend",
            "&lt;p&gt;" + msg + "&lt;/p&gt;"
        );
    }</code></pre>
</div>
</div>
</p>
<h2>UPDATE</h2>
<p><a href="https://github.com/vitaly-t/primes-generator" rel="nofollow noreferrer">Here's a solution that's 10 times faster than this one</a>.</p>


blocks|key|3874102|text|利用Eratosthenes筛分，source+on+Rosettacode|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3874103|最快的解决方案：https://repl.it/@caub/getPrimes-bench|3874104|​|3874105|function+getPrimes(limit)+{
++++if+(limit+<+2)+return+[];
++++var+sqrtlmt+=+limit**.5+-+2;
++++var+nums+=+Array.from({length:+limit-1},+(_,i)=>i%2B2);
++++for+(var+i+=+0;+i+<=+sqrtlmt;+i%2B%2B)+{
++++++++var+p+=+nums[i]
++++++++if+(p)+{
++++++++++++for+(var+j+=+p+*+p+-+2;+j+<+nums.length;+j+%2B=+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&&!/%5E(oo%2B)\1%2B$/.test('o'.repeat(n))|code-block|syntax|javascript|3874106|3874107|entityMap|0|LINK|mutability|MUTABLE|url|https://rosettacode.org/wiki/Sieve_of_Eratosthenes#JavaScript|1|https://repl.it/@caub/getPrimes-bench^0|H|L|0|0|8|11|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|C|$K|L]]|$1|M|3|G|5|6|7|17|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]]]

<p>Using Sieve of Eratosthenes, <a href="https://rosettacode.org/wiki/Sieve_of_Eratosthenes#JavaScript" rel="nofollow noreferrer">source on Rosettacode</a></p>

<p>fastest solution: <a href="https://repl.it/@caub/getPrimes-bench" rel="nofollow noreferrer">https://repl.it/@caub/getPrimes-bench</a></p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function getPrimes(limit) {
    if (limit &lt; 2) return [];
    var sqrtlmt = limit**.5 - 2;
    var nums = Array.from({length: limit-1}, (_,i)=&gt;i+2);
    for (var i = 0; i &lt;= sqrtlmt; i++) {
        var p = nums[i]
        if (p) {
            for (var j = p * p - 2; j &lt; nums.length; j += p)
                nums[j] = 0;
        }
    }
    return nums.filter(x =&gt; x); // return non 0 values
}
document.body.innerHTML = `&lt;pre style="white-space:pre-wrap"&gt;${getPrimes(100).join(', ')}&lt;/pre&gt;`;

// for fun, this fantasist regexp way (very inefficient):
// Array.from({length:101}, (_,i)=&gt;i).filter(n =&gt; n&gt;1&amp;&amp;!/^(oo+)\1+$/.test('o'.repeat(n))</code></pre>
</div>
</div>
</p>


blocks|key|3874118|text|我创建了一个JSFiddle，展示了它应该如何以一种可读的方式工作，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3874119|我的想法是使用两个函数isPrime和getPrimeNumbers来分离功能，并使用Math.pow和初始值2，因为它应该始终存在，请参阅jsFiddle附加的jsfiddle|offset|length|3874120|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+%25+divisor+==+0+%7C%7C+Math.sqrt(divisor)+>+n)+{
++++++++++++++++return+false;
++++++++++++}+else+{
++++++++++++++++divisor%2B%2B;
++++++++++++}
++++++++}
++++++++return+true;
++++}

++++function+getPrimeNumbers(range)+{
++++++++for+(var+i+=+3;+i+<=+range;+i%2B=2)+{
++++++++++++if+(isPrime(i))+{
++++++++++++++++primeNumbers.push(i);
++++++++++++}
++++++++}
++++++++fillContent(primeNumbers);
++++}
++++getPrimeNumbers(11);
++})();
};|code-block|syntax|javascript|3874121|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/py68qhq5/6/^0|0|1Y|8|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>I have created a JSFiddle showing how it should work in a readable way, </p>

<p>idea is to have two functions isPrime and getPrimeNumbers to separate functionality, as well as using Math.pow and initial value of 2, as it should be always there, see the jsfiddle attached <a href="https://jsfiddle.net/py68qhq5/6/" rel="nofollow">jsFiddle</a></p>

<pre><code>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 &gt; divisor) {
            if (Math.pow(divisor, 2) &gt; n) {
                return true;
            }
            if (n % divisor == 0 || Math.sqrt(divisor) &gt; n) {
                return false;
            } else {
                divisor++;
            }
        }
        return true;
    }

    function getPrimeNumbers(range) {
        for (var i = 3; i &lt;= range; i+=2) {
            if (isPrime(i)) {
                primeNumbers.push(i);
            }
        }
        fillContent(primeNumbers);
    }
    getPrimeNumbers(11);
  })();
};
</code></pre>


blocks|key|1763746|text|这是我使用Eratosthenes方法的筛子的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763747|function+gimmePrimes(num)+{
++numArray+=+[];
++//+first+generate+array+of+numbers+[2,3,...num]
++for+(i+=+2;+i+<=+num;+%2B%2Bi)+{
++++numArray.push(i);
++}

++for+(i+=+0;+i+<+numArray.length;+%2B%2Bi)+{
++++//this+for+loop+helps+to+go+through+each+element+of+array

++++for+(j+=+numArray[i];+j+<+numArray[numArray.length+-+1];+%2B%2Bj)+{
++++++//get's+the+value+of+i'th+element
++++++for+(k+=+2;+j+*+k+<=+numArray[numArray.length+-+1];+%2B%2Bk)+{
++++++++//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);|code-block|syntax|javascript|1763748|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is my solution using Sieve of Eratosthenes method:</p>

<pre><code>function gimmePrimes(num) {
  numArray = [];
  // first generate array of numbers [2,3,...num]
  for (i = 2; i &lt;= num; ++i) {
    numArray.push(i);
  }

  for (i = 0; i &lt; numArray.length; ++i) {
    //this for loop helps to go through each element of array

    for (j = numArray[i]; j &lt; numArray[numArray.length - 1]; ++j) {
      //get's the value of i'th element
      for (k = 2; j * k &lt;= numArray[numArray.length - 1]; ++k) {
        //find the index of multiples of ith element in the array
        index = numArray.indexOf(j * k);
        if (index &gt; -1) { //remove the multiples
          numArray.splice(index, 1);
        }
      }

    }
  }
  return numArray; //return result
}
gimmePrimes(100);
</code></pre>


blocks|key|1504627|text|下面是寻找n以内素数的Brute-force+iterative方法和Sieve+of+Eratosthenes方法。在时间复杂度方面，第二种方法的性能优于第一种方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1504628|蛮力迭代|BOLD|1504629|function+findPrime(n)+{
++var+res+=+[2],
++++++isNotPrime;

++for+(var+i+=+3;+i+<+n;+i%2B%2B)+{
++++isNotPrime+=+res.some(checkDivisorExist);
++++if+(+!isNotPrime+)+{
++++++res.push(i);
++++}
++}

++function+checkDivisorExist+(j)+{
++++return+i+%25+j+===+0;
++}

++return+res;
}|code-block|syntax|javascript|1504630|埃拉托西尼方法的筛法|1504631|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%2B%2B;
++}

++return+listOfNum;


++function+range+(num)+{
++++var+res+=+[];
++++for+(var+i+=+2;+i+<=+num;+i%2B%2B)+{
++++++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)+%7C%7C+(item+>+x+&&+item+%25+x+!==+0);
++++});
++}
}|1504632|entityMap^0|B|L|Z|L|0|0|4|0|0|8|2|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|H]]|D|@]|E|$]]|$1|I|3|J|5|K|7|11|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|12|8|@$9|13|A|14|B|H]]|D|@]|E|$]]|$1|P|3|Q|5|K|7|15|8|@]|D|@]|E|$L|M]]|$1|R|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|S|$]]

<p>Here are the <code>Brute-force iterative</code> method and <code>Sieve of Eratosthenes</code> method to find prime numbers upto n. The performance of the second method is better than first in terms of time complexity</p>

<p><strong>Brute-force iterative</strong></p>

<pre><code>function findPrime(n) {
  var res = [2],
      isNotPrime;

  for (var i = 3; i &lt; n; i++) {
    isNotPrime = res.some(checkDivisorExist);
    if ( !isNotPrime ) {
      res.push(i);
    }
  }

  function checkDivisorExist (j) {
    return i % j === 0;
  }

  return res;
}
</code></pre>

<p><strong>Sieve of Eratosthenes method</strong></p>

<pre><code>function seiveOfErasthones (n) {
  var listOfNum =range(n),
      i = 2;

  // CHeck only until the square of the prime is less than number
  while (i*i &lt; n &amp;&amp; i &lt; n) {
    listOfNum = filterMultiples(listOfNum, i);
    i++;
  }

  return listOfNum;


  function range (num) {
    var res = [];
    for (var i = 2; i &lt;= 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 &lt;= x) || (item &gt; x &amp;&amp; item % x !== 0);
    });
  }
}
</code></pre>


blocks|key|3874172|text|你可以对任意大小的质数数组使用它。希望这能有所帮助|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3874173|​|3874174|+function+prime()+{
+++var+num+=+2;

+++var+body+=+document.getElementById("solution");

+++var+len+=+arguments.length;
+++var+flag+=+true;

+++for+(j+=+0;+j+<+len;+j%2B%2B)+{

+++++for+(i+=+num;+i+<+arguments[j];+i%2B%2B)+{

+++++++if+(arguments[j]+%25+i+==+0)+{
+++++++++body.innerHTML+%2B=+arguments[j]+%2B+"+False+<br+/>";
+++++++++flag+=+false;
+++++++++break;

+++++++}+else+{
+++++++++flag+=+true;

+++++++}

+++++}
+++++if+(flag)+{
+++++++body.innerHTML+%2B=+arguments[j]+%2B+"+True+<br+/>";

+++++}

+++}

+}

+var+data+=+[1,+2,+3,+4,+5,+6,+7,+8,+9,+10];

+prime.apply(null,+data);|code-block|syntax|javascript|3874175|<div+id="solution">

</div>|3874176|3874177|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|K|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

<p>You can use this for any size of array of prime numbers. Hope this helps</p>

<p><div class="snippet" data-lang="js" data-hide="true">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code> function prime() {
   var num = 2;

   var body = document.getElementById("solution");

   var len = arguments.length;
   var flag = true;

   for (j = 0; j &lt; len; j++) {

     for (i = num; i &lt; arguments[j]; i++) {

       if (arguments[j] % i == 0) {
         body.innerHTML += arguments[j] + " False &lt;br /&gt;";
         flag = false;
         break;

       } else {
         flag = true;

       }

     }
     if (flag) {
       body.innerHTML += arguments[j] + " True &lt;br /&gt;";

     }

   }

 }

 var data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

 prime.apply(null, data);</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;div id="solution"&gt;

&lt;/div&gt;</code></pre>
</div>
</div>
</p>


blocks|key|1504649|text|这段著名的代码来自一个著名的JS忍者|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504650|var+isPrime+=+n+=>+Array(Math.ceil(Math.sqrt(n)%2B1)).fill().map((e,i)=>i).slice(2).every(m+=>+n%25m);

console.log(Array(100).fill().map((e,i)=>i%2B1).slice(1).filter(isPrime));|code-block|syntax|javascript|1504651|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>And this famous code from a famous JS Ninja</p>

<pre><code>var isPrime = n =&gt; Array(Math.ceil(Math.sqrt(n)+1)).fill().map((e,i)=&gt;i).slice(2).every(m =&gt; n%m);

console.log(Array(100).fill().map((e,i)=&gt;i+1).slice(1).filter(isPrime));
</code></pre>


blocks|key|3874284|text|我稍微修改了Sieve+of+Sundaram算法，以减少不必要的迭代，它似乎非常快。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3874285|这个算法实际上比这个主题下最被接受的@Ted+Hopp's+solution快两倍。解决78498+-+1M之间的质数在Chrome55中需要20~25毫秒，在FF+50.1中<+90毫秒。此外，@vitaly-t's+get+next+prime+algorithm看起来很有趣，但结果也要慢得多。|3874286|这是核心算法。人们可以应用分割和线程来获得极好的结果。|3874287|​|3874288|"use+strict";
function+primeSieve(n){
++var+a+=+Array(n+=+n/2),
++++++t+=+(Math.sqrt(4%2B8*n)-2)/4,
++++++u+=+0,
++++++r+=+[];
++for(var+i+=+1;+i+<=+t;+i%2B%2B){
++++u+=+(n-i)/(1%2B2*i);
++++for(var+j+=+i;+j+<=+u;+j%2B%2B)+a[i+%2B+j+%2B+2*i*j]+=+true;
++}
++for(var+i+=+0;+i<=+n;+i%2B%2B)+!a[i]+&&+r.push(i*2%2B1);
++return+r;
}

var+primes+=+[];
console.time("primes");
primes+=+primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);|code-block|syntax|javascript|3874289|3874290|解释了循环限制：|style|BOLD|3874291|Sundaram算法的筛子也从列表中剔除了一些选定的整数，就像Erasthotenes的筛子一样。为了选择要划掉的整数，规则是i%2Bj%2B+2ij≤n，其中i和j是两个索引，n是总元素的数量。一旦我们划掉每个i%2Bj%2B+2ij，剩下的数字就会加倍和奇怪(2n%2B1)，以显示一个质数列表。最后一个阶段实际上是自动打折偶数。here很好地解释了这一点。|3874292|Sundaram的筛子只有在循环索引起始和结束限制被正确选择的情况下才是快速的，以便不存在(或最小)冗余(多个)非素数的消除。因为我们需要i和j的值来计算要划掉的数字，所以i%2Bj%2B+2ij直到n，让我们看看如何处理。|3874293|I)，所以我们必须找到i和j相等时可以取的最大值。这是2i+%2B+2i%5E2+=+n，我们可以很容易地用二次公式来求解i的正值，这就是t+=+(Math.sqrt(4%2B8*n)-2)/4,直线|CODE|3874294|j)内部循环索引j应该从i开始，并一直运行到它可以使用当前i值的点。仅此而已。因为我们知道i%2Bj%2B+2ij+=+n，所以可以很容易地计算出u+=+(n-i)/(1%2B2*i);|3874295|虽然这不会完全消除冗余交叉，但它将“极大地”消除冗余。例如，对于n=+50+(检查素数到100)，而不是做50+x+50+=+2500，我们总共只做30次迭代。所以很明显，这个算法不应该被认为是O(n%5E2)时间复杂度的算法。|3874296|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|3874297|其中只有5个副本。22，31，37，40，49。当n=100时，冗余度约为20%25，而当n=+10M时，冗余度增加到~300%25。这意味着，随着n的增长，SoS的进一步优化有可能以更快的速度获得结果。因此，一个想法可能是分段，并始终保持n较小。|3874298|所以好吧..。我已经决定进一步探索这个问题。|3874299|经过对重复交叉的一些仔细检查，我已经意识到这样一个事实，除了i+===+1情况之外，如果i或j索引值中的一个或两个都在4，7，10，13，16，19之间...序列，则会生成重复的交叉。然后，仅当i%253-1+!==+0时才允许内循环转动，从而实现了循环总数的进一步减少，例如35-40%25。例如，对于1M整数，嵌套循环的总轮数从1.4M下降到1M。哇..！我们在这里讨论的几乎是O(n)。|3874300|我刚刚做了一个测试。在JS中，仅计数到1B的空循环就需要大约4000ms。在下面的改进算法中，找到100M以内的素数需要相同的时间。|3874301|我还实现了这个算法的分割部分，以推送到工人。这样我们也可以使用多个线程。但这段代码将在稍后发布。|3874302|所以让我介绍一下Sundaram的改进型筛子，可能在不分段的情况下最好。它可以用Chrome+V8和Edge+ChakraCore在15-20ms内计算出0-1M之间的质数。|3874303|3874304|"use+strict";
function+primeSieve(n){
++var+a+=+Array(n+=+n/2),
++++++t+=+(Math.sqrt(4%2B8*n)-2)/4,
++++++u+=+0,
++++++r+=+[];
++for(var+i+=+1;+i+<+(n-1)/3;+i%2B%2B)+a[1%2B3*i]+=+true;
++for(var+i+=+2;+i+<=+t;+i%2B%2B){
++++u+=+(n-i)/(1%2B2*i);
++++if+(i%253-1)+for(var+j+=+i;+j+<+u;+j%2B%2B)+a[i+%2B+j+%2B+2*i*j]+=+true;
++}
++for(var+i+=+0;+i<+n;+i%2B%2B)+!a[i]+&&+r.push(i*2%2B1);
++return+r;
}

var+primes+=+[];
console.time("primes");
primes+=+primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);|3874305|3874306|好吧..。最后，我猜我已经实现了一个筛子(它起源于巧妙的Sundaram筛子)，它是我在互联网上能找到的最快的JavaScript筛子，包括“Eratosthenes的唯一赔率筛子”或“阿特金斯筛子”。这也为web工作者准备好了，多线程。|3874307|这样想吧。在这个简陋的单线程AMD+PC中，JS仅计数到10%5E9就需要3,300ms，下面优化的分段SoS将使我在14,000ms内将50847534个素数计数到10%5E9。这意味着仅仅是计数操作的4.25倍。我认为这是令人印象深刻的。|3874308|你可以自己测试一下；|3874309|3874310|console.time("tare");
for+(var+i+=+0;+i+<+1000000000;+i%2B%2B);
console.timeEnd("tare");|3874311|3874312|在这里，我将向你介绍Sundaram的最好的分段Seieve。|3874313|3874314|"use+strict";
function+findPrimes(n){
++
++function+primeSieve(g,o,r){
++++var+t+=+(Math.sqrt(4%2B8*(g%2Bo))-2)/4,
++++++++e+=+0,
++++++++s+=+0;
++++
++++ar.fill(true);
++++if+(o)+{
++++++for(var+i+=+Math.ceil((o-1)/3);+i+<+(g%2Bo-1)/3;+i%2B%2B)+ar[1%2B3*i-o]+=+false;
++++++for(var+i+=+2;+i+<+t;+i%2B%2B){
++++++++s+=+Math.ceil((o-i)/(1%2B2*i));
++++++++e+=+(g%2Bo-i)/(1%2B2*i);
++++++++if+(i%253-1)+for(var+j+=+s;+j+<+e;+j%2B%2B)+ar[i+%2B+j+%2B+2*i*j-o]+=+false;
++++++}
++++}+else+{
++++++++for(var+i+=+1;+i+<+(g-1)/3;+i%2B%2B)+ar[1%2B3*i]+=+false;
++++++++for(var+i+=+2;+i+<+t;+i%2B%2B){
++++++++++e+=+(g-i)/(1%2B2*i);
++++++++++if+(i%253-1)+for(var+j+=+i;+j+<+e;+j%2B%2B)+ar[i+%2B+j+%2B+2*i*j]+=+false;
++++++++}
++++++}
++++for(var+i+=+0;+i+<+g;+i%2B%2B)+ar[i]+&&+r.push((i%2Bo)*2%2B1);
++++return+r;
++}
++
++var+cs+=+n+<=+1e6+?+7500
++++++++++++++++++++:+n+<=+1e7+?+60000
+++++++++++++++++++++++++++++++:+100000,+//+chunk+size
++++++cc+=+~~(n/cs),+++++++++++++++++++++//+chunk+count
++++++xs+=+n+%25+cs,+++++++++++++++++++++++//+excess+after+last+chunk
++++++ar+=+Array(cs/2),++++++++++++++++++//+array+used+as+map
++result+=+[];
++
++for(var+i+=+0;+i+<+cc;+i%2B%2B)+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);|3874315|3874316|我不确定还能不能比这更好。我很想听听你的意见。|3874317|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Sieve_of_Sundaram|1|https://stackoverflow.com/a/12287599|2|https://stackoverflow.com/a/32890203|3|https://en.wikipedia.org/wiki/Sieve_of_Sundaram#Correctness^0|6|H|0|0|I|K|1|2Q|10|2|0|0|0|0|0|3|5|0|4D|4|3|0|0|1T|R|0|0|2|1X|I|0|0|0|0|0|U|7|18|1|1A|1|2P|B|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2I|8|@]|9|@$A|2J|B|2K|1|2L]]|C|$]]|$1|D|3|E|5|6|7|2M|8|@]|9|@$A|2N|B|2O|1|2P]|$A|2Q|B|2R|1|2S]]|C|$]]|$1|F|3|G|5|6|7|2T|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|2U|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|2V|8|@]|9|@]|C|$M|N]]|$1|O|3|I|5|6|7|2W|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|2X|8|@$A|2Y|B|2Z|R|S]]|9|@]|C|$]]|$1|T|3|U|5|6|7|30|8|@]|9|@$A|31|B|32|1|33]]|C|$]]|$1|V|3|W|5|6|7|34|8|@]|9|@]|C|$]]|$1|X|3|Y|5|6|7|35|8|@$A|36|B|37|R|Z]]|9|@]|C|$]]|$1|10|3|11|5|6|7|38|8|@$A|39|B|3A|R|S]|$A|3B|B|3C|R|Z]]|9|@]|C|$]]|$1|12|3|13|5|6|7|3D|8|@]|9|@]|C|$]]|$1|14|3|15|5|L|7|3E|8|@]|9|@]|C|$M|N]]|$1|16|3|17|5|6|7|3F|8|@]|9|@]|C|$]]|$1|18|3|19|5|6|7|3G|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|6|7|3H|8|@$A|3I|B|3J|R|Z]|$A|3K|B|3L|R|Z]|$A|3M|B|3N|R|Z]|$A|3O|B|3P|R|Z]]|9|@]|C|$]]|$1|1C|3|1D|5|6|7|3Q|8|@]|9|@]|C|$]]|$1|1E|3|1F|5|6|7|3R|8|@]|9|@]|C|$]]|$1|1G|3|1H|5|6|7|3S|8|@]|9|@]|C|$]]|$1|1I|3|I|5|6|7|3T|8|@]|9|@]|C|$]]|$1|1J|3|1K|5|L|7|3U|8|@]|9|@]|C|$M|N]]|$1|1L|3|I|5|6|7|3V|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|6|7|3W|8|@]|9|@]|C|$]]|$1|1O|3|1P|5|6|7|3X|8|@]|9|@]|C|$]]|$1|1Q|3|1R|5|6|7|3Y|8|@]|9|@]|C|$]]|$1|1S|3|I|5|6|7|3Z|8|@]|9|@]|C|$]]|$1|1T|3|1U|5|L|7|40|8|@]|9|@]|C|$M|N]]|$1|1V|3|I|5|6|7|41|8|@]|9|@]|C|$]]|$1|1W|3|1X|5|6|7|42|8|@]|9|@]|C|$]]|$1|1Y|3|I|5|6|7|43|8|@]|9|@]|C|$]]|$1|1Z|3|20|5|L|7|44|8|@]|9|@]|C|$M|N]]|$1|21|3|I|5|6|7|45|8|@]|9|@]|C|$]]|$1|22|3|23|5|6|7|46|8|@]|9|@]|C|$]]|$1|24|3|-4|5|6|7|47|8|@]|9|@]|C|$]]]|25|$26|$5|27|28|29|C|$2A|2B]]|2C|$5|27|28|29|C|$2A|2D]]|2E|$5|27|28|29|C|$2A|2F]]|2G|$5|27|28|29|C|$2A|2H]]]]

<p>I have slightly modified the <a href="https://en.wikipedia.org/wiki/Sieve_of_Sundaram" rel="noreferrer">Sieve of Sundaram</a> algorithm to cut the unnecessary iterations and it seems to be very fast.</p>

<p>This algorithm is actually two times faster than the most accepted <a href="https://stackoverflow.com/a/12287599">@Ted Hopp's solution</a> under this topic. Solving the 78498 primes between 0 - 1M takes like 20~25 msec in Chrome 55 and &lt; 90 msec in FF 50.1. Also <a href="https://stackoverflow.com/a/32890203">@vitaly-t's get next prime algorithm</a> looks interesting but also results much slower.</p>

<p>This is the core algorithm. One could apply segmentation and threading to get superb results.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>"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 &lt;= t; i++){
    u = (n-i)/(1+2*i);
    for(var j = i; j &lt;= u; j++) a[i + j + 2*i*j] = true;
  }
  for(var i = 0; i&lt;= n; i++) !a[i] &amp;&amp; r.push(i*2+1);
  return r;
}

var primes = [];
console.time("primes");
primes = primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);</code></pre>
</div>
</div>
</p>

<p><strong>The loop limits explained:</strong></p>

<p>Just like the Sieve of Erasthotenes, the Sieve of Sundaram algorithm also crosses out some selected integers from the list. To select which integers to cross out the rule is i + j + 2ij ≤ n where i and j are two indices and n is the number of the total elements. Once we cross out every i + j + 2ij, the remaining numbers are doubled and oddified (2n+1) to reveal a list of prime numbers. The final stage is in fact the auto discounting of the even numbers. It's proof is beautifully explained <a href="https://en.wikipedia.org/wiki/Sieve_of_Sundaram#Correctness" rel="noreferrer">here</a>.</p>

<p>Sieve of Sundaram is only fast if the loop indices start and end limits are correctly selected such that there shall be no (or minimal) redundant (multiple) elimination of the non-primes. As we need i and j values to calculate the numbers to cross out, i + j + 2ij up to n let's see how we can approach.</p>

<p><strong>i)</strong> So we have to find the the max value i and j can take when they are equal. Which is 2i + 2i^2 = n. We can easily solve the positive value for i by using the quadratic formula and that is the line with <code>t = (Math.sqrt(4+8*n)-2)/4,</code></p>

<p><strong>j)</strong> The inner loop index j should start from i and run up to the point it can go with the current i value. No more than that. Since we know that i + j + 2ij = n, this can easily be calculated as <code>u = (n-i)/(1+2*i);</code></p>

<p>While this will not completely remove the redundant crossings it will "greatly" eliminate the redundancy. For instance for n = 50 (to check for primes up to 100) instead of doing 50 x 50 = 2500, we will do only 30 iterations in total. So clearly, this algorithm shouldn't be considered as an O(n^2) time complexity one.</p>

<pre><code>i  j  v
1  1  4
1  2  7
1  3 10
1  4 13
1  5 16
1  6 19
1  7 22  &lt;&lt;
1  8 25
1  9 28
1 10 31  &lt;&lt;
1 11 34
1 12 37  &lt;&lt;
1 13 40  &lt;&lt;
1 14 43
1 15 46
1 16 49  &lt;&lt;
2  2 12
2  3 17
2  4 22  &lt;&lt; dupe #1
2  5 27
2  6 32
2  7 37  &lt;&lt; dupe #2
2  8 42
2  9 47
3  3 24
3  4 31  &lt;&lt; dupe #3
3  5 38
3  6 45
4  4 40  &lt;&lt; dupe #4
4  5 49  &lt;&lt; dupe #5
</code></pre>

<p>among which there are only 5 duplicates. 22, 31, 37, 40, 49. The redundancy is around 20% for n = 100 however it increases to ~300% for n = 10M. Which means a further optimization of SoS bears the potentital to obtain the results even faster as n grows. So one idea might be segmentation and to keep n small all the time.</p>

<p>So OK.. I have decided to take this quest a little further.</p>

<p>After some careful examination of the repeated crossings I have come to the awareness of the fact that, by the exception of <code>i === 1</code> case, if either one or both of the <code>i</code> or <code>j</code> index value is among 4,7,10,13,16,19... series, a duplicate crossing is generated. Then allowing the inner loop to turn only when <code>i%3-1 !== 0</code>, a further cut down like 35-40% from the total number of the loops is achieved. So for instance for 1M integers the nested loop's total turn count dropped to like 1M from 1.4M. Wow..! We are talking almost O(n) here.</p>

<p>I have just made a test. In JS, just an empty loop counting up to 1B takes like 4000ms. In the below modified algorithm, finding the primes up to 100M takes the same amount of time.</p>

<p>I have also implemented the segmentation part of this algorithm to push to the workers. So that we will be able to use multiple threads too. But that code will follow a little later.</p>

<p>So let me introduce you the modified Sieve of Sundaram probably at it's best when not segmented. It shall compute the primes between 0-1M in about 15-20ms with Chrome V8 and Edge ChakraCore.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>"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 &lt; (n-1)/3; i++) a[1+3*i] = true;
  for(var i = 2; i &lt;= t; i++){
    u = (n-i)/(1+2*i);
    if (i%3-1) for(var j = i; j &lt; u; j++) a[i + j + 2*i*j] = true;
  }
  for(var i = 0; i&lt; n; i++) !a[i] &amp;&amp; r.push(i*2+1);
  return r;
}

var primes = [];
console.time("primes");
primes = primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);</code></pre>
</div>
</div>
</p>

<p>Well... finally I guess i have implemented a sieve (which is originated from the ingenious Sieve of Sundaram) such that it's the fastest JavaScript sieve that i could have found over the internet, including the "Odds only Sieve of Eratosthenes" or the "Sieve of Atkins". Also this is ready for the web workers, multi-threading.</p>

<p>Think it this way. In this humble AMD PC for a single thread, it takes 3,300 ms for JS just to count up to 10^9 and the following optimized  segmented SoS  will get me the 50847534 primes up to 10^9 only in 14,000 ms. Which means 4.25 times the operation of just counting. I think it's impressive.</p>

<p>You can test it for yourself;</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>console.time("tare");
for (var i = 0; i &lt; 1000000000; i++);
console.timeEnd("tare");</code></pre>
</div>
</div>
</p>

<p>And here i introduce you to the segmented Seieve of Sundaram at it's best.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>"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 &lt; (g+o-1)/3; i++) ar[1+3*i-o] = false;
      for(var i = 2; i &lt; 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 &lt; e; j++) ar[i + j + 2*i*j-o] = false;
      }
    } else {
        for(var i = 1; i &lt; (g-1)/3; i++) ar[1+3*i] = false;
        for(var i = 2; i &lt; t; i++){
          e = (g-i)/(1+2*i);
          if (i%3-1) for(var j = i; j &lt; e; j++) ar[i + j + 2*i*j] = false;
        }
      }
    for(var i = 0; i &lt; g; i++) ar[i] &amp;&amp; r.push((i+o)*2+1);
    return r;
  }
  
  var cs = n &lt;= 1e6 ? 7500
                    : n &lt;= 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 &lt; 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);</code></pre>
</div>
</div>
</p>

<p>I am not sure if it gets any better than this. I would love to hear your opinions.</p>


blocks|key|3874333|text|使用ES6的新功能构建的列表，特别是使用生成器。去https://codepen.io/arius/pen/wqmzGp+made+in+Catalan+language和我的学生一起上课。我希望你会发现它是有用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3874334|​|3874335|function*+Primer(max)+{+
++const+infinite+=+!max+&&+max+!==+0;
++const+re+=+/%5E.?$%7C%5E(..%2B?)\1%2B$/;+
++let+current+=+1;
+
++while+(infinite+%7C%7C+max--+)+{
++++++if(!re.test('1'.repeat(current))+==+true)+yield+current;
++++++current%2B%2B
++};
};


let+[...list]+=+Primer(100);+
console.log(list);|code-block|syntax|javascript|3874336|3874337|entityMap|0|LINK|mutability|MUTABLE|url|https://codepen.io/arius/pen/wqmzGp^0|P|Z|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Y|8|@]|9|@]|C|$I|J]]|$1|K|3|E|5|6|7|Z|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

<p>A list built using the new features of ES6, especially with generator.
Go to <a href="https://codepen.io/arius/pen/wqmzGp" rel="nofollow noreferrer">https://codepen.io/arius/pen/wqmzGp</a> made in Catalan language for classes with my students. I hope you find it useful.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function* Primer(max) { 
  const infinite = !max &amp;&amp; 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);</code></pre>
</div>
</div>
</p>


blocks|key|3874339|text|public+static+void+main(String[]+args)+{
++++int+m+=+100;
++++int+a[]+=new+int[m];
++++for+(int+i=2;+i<m;+i%2B%2B)
++++++++for+(int+j=0;+j<m;+j%2B=i)
++++++++++++a[j]%2B%2B;
++++for+(int+i=0;+i<m;+i%2B%2B)
++++++++if+(a[i]==1)+System.out.println(i);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3874340|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static void main(String[] args) {
    int m = 100;
    int a[] =new int[m];
    for (int i=2; i&lt;m; i++)
        for (int j=0; j&lt;m; j+=i)
            a[j]++;
    for (int i=0; i&lt;m; i++)
        if (a[i]==1) System.out.println(i);
}
</code></pre>


blocks|key|5291425|text|下面是在给定范围(1到极限)之间计算素数的非常简单的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291426|简单解决方案|offset|length|style|BOLD|5291427|++++public+static+void+getAllPrimeNumbers(int+limit)+{

++++++++System.out.println("Printing+prime+number+from+1+to+"+%2B+limit);

++++++++for(int+number=2;+number<=limit;+number%2B%2B){
++++++++++++//***print+all+prime+numbers+upto+limit***
++++++++++++if(isPrime(number)){
++++++++++++++++System.out.println(number);
++++++++++++}
++++++++}
++++}


++++public+static+boolean+isPrime(int+num)+{
++++++++if+(num+==+0+%7C%7C+num+==+1)+{
++++++++++++return+false;
++++++++}
++++++++if+(num+==+2)+{+
++++++++++++return+true;
++++++++}

++++++++for+(int+i+=+2;+i+<=+num+/+2;+i%2B%2B)+{
++++++++++++if+(num+%25+i+==+0)+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++return+true;
++++}|code-block|syntax|javascript|5291428|entityMap^0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>Here's the very simple way to calculate primes between a given range(1 to limit).</p>

<p><strong>Simple Solution</strong>:</p>

<pre><code>    public static void getAllPrimeNumbers(int limit) {

        System.out.println("Printing prime number from 1 to " + limit);

        for(int number=2; number&lt;=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 &lt;= num / 2; i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
</code></pre>


blocks|key|1763880|text|你也可以尝试这种方法，这是一个很基本但很容易理解的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763881|+var+tw+=+2,+th+=+3,+fv+=+5,+se+=+7;+

+document.write(tw+%2B+","+%2B+th+%2B+","%2B+fv+%2B+","+%2B+se+%2B+",");


for(var+n+=+0;+n+<=+100;+n%2B%2B)
{

++if((n+%25+tw+!==+0)+&&+(n+%25+th+!==0)+&&+(n+%25+fv+!==0+)+&&+(n+%25+se+!==0))

++{
++++++if+(n+==+1)
++++++{
++++++++++continue;
++++++}

++++document.write(n+%2B",");
++}
}|code-block|syntax|javascript|1763882|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h2>You can try this method also, this one is basic but easy to understand:</h2>

<pre><code> var tw = 2, th = 3, fv = 5, se = 7; 

 document.write(tw + "," + th + ","+ fv + "," + se + ",");


for(var n = 0; n &lt;= 100; n++)
{

  if((n % tw !== 0) &amp;&amp; (n % th !==0) &amp;&amp; (n % fv !==0 ) &amp;&amp; (n % se !==0))

  {
      if (n == 1)
      {
          continue;
      }

    document.write(n +",");
  }
}
</code></pre>


blocks|key|5291460|text|++++++++++++var+n=100;
++++++++++++var+counter+=+0;
++++++++++++var+primeNumbers+=+"Prime+Numbers:+";
++++++++++++for(var+i=2;+i<=n;+%2B%2Bi)
++++++++++++{
++++++++++++++++counter=0;
++++++++++++++++for(var+j=2;+j<=n;+%2B%2Bj)
++++++++++++++++{
++++++++++++++++++++if(i>=j+&&+i%25j+==+0)
++++++++++++++++++++{
++++++++++++++++++++++++%2B%2Bcounter;
++++++++++++++++++++}

++++++++++++++++}
++++++++++++++++if(counter+==+1)
++++++++++++++++++++{
++++++++++++++++++++++++primeNumbers+=+primeNumbers+%2B+i+%2B+"++";
++++++++++++++++++++}

++++++++++++}
++++++++++++console.log(primeNumbers);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5291461|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>            var n=100;
            var counter = 0;
            var primeNumbers = "Prime Numbers: ";
            for(var i=2; i&lt;=n; ++i)
            {
                counter=0;
                for(var j=2; j&lt;=n; ++j)
                {
                    if(i&gt;=j &amp;&amp; i%j == 0)
                    {
                        ++counter;
                    }

                }
                if(counter == 1)
                    {
                        primeNumbers = primeNumbers + i + "  ";
                    }

            }
            console.log(primeNumbers);
</code></pre>


blocks|key|3874382|text|function+isPrime(num)+{
++for(var+i+=+2;+i+<+num;+i%2B%2B)
++++if(num+%25+i+===+0)+return+false;
++return+num+;
}
function+primes(n){
++var+array_of_primes=[];
for(var+i+=+2;+i+<+n;+i%2B%2B){
++++if(isPrime(i))+array_of_primes.push(i)>1;
+++++}
+++return+array_of_primes;
}
document.write(primes(10000));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3874383|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function isPrime(num) {
  for(var i = 2; i &lt; num; i++)
    if(num % i === 0) return false;
  return num ;
}
function primes(n){
  var array_of_primes=[];
for(var i = 2; i &lt; n; i++){
    if(isPrime(i)) array_of_primes.push(i)&gt;1;
     }
   return array_of_primes;
}
document.write(primes(10000));
</code></pre>


blocks|key|5291506|text|我最近想出了一个单行解决方案，可以在Scrimba上的JS挑战中实现这一点(如下所示)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5291507|ES6%2B|offset|length|style|BOLD|5291508|const+getPrimes=num=>Array(num-1).fill().map((e,i)=>2%2Bi).filter((e,i,a)=>a.slice(0,i).every(x=>e%25x!==0));|code-block|syntax|javascript|5291509|<+ES6|5291510|function+getPrimes(num){return+",".repeat(num).slice(0,-1).split(',').map(function(e,i){return+i%2B1}).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%25e!==0})})};|5291511|这是解释的逻辑：|5291512|5291513|首先，该函数使用所需的数字(100)作为中继器参数，通过.repeat()函数构建到所需数字(在本例中为100)之前的所有数字的数组，然后将该数组映射到indexes%2B1，以获得从0到该数字(0-100)的范围。这里正在进行一些字符串拆分和加入的魔术。如果你愿意，我很乐意进一步解释这一步。|ordered-list-item|CODE|5291514|5291515|5291516|我们从数组中排除了0和1，因为它们不应该被测试为质数，以免它们给出假阳性。两个都不是质数。|5291517|仅对大于1的数字使用.filter()+(≥2)。|5291518|5291519|现在，我们只为质数过滤2到所需数字(100)之间的所有整数的新数组。为了只过滤质数，我们在第一步中使用了一些相同的魔术。我们再次使用.filter()和.repeat()创建一个从2开始的新数组，以便从新的数字数组中每个值。对于每个值的新数组，我们检查数字≥2和<+that+number是否为该数字的因子。我们可以使用与模运算符%25配对的.every()方法来检查该数字除以2与其本身之间的任何值时是否有余数。如果每个值都有余数(x%25e!==0)，则从2到该数字(但不包括该数字，即:+2,99)的所有值都满足该条件，我们可以说该数字是质数。filter函数将所有质数返回到最上面的返回值，从而返回介于2和传递的值之间的质数列表。|5291520|5291521|例如，使用我在上面添加的这些函数之一，返回以下内容：|5291522|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]|5291523|entityMap^0|0|0|4|0|0|0|5|0|0|0|0|S|9|0|0|0|0|A|9|0|0|1U|9|24|9|4L|1|4P|8|5Z|7|30|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1I|8|@$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1L|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1M|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|T|3|U|5|V|7|1O|8|@$D|1P|E|1Q|F|W]]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Z|3|10|5|V|7|1T|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1U|8|@$D|1V|E|1W|F|W]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|14|3|15|5|V|7|1Y|8|@$D|1Z|E|20|F|W]|$D|21|E|22|F|W]|$D|23|E|24|F|W]|$D|25|E|26|F|W]|$D|27|E|28|F|W]|$D|29|E|2A|F|G]]|9|@]|A|$]]|$1|16|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|2C|8|@]|9|@]|A|$]]|$1|19|3|1A|5|J|7|2D|8|@]|9|@]|A|$K|L]]|$1|1B|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1C|$]]

<p>I recently came up with a one-line solution that accomplishes exactly this for a JS challenge on Scrimba (below).</p>
<p><strong>ES6+</strong></p>
<pre class="lang-js prettyprint-override"><code>const getPrimes=num=&gt;Array(num-1).fill().map((e,i)=&gt;2+i).filter((e,i,a)=&gt;a.slice(0,i).every(x=&gt;e%x!==0));
</code></pre>
<p><strong>&lt; ES6</strong></p>
<pre class="lang-js prettyprint-override"><code>function getPrimes(num){return &quot;,&quot;.repeat(num).slice(0,-1).split(',').map(function(e,i){return i+1}).filter(function(e){return e&gt;1}).filter(function(x){return &quot;,&quot;.repeat(x).slice(0,-1).split(',').map(function(f,j){return j}).filter(function(e){return e&gt;1}).every(function(e){return x%e!==0})})};
</code></pre>
<p>This is the logic explained:</p>
<ol>
<li><p>First, the function builds an array of all numbers leading up to the desired number (in this case, 100) via the <code>.repeat()</code> function using the desired number (100) as the repeater argument and then mapping the array to the indexes+1 to get the range of numbers from 0 to that number (0-100). A bit of string splitting and joining magic going on here. I'm happy to explain this step further if you like.</p>
</li>
<li><p>We exclude 0 and 1 from the array as they should not be tested for prime, lest they give a false positive. Neither are prime. We do this using <code>.filter()</code> for only numbers &gt; 1 (≥ 2).</p>
</li>
<li><p>Now, we filter our new array of all integers between 2 and the desired number (100) for only prime numbers. To filter for prime numbers only, we use some of the same magic from our first step. We use <code>.filter()</code> and <code>.repeat()</code> once again to create a new array from 2 to <strong>each</strong> value from our new array of numbers. For each value's new array, we check to see if any of the numbers ≥ 2 and &lt; that number are factors of the number. We can do this using the <code>.every()</code> method paired with the modulo operator <code>%</code> to check if that number has any remainders when divided by any of those values between 2 and itself. If each value has remainders (<code>x%e!==0</code>), the condition is met for all values from 2 to that number (but not including that number, i.e.: [2,99]) and we can say that number is prime. The filter functions returns all prime numbers to the uppermost return, thereby returning the list of prime values between 2 and the passed value.</p>
</li>
</ol>
<p>As an example, using one of these functions I've added above, returns the following:</p>
<pre class="lang-js prettyprint-override"><code>getPrimes(100);
// =&gt; [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]
</code></pre>


blocks|key|1500094|text|我正在寻找如何找到质数，并通过上面的代码太长了。我找到了质数的一个新的简单的解决方案，并使用过滤器将它们相加。请建议我，如果我的代码中有任何错误，因为我是一个初学者。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1500095|function+sumPrimes(num)+{

let+newNum+=+[];

for(let+i+=+2;+i+<=+num;+i%2B%2B)+{
newNum.push(i)
}
for(let+i+in+newNum)+{

newNum+=+newNum.filter(item+=>+item+==+newNum[i]+%7C%7C+item+%25+newNum[i]+!==+0)
}

return+newNum.reduce((a,b)+=>+a%2Bb)
}

sumPrimes(10);|code-block|syntax|javascript|1500096|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I was searching how to find out prime number and went through above code which are too long. I found out a new easy solution for prime number and add them using filter. Kindly suggest me if there is any mistake in my code as I am a beginner.</p>
<pre><code>function sumPrimes(num) {

let newNum = [];

for(let i = 2; i &lt;= num; i++) {
newNum.push(i)
}
for(let i in newNum) {

newNum = newNum.filter(item =&gt; item == newNum[i] || item % newNum[i] !== 0)
}

return newNum.reduce((a,b) =&gt; a+b)
}

sumPrimes(10);
</code></pre>


blocks|key|1500098|text|这里是一个使用JS生成器的高效、简短的解决方案。JSfiddle|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1500099|​|1500100|//+Consecutive+integers
let+nats+=+function*+(n)+{
++++while+(true)+yield+n%2B%2B
}

//+Wrapper+generator
let+primes+=+function*+()+{
++++yield*+sieve(primes(),+nats(2))
}

//+The+sieve+itself;+only+tests+primes+up+to+sqrt(n)
let+sieve+=+function*+(pg,+ng)+{
++++yield+ng.next().value;
++++let+n,+p+=+pg.next().value;
++++while+((n+=+ng.next().value)+<+p+*+p)+yield+n;
++++yield*+sieve(pg,+(function*+()+{
++++++++while+(n+=+ng.next().value)+if+(n+%25+p)+yield+n
++++})())
}

//+Longest+prefix+of+stream+where+some+predicate+holds
let+take+=+function*+(vs,+fn)+{
++++let+nx;
++++while+(!(nx+=+vs.next()).done+&&+fn(nx.value))+yield+nx.value
}

document.querySelectorAll('dd')[0].textContent+=

//+Primes+smaller+than+100
++++[...take(primes(),+x+=>+x+<+100)].join(',+')|code-block|syntax|javascript|1500101|<dl>
<dt>Primes+under+100</dt>
<dd></dd>
</dl>|1500102|1500103|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/95zvutyk/^0|O|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|10|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|M|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]]]

<p>Here is an efficient, short solution using JS generators. <a href="https://jsfiddle.net/95zvutyk/" rel="nofollow noreferrer">JSfiddle</a></p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>// Consecutive integers
let nats = function* (n) {
    while (true) yield n++
}

// Wrapper generator
let primes = function* () {
    yield* sieve(primes(), nats(2))
}

// The sieve itself; only tests primes up to sqrt(n)
let sieve = function* (pg, ng) {
    yield ng.next().value;
    let n, p = pg.next().value;
    while ((n = ng.next().value) &lt; p * p) yield n;
    yield* sieve(pg, (function* () {
        while (n = ng.next().value) if (n % p) yield n
    })())
}

// Longest prefix of stream where some predicate holds
let take = function* (vs, fn) {
    let nx;
    while (!(nx = vs.next()).done &amp;&amp; fn(nx.value)) yield nx.value
}

document.querySelectorAll('dd')[0].textContent =

// Primes smaller than 100
    [...take(primes(), x =&gt; x &lt; 100)].join(', ')</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;dl&gt;
&lt;dt&gt;Primes under 100&lt;/dt&gt;
&lt;dd&gt;&lt;/dd&gt;
&lt;/dl&gt;</code></pre>
</div>
</div>
</p>


blocks|key|1763992|text|没有任何循环的版本。对您拥有的任何数组使用此方法。即，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763993|[1,2,3...100].filter(x=>isPrime(x));
const+isPrime+=+n+=>+{
if(n===1){
return+false;
}
if([2,3,5,7].includes(n)){
return+true;
}
return+n%252!=0+&&+n%253!=0+&&+n%255!=0+&&+n%257!=0;
}|code-block|syntax|javascript|1763994|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>A version without any loop. Use this against any array you have. ie.,</p>
<pre><code>[1,2,3...100].filter(x=&gt;isPrime(x));
const isPrime = n =&gt; {
if(n===1){
return false;
}
if([2,3,5,7].includes(n)){
return true;
}
return n%2!=0 &amp;&amp; n%3!=0 &amp;&amp; n%5!=0 &amp;&amp; n%7!=0;
}
</code></pre>


<p>In Javascript how would i find prime numbers between 0 - 100? i have thought about it, and i am not sure how to find them. i thought about doing x % x but i found the obvious problem with that.
this is what i have so far:
but unfortunately it is the worst code ever.</p>

<pre><code>var prime = function (){
var num;
for (num = 0; num &lt; 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());
</code></pre>


How to find prime numbers between 0 - 100?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Javascript中，我如何找到0- 100之间的质数？我已经考虑过了，但我不确定如何找到它们。我想过做x%x，但我发现了明显的问题。这就是我到目前为止所拥有的:但不幸的是，这是有史以来最糟糕的代码。var prime = function (){var num;for (num = 0; num < 101; n...

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

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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