Primes utils

find-primes-in-string.js

function findPrimesInString(str) {
  //console.log('str:', str, '| str.length:', str.length);
  if (str.match(/prime/gi)) { return true; }
  if (str.replace(/[a-z]+/gi, '').length === 0) { return false; }
  str = str.split(/[a-z]+/gi).filter(item => item);
  //console.log(str);
  let res = false;
  let i = 0;
  (function recurse() {
    if (str[i]) {
      const str2int = parseInt(str[i]);
      const intSqrt = Math.floor(Math.sqrt(str2int));
      if (isNaN(str2int)) { return false; }
      function isPrime(number, j) {
        const prime = ((number % j === 0 && number > 2) || number < 2) ? false : true;
        //console.log('number', number, '| j:', j, '| prime:', prime);
        res = prime;
        if (j <= intSqrt && prime) {
          j++;
          isPrime(number, j);
        }
      }
      isPrime(str2int, 2);
      //console.log('res:', res);
      if (res) { return true; }
      else {
        i++;
        recurse();
      }
    }
  })();
  return res;
}

// TEST
findPrimesInString('optimusprime'); // true
findPrimesInString('11'); // true
findPrimesInString('4'); // false
findPrimesInString('starPrime'); // true
findPrimesInString('11aagghh4'); // true

get-n-primes.js

class Primes {
  static isPrime(n) {
    let isPrime = true;
    primeDetectionLoop:
    for (let j = 2, max = n - 1; j <= max; j++) {
      if (n % j === 0) {
        isPrime = false;
        break primeDetectionLoop;
      }
    }
    return (n < 2) ? false : isPrime;
  };
  static first(n) {
    let counter = this.primes.length;
    let i = (counter) ? this.primes[counter - 1] + 1 : 2;
    if (counter < n) {
      while (counter < n) {
        if (this.isPrime(i)) {
          this.primes.push(i);
          counter++;
        }
        i++;
      }
      return this.primes;
    } else {
      return this.primes.slice(0, n);
    }
  };
}
Primes.primes = [];

// TEST
Primes.first(1) // [2]
Primes.first(5) // [2, 3, 5, 7, 11]
Primes.first(19).slice(16,18) // [59, 61]
Primes.first(100)[5] // 11

prime-factors-decomposition.js

function primeFactorsDecomposition(n) {
  if (!n) { return 0; }
  let primes = [];
  for (let i = 2, max = Math.floor(Math.sqrt(n)); i <= max; i++) {
    // find prime numbers
    let isPrime = true;
    primeDetectionLoop:
    for (let j = 2, jMax = i - 1; j < jMax; j++) {
      if (i % j === 0) {
        isPrime = false;
        break primeDetectionLoop;
      }
    }
    if (isPrime) { primes.push(i); }
  }
  //console.log('primes:', primes);
  let decomp = {};
  let rest = n;
  if (primes.filter(item => rest % item === 0).length > 0) {
    restDecreaseLoop:
    while (rest > 1) {
      let minPrime;
      let NA = true; // rest is > 1 but no prime factor found => rest is prime factor
      findMinPrimeLoop:
      for (let i in primes) {
        if (rest % primes[i] === 0) {
          NA = false;
          minPrime = primes[i];
          //console.log('minPrime:', minPrime);
          rest = rest / minPrime;
          //console.log('rest:', rest);
          if (decomp.hasOwnProperty(minPrime)) { decomp[minPrime]++; }
          else { decomp[minPrime] = 1; }
          break findMinPrimeLoop;
        }
      }
      if (NA) {
        decomp[rest] = 1;
        break restDecreaseLoop;
      }
    }
  } else { decomp[rest] = 1; }
  //console.log('decomp:', decomp);
  let res = '';
  for (let key in decomp) {
    const value = decomp[key];
    res += (value > 1) ? '(' + key + '**' + value + ')' : '(' + key + ')';
  }
  return res;
}

// TEST
primeFactorsDecomposition(7775460); // "(2**2)(3**3)(5)(7)(11**2)(17)"

prime-generator.js

function isPrime(number) {
  let isPrime = true;
  primeDetectionLoop:
  for (let j = 2, jMax = number - 1; j < jMax; j++) {
    if (number % j === 0) {
      isPrime = false;
      break primeDetectionLoop;
    }
  }
  return (number < 2) ? false : isPrime;
}

function getPrimes(start, finish) {
  if (start > finish) {
    const finCopy = finish;
    finish = start;
    start = finCopy;
  }
  if (finish < 2) { return []; }
  let primes = [];
  for (let i = (start < 2) ? 2 : start; i <= finish; i++) {
    if (isPrime(i)) { primes.push(i); }
  }
  return primes;
}

// TEST
getPrimes(0, 20).join(); // '2,3,5,7,11,13,17,19'
getPrimes(10, 20).join(); // '11,13,17,19'
getPrimes(20, 10).join(); // '11,13,17,19'

primes-before-and-after.js

function primesBeforeAndAfter(num) {
  if (!num) { return [2]; }
  function isPrime(number) {
    let isPrime = true;
    primeDetectionLoop:
    for (let j = 2, jMax = number - 1; j < jMax; j++) {
      if (number % j === 0) {
        isPrime = false;
        break primeDetectionLoop;
      }
    }
    return (number < 2) ? false : isPrime;
  }
  let primes = [];
  findPreviousLoop:
  for (let i = num - 1; i >= 2; i--) {
    if (isPrime(i)) {
      primes.push(i);
      break findPreviousLoop;
    }
  }
  findNextLoop:
  for (let i = num + 1; ; i++) {
    if (isPrime(i)) {
      primes.push(i);
      break findNextLoop;
    }
  }
  return primes;
}

// TEST
primesBeforeAndAfter(100); // [97, 101]
primesBeforeAndAfter(101); // [97, 103]

Primes.markdown

Primes utils

prime-generator.js

Function isPrime(number) checks whether provided number is prime or not.

Function getPrimes(start, finish) generates prime numbers sequence in provided range. Range can be provided in wrong sequence, i.e. getPrimes(20,0).

prime-factors-decomposition.js

Function primeFactorsDecomposition(n) decomposes provided integer to prime factors and return output in format "(p1**n1)(p2**n2)...(pk**nk)".

get-n-primes.js

Class Primes has static methods: isPrime(n) - checks if n is a prime number, first(n) - returns first n prime numbers. The class memorises previously generated primes in static variable primes.

primes-before-and-after.js

Function primesBeforeAndAfter(num) returns an array of primes [primeBefore, primeAfter] before and after the provided number num.

find-primes-in-string.js

Function findPrimesInString(str) finds primes in a string if str contains a substring prime (not case sensitive), or if str contains prime numbers apart from letters. The function uses recursion instead of loops.

Scripts by V.

License.