素数JavaScript


Prime Numbers JavaScript

有人可以给我指导以获取此处的质数吗？ 这是家庭作业，所以我不希望得到答案，但是一些提示将不胜感激。 这真让我很烦:(

我想我接近了。 但是我遇到的问题是数字25和35。这些不是素数，但是此函数正在返回它们

1
2
3
4
5
6
7
8
9
10
11
12
var getPrimeNumber = function(n) {
    if(n === 1) return"";
    else if(n == 2) return 2;
    else if(n == 3) return 3;
    else {
        for(i=Math.floor(Math.sqrt(n)); i>=2; i--){
            //console.log(i);//maybe another var in here?
            if(n%i !==0 && n%2 !==0 && n%3 !== 0)
                return n; // 25/Math.sqrt(25) will be equal to zero this is what gives me 25 !!!  
        }
    }
};
相关讨论

基于此页面，这将是一种确定数字是否为质数的方法：

1
2
3
4
5
6
7
8
function isPrime(number) {
    let start = 2;
    const limit = Math.sqrt(number);
    while (start <= limit) {
        if (number % start++ < 1) return false;
    }
    return number > 1;
}

在node.js中，大约需要250Ms才能确定2到100.000之间的素数。

也可以看看 ...

相关讨论

这是根据先前的素数来计算JavaScript中素数的最快方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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;
}

测试

1
2
3
4
5
6
var value, result = [];
for (var i = 0; i < 10; i++) {
    value = nextPrime(value);
    result.push(value);
}
console.log("Primes:", result);

输出量

1
Primes: [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]

这是非常快的，因为：

  • 它将循环限制对齐为整数；
  • 它使用较短的迭代循环，跳过偶数。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
    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>"
        );
    }

相关讨论

有一个函数，如果数字是素数，则返回true，否则返回false：

1
2
3
4
5
6
7
8
function isPrime(x){    
      d = x-1;
      while (d > 1){
        if ((x % d) == 0) return false;
        d--;
      }
      return true;
    }

查看演示：http://jsbin.com/velapabedi/1/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  JS Bin
 
 
    function isPrime(x){    
      d = x-1;
      while (d > 1){
        if ((x % d) == 0) return false;
        d--;
      }
      return true;      
     
    }
   
   
    if (isPrime(41)){
      alert('Prime');
    }
    else{
      alert('Not Prime');
    }
 
</head>
<body>

</body>
</html>

相关讨论

我在实现过程中考虑了以下几点：质数是"自然数"，负值有可能是质数。这是使用输入卫生的更确定的解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function isPrime(num) {
    //check if value is a natural numbers (integer)
    //without this check, it returns true
    if (isNaN(num) || num % 1 !== 0) {
        return false;
    }
    num = Math.abs(num); //*negative values can be primes
    if (num === 0 || num === 1) {
        return false;
    }
    var maxFactorNum = Math.sqrt(num);
    for (var i = 2; i <= maxFactorNum; i++) {
        if (num % i === 0) {
            return false;
        }
    }
    return true;
}

//this method in action
for (var i = 1; i <= 40; i++) {
    console.log(i + (isPrime(i) ?", isPrime" :""));
}
//checking anomalies
console.log(isPrime(1.22));
console.log(isPrime(1.44));
console.log(isPrime("string"));

我希望我的答案能被证明是使用了最佳实践的更具可读性的代码。例如，某些答案将平方根计算留在循环中，导致该方法在每个循环上运行该计算。

这是一个简单的质数"筛选器"，很容易理解，尽管它是一种幼稚的方法(与诸如AKS测试之类的复杂有效的质数测试相对)，但它却非常快(10000个数字在<1秒)。它将找到的质数存储在数组prim[]中，并使用模函数(%)进行测试：

循环将针对已找到的质数进行测试，如果不是质数，即模结果为0(关于表达式i % prim[j])===0)，则退出。否则，它将其添加到找到的质数列表中。

请注意，因为唯一的偶质数是2，所以循环步长是2，而不是1，因为从3开始没有其他偶数质数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
var MaxNum = 10000;
var prim;

function Main() {
  MaxNum = GetMaxNum();
  prim = CalculatePrimes(MaxNum);
  CheckSome();
}

function CalculatePrimes(pMaxNum) {
  Console.WriteLine("Calculating until" + pMaxNum +"...");
  var _prim = [2];
  if (pMaxNum > 2) {
    for (var i = 3; i < pMaxNum; i += 2) {
      var is_prim = true;
      if (_prim.length > 0) {
        for (var j = 0; j < _prim.length; j++) {
          if ((i % _prim[j]) === 0) {
            is_prim = false;
            break;
          }
        }
      }
      if (is_prim) {
        _prim.push(i);
      }
    }
  }
  Console.WriteLine("Prime numbers:");
  for (var i = 0; i < _prim.length; i++) {
    Console.Write(_prim[i] +"");
  }
  Console.WriteLine();
  Console.WriteLine("Found" + _prim.length +" prime numbers.");
  Console.WriteLine();
  return _prim;
}

// test some individual pre-calculated numbers

function CheckSome() {
  var num1 = prim[prim.length - 1];
  var num2 = num1 - 1;
  Console.WriteLine("Test:" + num1.toString() +". Is it a prime number?" + Is_prime(num1));
  Console.WriteLine("Test:" + num2.toString() +". Is it a prime number?" + Is_prime(num2));
}

function Is_prime(n) {
  if (n > MaxNum) throw"ERROR: n must be <" + MaxNum +"!";
  if (prim.indexOf(n) === -1)
    return false;
  else
    return true;
};


// ------------ HELPERS to display on screen ------------
var Console = {
  Section: 1,
  SectionId:"#section1",
  NewSection: function() {
    var $currentSection = $(this.SectionId);
    this.Section++;
    this.SectionId ="#section" + this.Section.toString();
    $currentSection.before('');
  },
  Write: function(str) {
    $(this.SectionId).append(str);
  },
  WriteLine: function(str) {
    if (str !== undefined && str !== null && str !=="") this.Write(str);
    this.Write("<br/>");
  }
};


var GetMaxNum = function() {
  var result = $("#MaxNumSelect option:selected").val();
  return result;
}

$(document).ready(function() {
  $("#MaxNumSelect").change(function() {
    MaxNum = GetMaxNum();
    Console.NewSection();
    Main();
    Console.WriteLine("---------------------------------");
  });
  Main();
});
1
2
3
4
5
6
7
8
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js">
Select max number:
  <select id="MaxNumSelect">
    <option value="10000" default="default">10000</option>
    <option value="100">100</option>
    <option value="1000">1000</option>
    <option value="100000">100000</option>
  </select>

在上面的示例中，我们测试了前10000个自然数。要确定给定数字是否为质数，只需检查它是否包含在数组prim中：

1
2
3
4
5
6
7
function Is_prime(n) {
    if (n>MaxNum) throw"ERROR: n must be <"+CalcToNum+"!";
    if (prim.indexOf(n)===-1)
      return false;
    else
      return true;
};

当然，为了使它起作用，需要预先计算素数。

示例：alert(Is_prime(25));-返回false，因为25不是素数。

注意：必须检查数字范围，因为功能Is_prime只能确定先前由上述筛子测试过的数字。如果数组太小而无法检查数字(即如果预计算的素数不足)，则会引发错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function isPrime(number) {

  // Immediate exit cases
  switch(true){
    case (number < 2):
      return console.log("Please enter a number greater than or equal to 2.")
    case (number === 2 || number === 3):
      return console.log(number +" is a prime number!")
  }

  // Process number if it does not meet above requirements
  var num = Math.floor(Math.sqrt(number))

  for(var i = 2; i <= num; i++) {
    if(number % i === 0)
      return console.log(number +" is not a prime number")
    else
      return console.log(number +" is a prime number!")
  }
}

isPrime(27) // 27 is a prime number!
isPrime(30) // 30 is not a prime number
isPrime(55) // 55 is a prime number!
isPrime(2)  // 2 is a prime number!

在您的if语句中，您得到了

1
if(n%i !==0 && n%2 !==0 && n%3 !== 0)

您的循环将一直持续到i> = 2，所以n％2！== 0是无用的，当i = 2时，if看起来像：

1
if(n%2 !==0 && n%2 !==0 && n%3 !== 0)

多数民众赞成在2倍相同的检查，相同的是n％3，它已经检查过:)。

您应该保留布尔值来检查n％i！== 0，如果它从未达到极限，则为素数。

祝您功课顺利：)。

您应该返回一个bool值，新函数可以是：

1
2
3
4
5
6
7
8
9
10
11
12
function(n) {
    if(n === 1) { return false;}
    else if(n == 2) { return true;}
    else if(n == 3) { return true;}
    else {
        for(i=Math.floor(Math.sqrt(n));i>=2;i--){
            //console.log(i);//maybe another var in here?
                if(n%i ==0 || n%2 ==0 || n%3 == 0) {return false;}
        }
        }
    return true;
};

在OP中，控件if(n%i !==0 && n%2 !==0 && n%3 !== 0) {return n;}存在问题，因为即使只有单个i满足此条件，该函数也会将数字返回为素数。

相关讨论

这是我的答案！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var isPrime = function (n) {
  if (n<2) {
    return false
  }else if (n = 2) {
    return true
  }
  for (var i = 2; i < n; i++) {
    if (n%i === 0) {
      return false
    }else if (i === n-1) {
      return true
    }
  }
}
console.log(isPrime(7));

您是否想知道如何确定数字是质数还是复合数。此代码使您轻松理解。输入数字2。

1
2
3
4
5
6
7
8
9
var p = prompt("Insert a number for check","");
var x =" is a prime number";
for(i=2; i<p; i++){
    if(p%i === 0){
        x =" is a composite number";
        break;
    }
}
alert(p+x);
相关讨论