Простое числовое тестирование в JavaScript

Ответ 1

Как можно проще:

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;
}

Ответ 2

Небольшое предложение здесь, почему вы хотите запустить цикл для целых 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))

За дополнительной информацией Почему мы проверяем квадратный корень простого числа, чтобы определить, является ли оно простым?

Надеюсь, что это поможет

Ответ 3

Прохладная версия:

const isPrime = n => ![...Array(n).keys()].slice(2).map(i => !(n%i)).includes(true) && ![0,1].includes(n)

Ответ 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 true;
}

Ответ 5

// 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);

Ответ 6

Простые числа имеют вид 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))

Ответ 7

function isPrime(num) {
    var prime = num != 1;
    for(var i=2; i<num; i++) {
        if(num % i == 0) {
            prime = false;
            break;
        }
    }
    return prime;
}

DEMO

Ответ 8

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 not a prime number so return false
  }
  return n > 1; // otherwise it 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

Ответ 9

Я думаю, что этот вопрос не имеет рекурсивного решения:

// 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 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');
}

Ответ 10

вы можете использовать приведенный ниже код в 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) ложь

Ответ 11

Я думаю, что лучший способ найти простое число с этой логикой:

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

Вы можете попробовать это

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');
   }

Ответ 13

Вы пытаетесь проверить слишком много условий. для проверки простого числа требуется только один цикл.

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 a prime no.
}
return true;
}

Вы должны учитывать все, что нет. просто нет. если он не делится на некоторые нет. меньше или равно квадратному корню.

У вашего решения есть оператор возврата для каждого случая, поэтому он прекращает выполнение до того, как он должен. Он не проверяет число более одного раза. Он дает неправильный ответ для нескольких случаев - 15,35.. на самом деле для каждый нет. это нечетно.

Ответ 14

Он выглядит как ваш первый оператор if в первом выражении "if" в цикле for. Так как если num = 9 и я = 2, 9% i! == 0, но 9 не является простым, так как на следующей итерации, где я = 3, 9% я === 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 из-за математического свойства, в котором число не имеет обоих факторов, больших квадратного корня из этого числа.

Надеюсь, это поможет!

Ответ 15

Это я считаю более эффективным для проверки простого числа:

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))

Ответ 16

Простая версия:

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));

Ответ 17

Вот как я это сделаю:

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;
}

Ответ 18

очень просто

const isPrime = num => {
  for (var i = 2; i < num; i++) if (num % i == 0) return false;
  return num >= 2; 
}

Ответ 19

(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));

Ответ 20

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

Ответ 21

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);
    }

Ответ 22

Использование решения Ticked Игорь Сакайлюк

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) true

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) false

isPrime (100) false

isPrime (-100) false

Первые 6 простых чисел? 2 3 5 7 11 13?

isPrime (1) false

isPrime (2) true//Prime 1

isPrime (3) true//Prime 2

isPrime (4) false

isPrime (5) true//Prime 3

isPrime (6) ложь

isPrime (7) true//Prime 4

isPrime (8) false

isPrime (9) ложь

isPrime (10) false

isPrime (11) true//Prime 5

isPrime (12) ложь

isPrime (13) true//Prime 6

Ответ 23

Этот ответ основан на ответе Игоря Сакайлюка. Но вместо того, чтобы проверять все числа, я проверяю только нечетные числа. Сделав это, я сократил временную сложность решения до 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;
}

Ответ 24

function isPrime(n){
	if (isNaN(n) || !isFinite(n) || n%1 || n<2) {
		return false;
	}

	if (n%2==0){
		return (n==2);
	}

	var sqrt = Math.sqrt(n);
	for (var i = 3; i < sqrt; i+=2) {
		if(n%i == 0){
			return false;
		}
	}
	
	return true;
}

Ответ 25

Это будет охватывать всю возможность простого числа. (порядок последних 3 если утверждения важны)

   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;        
   }

Ответ 26

Следующий код использует наиболее эффективный способ зацикливания, чтобы проверить, является ли данное число простым.

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
}

1. Сначала проверьте правила 2 и меньшие числа и все четные числа
2. Использование Math.sqrt() для минимизации количества циклов
3. Увеличение счетчика циклов на 2, пропуск всех четных чисел, дальнейшее уменьшение числа циклов вдвое