0から100までの素数を見つけるには？
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());
JavaScriptのSieve実装の例を次に示します。
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実装は非常によく似ています。
解決方法は次のとおりです。 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）]を確認するだけで十分です。
このスクリプトのライブデモは次のとおりです。 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);
}
言語が何であれ、ある範囲内の素数を見つける最良かつ最もアクセスしやすい方法の1つは、 sieve を使用することです。
コードを提供するつもりはありませんが、これは良い出発点です。
あなたのような小さな範囲では、最も効率的なのは数値を事前に計算することです。
Sieve of Sundaram アルゴリズムをわずかに変更して、不要な反復を削減しましたが、非常に高速であるようです。
このアルゴリズムは実際、このトピックで最も受け入れられている @ Ted Hoppのソリューション よりも2倍高速です。 0〜1Mの間で78498素数を解くには、Chrome 55で20〜25ミリ秒、FF 50.1で<90ミリ秒の時間がかかります。また、 @ vitaly-tは次のプライムアルゴリズムを取得します は興味深いように見えますが、結果はずっと遅くなります。
これがコアアルゴリズムです。セグメンテーションとスレッディングを適用して、素晴らしい結果を得ることができます。
"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);ループ制限の説明：
Sieve of Erasthotenesと同じように、Sieve of Sundaramアルゴリズムもリストから選択された整数を消します。ルールを打ち消す整数を選択するには、i + j + 2ij≤nです。ここで、iとjは2つのインデックスで、nは合計要素の数です。すべてのi + j + 2ijを消すと、残りの数は2倍になり、奇数（2n + 1）になり、素数のリストが表示されます。最終段階は、実際には偶数の自動割引です。その証拠は美しく説明されています ここ 。
Sanda of 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つだけです。 22、31、37、40、49。冗長性は、n = 100では約20％ですが、n = 10Mでは約300％に増加します。つまり、SoSをさらに最適化すると、nが大きくなるにつれてさらに高速に結果を取得できる可能性があります。したがって、1つのアイデアはセグメンテーションであり、常にnを小さくすることです。
わかりました。このクエストをもう少し進めることにしました。
繰り返し交差を注意深く調べた後、i === 1の場合を除いて、iまたはjのいずれかまたは両方のインデックス値が4,7,10,13,16,19 ...シリーズの1つである場合、重複交差が生成されます。その後、i%3-1 !== 0の場合にのみ内側のループを回すことができ、ループの総数から35〜40％のようにさらに削減されます。そのため、たとえば1M整数の場合、ネストされたループの合計ターン数は1.4Mから1Mのように低下しました。ワオ..！ここでほとんどO(n)と話している。
私はちょうどテストをしました。 JSでは、1Bまでカウントする空のループだけで4000ms程度かかります。以下の修正されたアルゴリズムでは、100Mまでの素数を見つけるのに同じ時間がかかります。
また、このアルゴリズムのセグメンテーション部分を実装して、ワーカーにプッシュします。そのため、複数のスレッドを使用することもできます。しかし、そのコードは少し後に続きます。
それでは、おそらくセグメント化されていないときに最適なSundaramの変更されたSieveを紹介しましょう。 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);さて...最後に、私は（スンダラムの独創的なふるいから生まれた）ふるいを実装し、「エラトステネスのオッズのみ」や、 「アトキンスのふるい」。また、これはWebワーカー向けのマルチスレッドです。
このように考えてください。シングルスレッドのこの控えめなAMD PCでは、JSが最大10 ^ 9までカウントするのに3,300ミリ秒かかり、次の最適化されたセグメント化されたSoSは、14,000ミリ秒で最大10 ^ 9の50847534プライムを取得します。これは、カウントだけの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);これより良くなるかどうかはわかりません。あなたの意見を聞きたいです。
問題の数よりも低い他の素数で割り切れない場合、その数は素数です。
したがって、これは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);
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;
}
前の素数の値に基づいて、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 ]
ここで公開されている他の選択肢よりも高速です。
- ループの制限を整数に合わせて調整します。
- 偶数をスキップして、短い反復ループを使用します。
約130msで最初の100,000個の素数、または約4秒で最初の1m個の素数を得ることができます。
function nextPrime(value) {
if (value > 2) {
var i, q;
do {
i = 3;
value += 2;
q = Math.floor(Math.sqrt(value));
while (i <= q && value % i) {
i += 2;
}
} while (i <= q);
return value;
}
return value === 2 ? 3 : 2;
}
var value, result = [];
for (var i = 0; i < 10; i++) {
value = nextPrime(value);
result.Push(value);
}
display("Primes: " + result.join(', '));
function display(msg) {
document.body.insertAdjacentHTML(
"beforeend",
"<p>" + msg + "</p>"
);
}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);
}
Luchianの答えは、素数を見つけるための標準的な手法へのリンクを提供します。
効率は劣りますが、より簡単なアプローチは、既存のコードをネストされたループに変えることです。 2,3,4,5,6などで除算していることを確認し、それをループに変えます。
これが宿題であり、宿題の目的が基本的なプログラミングの学習を支援することであることを考えると、シンプルで正しいが、やや非効率的なソリューションは問題ありません。
そして、有名なJS忍者のこの有名なコード
var isPrime = n => Array(Math.ceil(Math.sqrt(n)+1)).fill().map((e,i)=>i).slice(2).every(m => n%m);
console.log(Array(100).fill().map((e,i)=>i+1).slice(1).filter(isPrime));
エラトステネスのふるい。少し見た目は簡単ですが、動作します！
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);
エラトステネスのふるいを使用して、 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))この方法も試すことができます。これは基本ですが理解しやすいものです。
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 +",");
}
}
これは、指定された範囲（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;
}
2ですでに削除しようとした場合、なぜ4（および6,8,10,12）で削除しようとするのですか？ ですでに削除しようとした場合、9で削除しようとする理由11 ifで削除しようとする理由 11 * 11 = 121> 100 ？なぜ2で奇数を削除してみますか？なぜ上記でも2を削除してみますか？
デッドテストを排除すると、素数100以下の優れたコードテストが得られます。
そして、あなたのコードはこれまでで最悪のコードではありません。多くのmany他は1を99で除算しようとします。しかし、絶対的なチャンピオンは、2..96と2..96のすべての製品を生成し、97がその中にあるかどうかをテストします。 その1つ は本当に驚くほど非効率的です。
Sieve of Eratosthenes もちろん、はるかに優れており、1つ持つことができます-100s-with - ブール値の配列なし（および除算なし！） ：
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"
ここに私の刺し傷があります。
最初のi=0を0から任意の値に変更し、2番目の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で試してみました-少し時間がかかりますが、正確であるようです。
<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>
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);
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);Nまでの素数を見つけるBrute-force iterativeメソッドとSieve of Eratosthenesメソッドを次に示します。 2番目の方法のパフォーマンスは、時間の複雑さの点で最初よりも優れています。
ブルートフォースの反復
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;
}
エラトステネスのふるい法
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);
});
}
}
次の関数を使用して、素数を見つけます。
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
}
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;
}
JSFiddleを作成し、読みやすい方法で動作する方法を示しました。
アイデアは、2つの関数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);
})();
};
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);
}
エラトステネス法のふるいを使用した私のソリューションは次のとおりです。
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);
これは私の ソリューション です
//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));
これを任意のサイズの素数の配列に使用できます。お役に立てれば
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>このスレッドで紹介される膨大な数のアルゴリズムのいずれかを使用して、それらのいくつかをメモすることを学ぶなら、それはあなたのことでしょう。
まず、別のループ（forおよびwhile）の内部コードを変更して、異なる値に対して同じコードを繰り返すことができるようにします。
特定のnが素数であるかどうかを知りたい場合は、2〜sqrt（n）の間のすべての値に分割する必要があります。モジュールのいずれかが0の場合、素数ではありません。
すべての素数を検索する場合は、以前に見つかった素数で除算するだけで、nを高速化して確認できます。プロセスを高速化する別の方法は、2と3を除いて、すべての素数が6*kプラス1以下であるという事実です。
数値が素数かどうかをテストする方法を次に示します。
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;
}
このようなものはどうですか。
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>');
}
Promptメソッドを使用したくなく、プログラムが素数を出力するのを見たいだけの人のために、私は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
}
}