在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());
答案 0 :(得分：68)
以下是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实现看起来非常相似。
答案 1 :(得分：50)
以下是我如何解决它。将它从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）]就足够了。
答案 2 :(得分：26)
以下是此脚本的实时演示：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);
}
答案 3 :(得分：9)
答案 4 :(得分：8)
我稍微修改了Sieve of Sundaram算法以减少不必要的迭代，而且似乎非常快。
此算法实际上比本主题下最常用的@Ted Hopp's solution快两倍。解决0到1M之间的78498个素数在Chrome 55中需要20~25毫秒并且＆lt; FF 50.1中90毫秒。同样@vitaly-t's get next prime algorithm看起来很有趣但结果也慢得多。
这是核心算法。可以应用分段和线程来获得极好的结果。
"use strict";
function primeSieve(n){
var a = Array(n = n/2),
t = (Math.sqrt(4+8*n)-2)/4,
u = 0,
r = [];
for(var i = 1; i <= t; i++){
u = (n-i)/(1+2*i);
for(var j = i; j <= u; j++) a[i + j + 2*i*j] = true;
}
for(var i = 0; i<= n; i++) !a[i] && r.push(i*2+1);
return r;
}
var primes = [];
console.time("primes");
primes = primeSieve(1000000);
console.timeEnd("primes");
console.log(primes.length);
解释了循环限制：
就像Erasthotenes的Sieve一样，Sundaram算法的Sieve也从列表中删除了一些选定的整数。要选择哪个整数划掉规则，i + j +2ij≤n其中i和j是两个索引，n是总元素的数量。一旦我们划掉每个i + j + 2ij，剩下的数字就会加倍并变为奇数（2n + 1）以显示素数列表。最后阶段实际上是偶数的自动折扣。它的证明得到了很好的解释here。
如果正确选择循环索引的开始和结束限制，那么Sundaram的筛选速度很快，这样就不会有（或最小）冗余（多次）消除非素数。由于我们需要i和j值来计算要交叉的数字，i + j + 2ij直到n让我们看看我们如何接近。
i）所以我们必须找到i和j在它们相等时可以采用的最大值。这是2i + 2i ^ 2 = n。我们可以通过使用二次公式轻松求解i的正值，即t = (Math.sqrt(4+8*n)-2)/4,
j）内循环索引j应该从i开始并运行到它可以使用当前i值的点。仅此而已。由于我们知道i + j + 2ij = n，因此可以很容易地将其计算为u = (n-i)/(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个重复。对于n = 100，冗余度约为20％，但是对于n = 10M，冗余度增加到约300％。这意味着随着n的增长，进一步优化SoS可以更快地获得结果。所以一个想法可能是细分，并且一直保持小。
好吧..我决定进一步采取这个任务。
经过仔细检查反复交叉后，我开始意识到，除了i === 1案例外，i或{{1}中的任何一个或两个都是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-20ms内计算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 = (n-i)/(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筛子，包括＆＃ 34;赔率仅为Eratosthenes的筛子＆＃34;或者阿特金斯的筛子＆＃34;。这也适用于网络工作者，多线程。
这样想。在用于单线程的这款简陋的AMD PC中，JS需要3,300 ms才能计数到10 ^ 9，而以下优化的分段SoS将在14,000 ms内获得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*i-o] = false;
for(var i = 2; i < 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 < e; j++) ar[i + j + 2*i*j-o] = false;
}
} else {
for(var i = 1; i < (g-1)/3; i++) ar[1+3*i] = false;
for(var i = 2; i < t; i++){
e = (g-i)/(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);
我不确定它是否比这更好。我很想听听你的意见。
答案 5 :(得分：5)
如果数字不能被低于所讨论数字的其他素数整除，则数字是素数。
所以这会构建一个primes数组。测试每个新的奇数候选人n，以便对比primes低于n的现有找到的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);
作为最后一步。
{{1}}
答案 6 :(得分：3)
查找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;
}
答案 7 :(得分：2)
Luchian的答案为您提供了寻找素数的标准技术的链接。
效率较低但更简单的方法是将现有代码转换为嵌套循环。注意你除以2,3,4,5,6等等......然后把它变成一个循环。
鉴于这是家庭作业，并且假设家庭作业的目的是帮助您学习基本编程，那么简单，正确但效率低下的解决方案应该没问题。
答案 8 :(得分：2)
这是基于之前的素数价值计算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秒内为您提供前1个素数。
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>"
);
}
答案 9 :(得分：2)
使用递归结合here中的平方根规则，检查数字是否为素数：
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);
}
答案 10 :(得分：1)
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);
答案 11 :(得分：1)
这个来自着名JS忍者的着名代码
x*2+2答案 12 :(得分：1)
使用Eratosthenes的Sieve，source on 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))
答案 13 :(得分：1)
这是我的抨击。
将初始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 - 这需要一些时间，但似乎是准确的。
答案 14 :(得分：1)
使用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);
答案 15 :(得分：1)
这是在给定范围（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;
}
答案 16 :(得分：1)
Eratosthenes的筛子。它有点看，但它很简单，它的工作原理！
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);
答案 17 :(得分：1)
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 +",");
}
}
答案 18 :(得分：1)
<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>
答案 19 :(得分：1)
我最近想出了一种单线解决方案，可以完全解决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));
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})})};
这是解释的逻辑：
首先，该函数使用所需的数字（100）作为转发器参数，通过.repeat()函数构建一个包含所有数字的数组，最终导致所需的数字（在本例中为100）将数组映射到索引+1，以获取从0到该数字（0-100）的数字范围。一些字符串拆分和连接魔术在这里进行。如果您愿意，我很乐意进一步解释这一步骤。
我们从数组中排除0和1，因为不应对其进行素数测试，以免产生假阳性。都不是素数。我们仅对数字> 1（≥2）使用.filter()。
现在，我们只过滤质数为2到所需数字（100）之间的所有整数的新数组。为了仅过滤质数，我们从第一步开始使用一些相同的魔术。我们再次使用.filter()和.repeat()从新的数字数组中创建一个从2到每个值的新数组。对于每个值的新数组，我们检查是否≥2和<该数字的任何一个是该数字的因数。我们可以使用.every()方法和模运算符%配对来执行此操作，以检查该数字除以2与它自身之间的任何值时是否有余数。如果每个值都有余数（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]
答案 20 :(得分：1)
如果我们已经尝试通过 2 删除，为什么要尝试删除 4 （以及 6,8,10,12 ）？如果已经尝试通过 3 删除，为什么要尝试删除 9 ？如果 11 * 11 = 121＆gt;，为什么要尝试删除 11 100 ？为什么要尝试删除 2 的任何奇数？为什么要尝试删除任何甚至超过 2 的内容？
消除死测试，你将获得一个良好的代码测试 <100> 。
你的代码远远不是有史以来最糟糕的代码。许多许多其他人会尝试将 100 划分为 99 。但绝对冠军会生成2..96 2..96的所有产品，以测试 97 是否属于其中。 That one确实效率低得令人惊讶。
Sieve of Eratosthenes当然要好得多，而你可以拥有一个 - 100s - no arrays of booleans (and no divisions too!)：
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"
答案 21 :(得分：0)
public static void main(String[] args) {
int m = 100;
int a[] =new int[m];
for (int i=2; i<m; i++)
for (int j=0; j<m; j+=i)
a[j]++;
for (int i=0; i<m; i++)
if (a[i]==1) System.out.println(i);
}
答案 22 :(得分：0)
没有任何循环的版本。将此用于您拥有的任何阵列。即，
[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%2!=0 && n%3!=0 && n%5!=0 && n%7!=0;
}
答案 23 :(得分：0)
function isPrime(num) {
for(var i = 2; i < num; i++)
if(num % i === 0) return false;
return num ;
}
function primes(n){
var array_of_primes=[];
for(var i = 2; i < n; i++){
if(isPrime(i)) array_of_primes.push(i)>1;
}
return array_of_primes;
}
document.write(primes(10000));
答案 24 :(得分：0)
我正在搜索如何找出素数，并经历了太长的上述代码。我找到了一个新的质数简单解决方案，并使用过滤器添加它们。如果我是初学者，请建议我的代码中是否有任何错误。
function sumPrimes(num) {
let newNum = [];
for(let i = 2; i <= num; i++) {
newNum.push(i)
}
for(let i in newNum) {
newNum = newNum.filter(item => item == newNum[i] || item % newNum[i] !== 0)
}
return newNum.reduce((a,b) => a+b)
}
sumPrimes(10);
答案 25 :(得分：0)
这是使用JS生成器的高效，简短的解决方案。 JSfiddle
// 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) < 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 && fn(nx.value)) yield nx.value
}
document.querySelectorAll('dd')[0].textContent =
// Primes smaller than 100
[...take(primes(), x => x < 100)].join(', ')<dl>
<dt>Primes under 100</dt>
<dd></dd>
</dl>
答案 26 :(得分：0)
您可以将此用于任何大小的素数数组。希望这有帮助
function prime() {
var num = 2;
var body = document.getElementById("solution");
var len = arguments.length;
var flag = true;
for (j = 0; j < len; j++) {
for (i = num; i < arguments[j]; i++) {
if (arguments[j] % i == 0) {
body.innerHTML += arguments[j] + " False <br />";
flag = false;
break;
} else {
flag = true;
}
}
if (flag) {
body.innerHTML += arguments[j] + " True <br />";
}
}
}
var data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
prime.apply(null, data);<div id="solution">
</div>
答案 27 :(得分：0)
以下是查找素数n的Brute-force iterative方法和Sieve of Eratosthenes方法。在时间复杂度方面，第二种方法的性能优于第一种方法
强力迭代
function findPrime(n) {
var res = [2],
isNotPrime;
for (var i = 3; i < n; i++) {
isNotPrime = res.some(checkDivisorExist);
if ( !isNotPrime ) {
res.push(i);
}
}
function checkDivisorExist (j) {
return i % j === 0;
}
return res;
}
Eratosthenes方法筛选
function seiveOfErasthones (n) {
var listOfNum =range(n),
i = 2;
// CHeck only until the square of the prime is less than number
while (i*i < n && i < n) {
listOfNum = filterMultiples(listOfNum, i);
i++;
}
return listOfNum;
function range (num) {
var res = [];
for (var i = 2; i <= num; i++) {
res.push(i);
}
return res;
}
function filterMultiples (list, x) {
return list.filter(function (item) {
// Include numbers smaller than x as they are already prime
return (item <= x) || (item > x && item % x !== 0);
});
}
}
答案 28 :(得分：0)
这是我使用Sieve of Eratosthenes方法的解决方案：
function gimmePrimes(num) {
numArray = [];
// first generate array of numbers [2,3,...num]
for (i = 2; i <= num; ++i) {
numArray.push(i);
}
for (i = 0; i < numArray.length; ++i) {
//this for loop helps to go through each element of array
for (j = numArray[i]; j < numArray[numArray.length - 1]; ++j) {
//get'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);
答案 29 :(得分：0)
我创建了一个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);
})();
};
答案 30 :(得分：0)
这是我的solution
//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));
答案 31 :(得分：0)
这样的事情怎么样。
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>');
}
答案 32 :(得分：0)
我修改了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
}
}
答案 33 :(得分：0)
这是一种测试数字是素数的方法。
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;
}
答案 34 :(得分：0)
使用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;
}
答案 35 :(得分：0)
使用以下函数查找素数：
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
}
答案 36 :(得分：0)
如果你要使用你将要在这个帖子中提供的任何数以千计的算法，那么你应该学会记住其中的一些算法。
请参阅Interview question : What is the fastest way to generate prime number recursively?
答案 37 :(得分：0)
首先，将内部代码更改为另一个循环（for和while），以便为不同的值重复相同的代码。
更具体地针对您的问题，如果您想知道给定的n是否为素数，则需要将其除以2和sqrt（n）之间的所有值。如果任何模块为0，则它不是素数。
如果你想找到所有的素数，你可以加速它并仅通过除以先前找到的素数来检查n。加速这一过程的另一种方法是，除了2和3之外，所有素数都是6*k加上或少于1。
答案 38 :(得分：-1)
有没有人试过这个？它简单而有效......
function Prime(num) {
if (num <= 2)return false;
for(var i = 2; i < num; i++){
if (num % i == 0) return false;
}
return true;
}
function PrimeWithin(userinput){
for(var i = 2; i < userinput; i++){
if(Prime(i)){
console.log(i);
}
}
}
PrimeWithin(500);
答案 39 :(得分：-1)
<html>
<head>
<script type="text/javascript">
function primeNumber() {
x=document.getElementById('txt_field').value;
for (i=1; i<=parseInt(x); i++) {
var flag=0,flag1=0;
for (j=2; j<i; j++) {
if(i%j==0){
flag=1;
if(i==x)
flag1=1;
}
}
if(flag==0)
document.write(i+'<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>