我正在尝试完成代码检查挑战，要求您检查数字是否为素数。无论出于何种原因，我的解决方案似乎不适用于奇素数的平方（例如9返回true而不是false）。
function isPrime(num) {
if (num === 2) {
return true;
}
else if(num > 1){
for (var i = 2; i < num; i++) {
if (num % i !== 0 ) {
return true;
}
else if (num === i * i) {
return false
}
else {
return false;
}
}
}
else {
return false;
}
}
console.log(isPrime(121));
P.S。我包括了第二个else / if语句，因为我试图解决问题。
答案 0 :(得分：74)
尽可能简单：
function isPrime(num) {
for(var i = 2; i < num; i++)
if(num % i === 0) return false;
return num > 1;
}
使用ES6语法：
const isPrime = num => {
for(let i = 2; i < num; i++)
if(num % i === 0) return false;
return num > 1;
}
如果您运行循环直到数字的平方根，您还可以将算法的复杂性从O(n)降低到O(sqrt(n))：
const isPrime = num => {
for(let i = 2, s = Math.sqrt(num); i <= s; i++)
if(num % i === 0) return false;
return num > 1;
}
答案 1 :(得分：21)
这里有一个小建议，你为什么要为整个n个数字运行循环？
如果一个数字是素数，它将有2个因子（1和数字本身）。 如果它不是素数，它们将有1，数字本身等等，你不需要运行循环直到数字，可能你可以考虑运行它直到数字的平方根。
你可以通过欧拉的主逻辑来做到这一点。 请查看以下代码段：
function isPrime(num) {
var sqrtnum=Math.floor(Math.sqrt(num));
var prime = num != 1;
for(var i=2; i<sqrtnum+1; i++) { // sqrtnum+1
if(num % i == 0) {
prime = false;
break;
}
}
return prime;
}
现在复杂性为O（sqrt（n））
了解更多信息 Why do we check up to the square root of a prime number to determine if it is prime?
希望有所帮助
答案 2 :(得分：8)
酷版：
const isPrime = n => ![...Array(n).keys()].slice(2).map(i => !(n%i)).includes(true) && ![0,1].includes(n)
答案 3 :(得分：4)
function isPrime(num) {
if (num <= 1) return false; // negatives
if (num % 2 == 0 && num > 2) return false; // even numbers
let s = Math.sqrt(num); // store the square to loop faster
for(let i = 3; i < s; i++) { // start from 3, stop at the square, increment
if(num % i === 0) return false; // modulo shows a divisor was found
}
return num !== 1; // if its not 1 its prime
}
答案 4 :(得分：4)
// A list prime numbers
function* Prime(number) {
const infinit = !number && number !== 0;
const re = /^.?$|^(..+?)\1+$/;
let actual = 1;
while (infinit || number-- ) {
if(!re.test('1'.repeat(actual)) == true) yield actual;
actual++
};
};
let [...primers] = Prime(101); //Example
console.log(primers);
答案 5 :(得分：3)
素数的形式为6f±1，不包括2和3，其中f是任何整数
function isPrime(number)
{
if (number <= 1)
return false;
// The check for the number 2 and 3
if (number <= 3)
return true;
if (number%2 == 0 || number%3 == 0)
return false;
for (var i=5; i*i<=number; i=i+6)
{
if (number%i == 0 || number%(i+2) == 0)
return false;
}
return true;
}
解决方案的时间复杂度：O（sqrt（n））
答案 6 :(得分：3)
function isPrime(num) {
var prime = num != 1;
for(var i=2; i<num; i++) {
if(num % i == 0) {
prime = false;
break;
}
}
return prime;
}
<强> DEMO
答案 7 :(得分：3)
function isPrimeNumber(n) {
for (var i = 2; i < n; i++) { // i will always be less than the parameter so the condition below will never allow parameter to be divisible by itself ex. (7 % 7 = 0) which would return true
if(n % i === 0) return false; // when parameter is divisible by i, it's not a prime number so return false
}
return n > 1; // otherwise it's a prime number so return true (it also must be greater than 1, reason for the n > 1 instead of true)
}
console.log(isPrimeNumber(1)); // returns false
console.log(isPrimeNumber(2)); // returns true
console.log(isPrimeNumber(9)); // returns false
console.log(isPrimeNumber(11)); // returns true
答案 8 :(得分：2)
我认为这个问题缺少递归解决方案：
// Preliminary screen to save our beloved CPUs from unneccessary labour
const isPrime = n => {
if (n === 2 || n === 3) return true;
if (n < 2 || n % 2 === 0) return false;
return isPrimeRecursive(n);
}
// The recursive function itself, tail-call optimized.
// Iterate only over odd divisors (there's no point to iterate over even ones).
const isPrimeRecursive = (n, i = 3, limit = Math.floor(Math.sqrt(n))) => {
if (n % i === 0) return false;
if (i >= limit) return true; // Heureka, we have a prime here!
return isPrimeRecursive(n, i += 2, limit);
}
// Usage example
for (i = 0; i <= 50; i++) {
console.log(`${i} is ${isPrime(i) ? `a` : `not a` } prime`);
}
这种方法有缺点-由于浏览器引擎（编写于11/2018）仍未进行TC优化，如果按的顺序测试素数，则可能会出现字面的堆栈溢出错误。数几亿甚至更高（可能会有所不同，具体取决于实际的浏览器和可用内存）。
答案 9 :(得分：2)
我会这样：
const isPrime = (num) => num < 10 ? [2, 3, 5, 7].includes(num) : ![2, 3, 5, 7].some(i => !(num % i));
答案 10 :(得分：1)
这是一个优化的解决方案，以防止循环遍历所有范围编号。
function isPrime(num) {
for (let i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0)
return false;
}
return true;
}
答案 11 :(得分：1)
我认为找到素数的更好方法是使用这个逻辑：
var p=prompt("input numeric value","10"); // input your number
for(j=2;j<p;j++){
if(isPrimes(j)){
document.write(j+", "); // for output the value
} // end if
}// end for loop
function isPrimes(n) {
var primes = true;// let prime is true
for (i=2;i<n;i++) {
if(n%i==0) {
primes= false; // return prime is false
break; // break the loop
}// end if inner
}// end inner loop
return primes; // return the prime true or false
}// end the function
答案 12 :(得分：1)
您可以在javascript中使用以下代码来检查数字是否为素数。 它将减少迭代次数并快速得到结果。
function testPrime(num) {
var isPrime = true;
if (num >= 2) {
if(num == 2 || num == 3){
isPrime = true;
}
else if (num % 2 == 0) {
isPrime = false;
}
else {
for (i = 3; i <= Math.floor(Math.sqrt(num)); i += 2) {
if (num % i == 0) {
isPrime = false;
break;
}
}
}
}
else {
isPrime = false;
}
return isPrime;
}
// testPrime（21） 假
答案 13 :(得分：1)
您可以尝试这个
function isPrime(num){
// Less than or equal to 1 are not prime
if (num<=1) return false;
// 2 and 3 are prime, so no calculations
if (num==2 || num==3 ) return true;
// If mod with square root is zero then its not prime
if (num % Math.sqrt(num)==0 ) return false;
// Run loop till square root
for(let i = 2, sqrt = Math.sqrt(num); i <= sqrt; i++) {
// If mod is zero then its not prime
if(num % i === 0) return false;
}
// Otherwise the number is prime
return true;
}
for(let i=-2; i <= 35; i++) {
console.log(`${i} is${isPrime(i) ? '' : ' not'} prime`);
}
答案 14 :(得分：1)
最短的版本之一
isPrime=(n)=>[...Array(n-2)].map((_,i)=>i+2).filter(i=>n%i==0).length==0
答案 15 :(得分：0)
{{1}}
答案 16 :(得分：0)
我们只用一个循环就可以找到最多 n 的素数，而且我将循环增加了 +2：
function primeNumber(n) {
let arr = [];
if (n <= 1) return false;
if (n === 2) return true;
let flag = true;
for (let i = 3; i < n; i += 2) {
if (n % i == 0) {
flag = false;
break;
}
}
return flag;
}
// It will retrun bollean true/false
// primeNumber(11) true
// primeNumber(12) false
最好的部分是复杂度是 o(n/2)
答案 17 :(得分：0)
比常规方法快三倍：
function isPrime (num){
if (num === 1){
return false;
}
if(num === 2 || num === 3){
return true;
}
if((num % 2 !== 0) && (num % 3 !== 0)){
let k = 1;
const numSqrt = Math.sqrt(num);
if(( 6 * k - 1 ) > numSqrt){
return true;
} else {
while( ( 6 * k - 1 ) <= numSqrt ){
if(num % (6 * k - 1) !== 0 && num % (6 * k + 1) !== 0){
return true;
}
k++;
}
return false;
}
}
return false;
}
console.log(isPrime(29))
答案 18 :(得分：0)
function isPrime(num) {
return Array.from({ length: num }, (i, index) => index + 1).filter(
(item, i) => (num % item) === 0).length === 2;
}
console.log(isPrime(1)); // false
console.log(isPrime(2)); // true
console.log(isPrime(3)); // true
console.log(isPrime(4)); // false
答案 19 :(得分：0)
如果要查找n个质数，这是一种更可靠的解决方案。
function findPrime(n) {
const primes = [];
loop1:
for (let j = 0; primes.length < n; j++) {
loop2:
for(let i = 2; i < j; i++){
if(j % i === 0){
continue loop1;
}
}
if(j>1) primes.push(j);
}
console.log(primes);
}
findPrime(5);
答案 20 :(得分：0)
这将以不同的方式计算平方并跳过偶数。
const isPrime = (n) => {
if (n <= 1) return false;
if (n === 2) return true;
if (n % 2 === 0) return false;
//goto square root of number
for (let i = 3, s = n ** 0.5; i < s; i += 2) {
if (n % i == 0) return false;
}
return true;
};
答案 21 :(得分：0)
对某些人可能有用：Miller Rabin素数测试的实现。适用于所有小于Number.MAX_SAFE_INTEGER的正整数。
尝试使用JSFiddle：https://jsfiddle.net/4rxhas2o/
let unsafeToSquare = Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER))
function addMod(a, b, m) {
// Returns (a + b) % m
let sum = a + b
let result = sum % m
if (sum < Number.MAX_SAFE_INTEGER)
return result
let signature = ((a % 8) + (b % 8)) % 8
let sumMod = sum % 8
for (let i = -2; i <= 2; ++i) {
if ((sumMod + i) % 8 === signature) {
let ret = result + i
if (ret > m)
ret = (result - m) + i // prevent overflow
return ret
}
}
}
function mulMod(a, b, m) {
if (m === 0)
return 0
let prod = a * b
if (prod < Number.MAX_SAFE_INTEGER)
return prod % m
let y = 0
let result = a
while (b > 1) {
if (b % 2 === 0) {
result = addMod(result, result, m)
b /= 2
} else {
y = addMod(result, y, m)
result = addMod(result, result, m)
b = (b - 1) / 2
}
}
return addMod(result, y, m)
}
function squareMod(b, m) {
// Computes (b * b % m)
return mulMod(b, b, m)
}
function expModLargeB(b, exponent, m) {
let y = 1
while (exponent > 1) {
if (exponent % 2 === 0) {
b = squareMod(b, m)
exponent /= 2
} else {
y = mulMod(y, b, m)
b = squareMod(b, m)
exponent = (exponent - 1) / 2
}
}
return mulMod(b, y, m)
}
function expMod(b, exponent, m) {
if (exponent === 0)
return 1
if (b >= unsafeToSquare || m >= unsafeToSquare) {
return expModLargeB(b, exponent, m)
}
let y = 1
while (exponent > 1) {
if (exponent % 2 === 0) {
b *= b
b %= m
exponent /= 2
} else {
y *= b
b *= b
y %= m
b %= m
exponent = (exponent - 1) / 2
}
}
return (b * y) % m
}
function _isPrimeTrialDivision(p) {
let sqrtP = Math.ceil(Math.sqrt(p))
for (let i = 23; i <= sqrtP + 1; i += 2) {
if (p % i === 0)
return false
}
return true
}
function _isProbablePrimeMillerRabin(p, base=2) {
let pm1 = p - 1
let pm1div = pm1
let d, r = 0
while (true) {
if (pm1div % 2 === 0) {
pm1div /= 2
r++
} else {
d = pm1div
break
}
}
let x = expMod(base, d, p)
if (x === 1 || x === pm1)
return true
for (let i = 0; i < r - 1; ++i) {
x = squareMod(x, p)
if (x === pm1)
return true
}
return false
}
function _isPrimeLarge(p) {
let bases
if (p < 2047)
bases = [2]
else if (p < 1373653)
bases = [2, 3]
else if (p < 9080191)
bases = [31, 73]
else if (p < 25326001)
bases = [2, 3, 5]
else if (p < 3215031751)
bases = [2, 3, 5, 7]
else if (p < 4759123141)
bases = [2, 7, 61]
else if (p < 1122004669633)
bases = [2, 13, 23, 1662803]
else if (p < 2152302898747)
bases = [2, 3, 5, 7, 11]
else if (p < 3474749660383)
bases = [2, 3, 5, 7, 11, 13]
else if (p < 341550071728321)
bases = [2, 3, 5, 7, 11, 13, 17]
else
bases = [2, 3, 5, 7, 11, 13, 17, 19, 23]
return bases.every(base => _isProbablePrimeMillerRabin(p, base))
}
let smallPrimes = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223]
function isPrime(p) {
if (!Number.isInteger(p) || p < 2)
return false
// Test for small primes
for (let i = 0; i < smallPrimes.length; ++i) {
let prime = smallPrimes[i]
if (p === prime)
return true
if (p % prime === 0)
return false
}
if (p < 150) {
return _isPrimeTrialDivision(p)
} else {
return _isPrimeLarge(p)
}
}
const tests = [1, 2, 3, 10, 100, 100019, 10000000019, 100000000003, 10000000000037]
let start = performance.now()
tests.forEach(test => {
console.log(`${test} is ${ isPrime(test) ? "" : "not " }prime`)
})
let end = performance.now()
console.log("Tests completed in " + (end - start) + " ms.")
答案 22 :(得分：0)
您正在尝试检查太多条件。只需要一个循环来检查素数
function isPrime(num){
if(num==2)
return true;
for(i=2;i<Math.sqrt(num);i++) // mathematical property-no number has both of its factors greater than the square root
{
if(num % i==0)
return false; // otherwise it's a prime no.
}
return true;
}
你必须考虑每一个没有。一个素数没有。除非它可以被某些人整除。小于或等于平方根。
你的解决方案已经针对每个案例都有一个return语句，因此它应该在它应该之前停止执行。它不会多次检查任何数字。它给出了多个案例的错误答案 - 15,35 .. in每个没有的事实。这很奇怪。
答案 23 :(得分：0)
我的解决方案，
function isPrimeNumber(number){
if(number <= 1) return false;
if(number <= 3) return true;
for(let i = 2; i < 9; i++) {
if(number === i) continue;
if(number % i === 0 ) return false;
}
return true;
}
for(let i = 0; i <= 100; i++){
if (isPrimeNumber(i)) console.log(i);
}
答案 24 :(得分：0)
为什么要尝试使用循环！？在这里进行迭代是如此浪费计算能力...
这可以通过数学来完成：
function isPrime(num) {
if ( num !=1 && num%3 != 0 && num%5 != 0 && num%7 != 0 && num%9 != 0 && num%11 != 0 && Math.sign(num) == 1 && Math.round(num) == num) {
if ( (num-1)%6 == 0 || (num+1)%6 == 0 ) {
return true;
}
} // no need for else statement since if true, then will do return
return num==11||x==9||num==5||num==3||num==2; // will return T/F;
}
始终尝试以数学方式进行操作，而不是遍历循环。数学几乎总是最有效的方法。 是的，这个方程可能令人困惑...但是，在检查某些东西是否是质数时，我们不需要太多的可读性...以后的代码编辑器可能不需要维护它。 / p>
编辑：
优化的代码版本：
function isPrime(x=0) {
const m = Math;
return (x%3!=0&&x%5!=0&&x%7!=0&&x%9!=0&&x%11!=0&&x!=1&&m.sign(x)*m.round(x)==x&&(!!!((x-1)%6)||!!!((x+1)%6)))||x==11||x==9||x==7||x==5||x==3||x==2;
}
编辑：
事实证明……与假阳性检测还有更多关系，因为它们是随机分布的（至少在表面上看起来如此），所以+ -1％6的东西实际上并不能在所有情况下起作用……但是我肯定在这里……
答案 25 :(得分：0)
简单版本：
function isPrime(num) {
if (num <= 1) {
return false;
} else {
for (var i = 2; i < num; i++) {
if (num % i === 0) {
return false;
}
}
return true;
}
}
console.log(isPrime(9));
答案 26 :(得分：0)
此答案基于Ihor Sakaylyuk的答案。但是，我没有检查所有数字，而是只检查了奇数。这样做可以将解决方案的时间复杂度降低为O（sqrt（n）/ 2）。
function isPrime(num) {
if (num > 2 && num % 2 === 0) return false;
for (var i = 3; i < Math.sqrt(num); i += 2) {
if (num % i === 0) return false;
}
return num > 1;
}
答案 27 :(得分：0)
看起来你是第一个if语句，如果＆＃39; if＆＃39; for循环中的语句。因为如果num = 9且i = 2,9％i！== 0但是9不是素数，因为在下一次迭代中i = 3,9％i === 0。
这是我对这个问题的回答。
var isPrime = function(n) {
if(typeof n !== 'number' || n <= 1 || n % 1 !== 0){
return false;
}
for(var i = 2; i <= Math.sqrt(n); i += 1){
if(n % i === 0){
return false;
}
}
return true;
};
第一个if语句捕获边缘情况。 for循环然后检查从2到n的平方根，因为数学属性没有数字的两个因子都大于该数字的平方根。
希望这有帮助！
答案 28 :(得分：0)
使用Ticked解决方案Ihor Sakaylyuk
const isPrime = num => {
for(let i = 2, s = Math.sqrt(num); i <= s; i++)
if(num % i === 0) return false;
return num !== 1 && num !== 0;
}
在控制台中提供
isPrime（-100） 是
const isPrime = num => {
// if not is_number num return false
if (num < 2) return false
for(let i = 2, s = Math.sqrt(num); i <= s; i++) {
if(num % i === 0) return false
}
return true
}
在控制台中提供
isPrime（1） 错误
isPrime（100） 错误
isPrime（-100） 错误
前6个素数？ 2 3 5 7 11 13吗？
isPrime（1） 错误
isPrime（2） true //素数1
isPrime（3） true //素数2
isPrime（4） 错误
isPrime（5） true //素数3
isPrime（6） 错误
isPrime（7） true //素数4
isPrime（8） 错误
isPrime（9） 错误
isPrime（10） 错误
isPrime（11） true //素数5
isPrime（12） 错误
isPrime（13） true //素数6
答案 29 :(得分：0)
我觉得检查素数会更有效：
function prime(num){
if(num == 1) return true;
var t = num / 2;
var k = 2;
while(k <= t) {
if(num % k == 0) {
return false
} else {
k++;
}
}
return true;
}
console.log(prime(37))
答案 30 :(得分：0)
function isPrime(num) {
if(num < 2) return false;
for (var i = 2; i <= num/2; i++) {
if(num%i==0)
return false;
}
return true;
}
如果我们想要两个数字之间的质数，我们只需添加此代码
for(var i = 0; i < 100; i++){
if(isPrime(i))
console.log(i);
}
答案 31 :(得分：0)
function isAPrimeNumber(num){
var counter = 0;
//loop will go k equals to $num
for (k = 1; k <= num; k++) {
//check if the num is divisible by itself and 1
// `%` modulus gives the reminder of the value, so if it gives the reminder `0` then it is divisible by the value
if (num % k == 0) {
//increment counter value 1
counter = counter + 1;
}
}
//if the value of the `counter is 2` then it is a `prime number`
//A prime number is exactly divisible by 2 times only (itself and 1)
if (counter == 2) {
return num + ' is a Prime Number';
}else{
return num + ' is nota Prime Number';
}
}
现在通过传递值来调用isAPrimeNumber()函数。
var resp = isAPrimeNumber(5);
console.log(resp);
输出：
5 is a Prime Number
答案 32 :(得分：0)
(function(value){
var primeArray = [];
for(var i = 2; i <= value; i++){
if((i === 2) || (i === 3) || (i === 5) || (i === 7)){
primeArray.push(i);
}
else if((i % 2 !== 0) && (i % 3 !== 0) && (i % 5 !== 0) && (i % 7 !== 0)){
primeArray.push(i);
}
}
console.log(primeArray);
}(100));
答案 33 :(得分：0)
非常简单
const isPrime = num => {
for (var i = 2; i < num; i++) if (num % i == 0) return false;
return num >= 2;
}
答案 34 :(得分：0)
我就是这样做的：
function isPrime(num) {
if(num < 2) return false;
if(num == 2) return true;
for(var i = 2; i < num; i++) {
if(num % i === 0) return false;
}
return true;
}
答案 35 :(得分：-1)
唯一的偶数是2，所以我们应该从循环中排除偶数。
function isPrime(a) {
if (a < 2) return false;
if (a > 2) {
if (a % 2 == 0) return false;
for (let x = 3; x <= Math.sqrt(a); x += 2) {
if (a % x == 0) return false;
}
}
return true;
}
答案 36 :(得分：-1)
@IhorSakaylyuk的答案可以通过跳过除2以外的所有偶数来进一步提高到Get-ChildItem -Path C:\DIRECTORY\* -Depth 2
：
O(sqrt(n/2))您还可以使用npm软件包pial。
答案 37 :(得分：-1)
我认为最简单，更快捷的方法是
function isPrime(num) {
for(var i = 2; i < Math.sqrt(num); i++) {
if(num % i === 0){
return false;
}
return num > 1;
}
}
console.log(isPrime(9))
答案 38 :(得分：-1)
以下代码使用最有效的循环方式来检查给定数字是否为素数。
function checkPrime(number){
if (number==2 || number==3) {
return true
}
if(number<2 ||number % 2===0){
return false
}
else{
for (let index = 3; index <= Math.sqrt(number); index=index+2) {
if (number%index===0) {
return false
}
}
}
return true
}
答案 39 :(得分：-1)
这将涵盖素数的所有可能性。 （最后3个if语句的顺序很重要）
function isPrime(num){
if (num==0 || num==1) return false;
if (num==2 || num==3 ) return true;
if (num % Math.sqrt(num)==0 ) return false;
for (let i=2;i< Math.floor(Math.sqrt(num));i++) if ( num % i==0 ) return false;
if ((num * num - 1) % 24 == 0) return true;
}