How to find prime numbers between 0 - 100?

Question

In Javascript how would i find prime numbers between 0 - 100? i have thought about it, and i am not sure how to find them. i thought about doing x % x but i found the obvious problem with that. this is what i have so far: but unfortunately it is the worst code ever.

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

Answer 1

function primes(n) {
    let f, known = [2, 3]; // known primes (extend to possibly include n).
    const uneven = (f, q) => q % f; // factor doesn't divide evenly?
    const small = (f, q) => f * f < q; // factor smaller than squareroot?
    for (let q = 5; q <= n; q += 2) { // starting with 5, test odd numbers up to n.
        f = 3; // starting with 3, try small primes (up to squareroot) as factors.
        for (let i = 2; uneven(f, q) && small(f, q); i++) f = known[i]; // continue?
        if (uneven(f, q)) known.push(q); // if nothing factors it, it must be prime!
    }
    return known;
}

Answer 2

Here is an efficient, short solution using JS generators. JSfiddle

// Consecutive numbers starting from n
function* nats (n) {
    while (true) yield n++
}

// Recursively sift primes, starting with the stream of numbers 2 and above
function* primes () {
    yield* sieve(primes(), nats(2))
}

// Take a stream of primes and the stream of already-sifted numbers, and
//   recursively yield from streams of numbers each time sifted by a new prime
function* sieve (ps, ns) {

    // The first new already-sifted number must also be prime
    // (In the first call, this loads a 2 into the prime stream to begin
    //   sifting)
    yield ns.next().value;
    let n;

    // Get p, the new prime which this sieve focuses on
    const p = ps.next().value;

    // Yield already-sifted numbers up to p^2
    while ((n = ns.next().value) < p * p) yield n;

    // Yield from a new sieve that also removes p-divisible numbers
    yield* sieve(ps, (function* () {
        while (n = ns.next().value) if (n % p) yield n
    })())

}

// Longest prefix of stream where some predicate holds
function* take (vs, pf) {
    let v;
    while (!(v = vs.next()).done && pf(v.value)) yield v.value
}

document.querySelectorAll('dd')[0].textContent =

// Primes smaller than 100
    [...take(primes(), x => x < 100)].join(', ')

<dl>
<dt>Primes under 100</dt>
<dd></dd>
</dl>

Answer 3

Here's a fast way to calculate primes in JavaScript, based on the previous prime value.

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

Test

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

Output

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

It is faster than other alternatives published here, because:

• It aligns the loop limit to an integer, which works way faster;
• It uses a shorter iteration loop, skipping even numbers.

It can give you the first 100,000 primes in about 130ms, or the first 1m primes in about 4 seconds.

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

UPDATE

A modern, efficient way of doing it, using prime-lib:

import {generatePrimes, stopWhen} from 'prime-lib';

const p = generatePrimes(); //=> infinite prime generator
const i = stopWhen(p, a => a > 100); //=> Iterable<number>

console.log(...i); //=> 2 3 5 7 11 ... 89 97

Answer 4

I have slightly modified the Sieve of Sundaram algorithm to cut the unnecessary iterations and it seems to be very fast.

This algorithm is actually two times faster than the most accepted @Ted Hopp's solution under this topic. Solving the 78498 primes between 0 - 1M takes like 20~25 msec in Chrome 55 and < 90 msec in FF 50.1. Also @vitaly-t's get next prime algorithm looks interesting but also results much slower.

This is the core algorithm. One could apply segmentation and threading to get superb results.

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

The loop limits explained:

Just like the Sieve of Erasthotenes, the Sieve of Sundaram algorithm also crosses out some selected integers from the list. To select which integers to cross out the rule is i + j + 2ij ≤ n where i and j are two indices and n is the number of the total elements. Once we cross out every i + j + 2ij, the remaining numbers are doubled and oddified (2n+1) to reveal a list of prime numbers. The final stage is in fact the auto discounting of the even numbers. It's proof is beautifully explained here.

Sieve of Sundaram is only fast if the loop indices start and end limits are correctly selected such that there shall be no (or minimal) redundant (multiple) elimination of the non-primes. As we need i and j values to calculate the numbers to cross out, i + j + 2ij up to n let's see how we can approach.

i) So we have to find the the max value i and j can take when they are equal. Which is 2i + 2i^2 = n. We can easily solve the positive value for i by using the quadratic formula and that is the line with t = (Math.sqrt(4+8*n)-2)/4,

j) The inner loop index j should start from i and run up to the point it can go with the current i value. No more than that. Since we know that i + j + 2ij = n, this can easily be calculated as u = (n-i)/(1+2*i);

While this will not completely remove the redundant crossings it will "greatly" eliminate the redundancy. For instance for n = 50 (to check for primes up to 100) instead of doing 50 x 50 = 2500, we will do only 30 iterations in total. So clearly, this algorithm shouldn't be considered as an O(n^2) time complexity one.

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

among which there are only 5 duplicates. 22, 31, 37, 40, 49. The redundancy is around 20% for n = 100 however it increases to ~300% for n = 10M. Which means a further optimization of SoS bears the potentital to obtain the results even faster as n grows. So one idea might be segmentation and to keep n small all the time.

So OK.. I have decided to take this quest a little further.

After some careful examination of the repeated crossings I have come to the awareness of the fact that, by the exception of i === 1 case, if either one or both of the i or j index value is among 4,7,10,13,16,19... series, a duplicate crossing is generated. Then allowing the inner loop to turn only when i%3-1 !== 0, a further cut down like 35-40% from the total number of the loops is achieved. So for instance for 1M integers the nested loop's total turn count dropped to like 1M from 1.4M. Wow..! We are talking almost O(n) here.

I have just made a test. In JS, just an empty loop counting up to 1B takes like 4000ms. In the below modified algorithm, finding the primes up to 100M takes the same amount of time.

I have also implemented the segmentation part of this algorithm to push to the workers. So that we will be able to use multiple threads too. But that code will follow a little later.

So let me introduce you the modified Sieve of Sundaram probably at it's best when not segmented. It shall compute the primes between 0-1M in about 15-20ms with Chrome V8 and Edge ChakraCore.

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

Well... finally I guess i have implemented a sieve (which is originated from the ingenious Sieve of Sundaram) such that it's the fastest JavaScript sieve that i could have found over the internet, including the "Odds only Sieve of Eratosthenes" or the "Sieve of Atkins". Also this is ready for the web workers, multi-threading.

Think it this way. In this humble AMD PC for a single thread, it takes 3,300 ms for JS just to count up to 10^9 and the following optimized segmented SoS will get me the 50847534 primes up to 10^9 only in 14,000 ms. Which means 4.25 times the operation of just counting. I think it's impressive.

You can test it for yourself;

console.time("tare");
for (var i = 0; i < 1000000000; i++);
console.timeEnd("tare");

And here I introduce you to the segmented Seieve of Sundaram at it's best.

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

Here I present a multithreaded and slightly improved version of the above algorithm. It utilizes all available threads on your device and resolves all 50,847,534 primes up to 1e9 (1 Billion) in the ballpark of 1.3 seconds on my trash AMD FX-8370 8 core desktop. While there exists some very sophisticated sublinear sieves, I believe the modified Segmented Sieve of Sundaram could only be stretced this far to being linear in time complexity. Which is not bad.

class Threadable extends Function {
  
  constructor(f){
    super("...as",`return ${f.toString()}.apply(this,as)`);
  }
  
  spawn(...as){
    var code = `self.onmessage = m => self.postMessage(${this.toString()}.apply(null,m.data));`,
        blob = new Blob([code], {type: "text/javascript"}),
        wrkr = new Worker(window.URL.createObjectURL(blob));
    return new Promise((v,x) => ( wrkr.onmessage = m => (v(m.data), wrkr.terminate())
                                , wrkr.onerror   = e => (x(e.message), wrkr.terminate())
                                , wrkr.postMessage(as)
                                ));
  }
}

function pi(n){

  function scan(start,end,tid){
  
    function sieve(g,o){
      var t = (Math.sqrt(4+8*(g+o))-2)/4,
          e = 0,
          s = 0,
          a = new Uint8Array(g),
          c = 0,
          l = o ? (g+o-1)/3
                : (g-1)/3;
      
      if (o) {
        for(var i = Math.ceil((o-1)/3); i < l; i++) a[1+3*i-o] = 0x01;
        for(var i = 2; i < t; i++){
          if (i%3-1) {
            s = Math.ceil((o-i)/(1+2*i));
            e = (g+o-i)/(1+2*i);
            for(var j = s; j < e; j++) a[i + j + 2*i*j-o] = 0x01; 
          }
        }
      } else {
          for(var i = 1; i < l; i++) a[1+3*i] = 0x01;
          for(var i = 2; i < t; i++){
            if (i%3-1){
              e = (g-i)/(1+2*i);
              for(var j = i; j < e; j++) a[i + j + 2*i*j] = 0x01;
            }
          }
        }
      for (var i = 0; i < g; i++) !a[i] && c++;
      return c;
    }
    end   % 2 && end--;
    start % 2 && start--;
    var n  = end - start,
        cs = n < 2e6 ? 1e4   : 
             n < 2e7 ? 2e5   :
                     4.5e5 ,        // Math.floor(3*n/1e3),  // chunk size
        cc = Math.floor(n/cs),      // chunk count
        xs = n % cs,                // excess after last chunk
        pc = 0;
  
    for(var i = 0; i < cc; i++) pc += sieve(cs/2,(start+i*cs)/2);
    xs && (pc += sieve(xs/2,(start+cc*cs)/2));
    return pc;
  }
  var tc = navigator.hardwareConcurrency,
      xs = n % tc,
      cs = (n-xs) / tc,
      st = new Threadable(scan),
      ps = Array.from( {length:tc}
                     , (_,i) => i ? st.spawn(i*cs+xs,(i+1)*cs+xs,i)
                                  : st.spawn(0,cs+xs,i)
                     );
  return Promise.all(ps);
}

var n = 1e9,
    count;

console.time("primes");
pi(n).then(cs => ( count = cs.reduce((p,c) => p+c)
                 , console.timeEnd("primes")
                 , console.log(count)
                 )
          )
     .catch(e => console.log(`Error: ${e}`));

So this is as far as I could take the Sieve of Sundaram.

Answer 5

Here's my stab at it.

Change the initial i=0 from 0 to whatever you want, and the the second i<100 from 100 to whatever to get primes in a different range.

for(var i=0; i<100000; i++){
    var devisableCount = 2;

    for(var x=0; x<=i/2; x++){
        if (devisableCount > 3) {
            break;
        }
        if(i !== 1 && i !== 0 && i !== x){
            if(i%x === 0){
               devisableCount++;
             }
        }
    }

    if(devisableCount === 3){
        console.log(i);
    }
}

I tried it with 10000000 - it takes some time but appears to be accurate.

Answer 6

A version without any loop. Use this against any array you have. ie.,

[1,2,3...100].filter(x=>isPrime(x));
const isPrime = n => {
if(n===1){
return false;
}
if([2,3,5,7].includes(n)){
return true;
}
return n%2!=0 && n%3!=0 && n%5!=0 && n%7!=0;
}

Answer 7

I was searching how to find out prime number and went through above code which are too long. I found out a new easy solution for prime number and add them using filter. Kindly suggest me if there is any mistake in my code as I am a beginner.

function sumPrimes(num) {

let newNum = [];

for(let i = 2; i <= num; i++) {
newNum.push(i)
}
for(let i in newNum) {

newNum = newNum.filter(item => item == newNum[i] || item % newNum[i] !== 0)
}

return newNum.reduce((a,b) => a+b)
}

sumPrimes(10);

Answer 8

I recently came up with a one-line solution that accomplishes exactly this for a JS challenge on Scrimba (below).

ES6+

const getPrimes=num=>Array(num-1).fill().map((e,i)=>2+i).filter((e,i,a)=>a.slice(0,i).every(x=>e%x!==0));

< ES6

function getPrimes(num){return ",".repeat(num).slice(0,-1).split(',').map(function(e,i){return i+1}).filter(function(e){return e>1}).filter(function(x){return ",".repeat(x).slice(0,-1).split(',').map(function(f,j){return j}).filter(function(e){return e>1}).every(function(e){return x%e!==0})})};

This is the logic explained:

1. First, the function builds an array of all numbers leading up to the desired number (in this case, 100) via the .repeat() function using the desired number (100) as the repeater argument and then mapping the array to the indexes+1 to get the range of numbers from 0 to that number (0-100). A bit of string splitting and joining magic going on here. I'm happy to explain this step further if you like.

2. We exclude 0 and 1 from the array as they should not be tested for prime, lest they give a false positive. Neither are prime. We do this using .filter() for only numbers > 1 (≥ 2).

3. Now, we filter our new array of all integers between 2 and the desired number (100) for only prime numbers. To filter for prime numbers only, we use some of the same magic from our first step. We use .filter() and .repeat() once again to create a new array from 2 to each value from our new array of numbers. For each value's new array, we check to see if any of the numbers ≥ 2 and < that number are factors of the number. We can do this using the .every() method paired with the modulo operator % to check if that number has any remainders when divided by any of those values between 2 and itself. If each value has remainders (x%e!==0), the condition is met for all values from 2 to that number (but not including that number, i.e.: [2,99]) and we can say that number is prime. The filter functions returns all prime numbers to the uppermost return, thereby returning the list of prime values between 2 and the passed value.

As an example, using one of these functions I've added above, returns the following:

getPrimes(100);
// => [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]

Answer 9

function isPrime(num) {
  for(var i = 2; i < num; i++)
    if(num % i === 0) return false;
  return num ;
}
function primes(n){
  var array_of_primes=[];
for(var i = 2; i < n; i++){
    if(isPrime(i)) array_of_primes.push(i)>1;
     }
   return array_of_primes;
}
document.write(primes(10000));

Answer 10

• Why try deleting by 4 (and 6,8,10,12) if we've already tried deleting by 2 ?
  Why try deleting by 9 if we've already tried deleting by 3 ?
  Why try deleting by 11 if 11 * 11 = 121 which is greater than 100 ?
  Why try deleting any odd number by 2 at all?
  Why try deleting any even number above 2 by anything at all?

Eliminate the dead tests and you'll get yourself a good code, testing for primes below 100.

And your code is very far from being the worst code ever. Many many others would try dividing 100 by 99. But the absolute champion would generate all products of 2..96 with 2..96 to test whether 97 is among them. That one really is astonishingly inefficient.

Sieve of Eratosthenes of course is much better, and you can have one -- under 100 -- with no arrays of booleans (and no divisions too!):

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"

---

This is the sieve of Eratosthenes, were we skip over the composites - and that's what this code is doing. The timing of generation of composites and of skipping over them (by checking for equality) is mixed into one timeline. The usual sieve first generates composites and marks them in an array, then sweeps the array. Here the two stages are mashed into one, to avoid having to use any array at all (this only works because we know the top limit's square root - 10 - in advance and use only primes below it, viz. 3,5,7 - with 2's multiples, i.e. evens, implicitly skipped over in advance).

In other words this is an incremental sieve of Eratosthenes and m3, m5, m7 form an implicit priority queue of the multiples of primes 3, 5, and 7.

Answer 11

Using Sieve of Eratosthenes, source on Rosettacode

fastest solution: 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))

Answer 12

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

Answer 13

You can try this method also, this one is basic but easy to understand:

 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 +",");
  }
}

Answer 14

Here's the very simple way to calculate primes between a given range(1 to limit).

Simple Solution:

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

Answer 15

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

Answer 16

A list built using the new features of ES6, especially with generator. Go to https://codepen.io/arius/pen/wqmzGp made in Catalan language for classes with my students. I hope you find it useful.

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

Answer 17

A number is a prime if it is not divisible by other primes lower than the number in question.

So this builds up a primes array. Tests each new odd candidate n for division against existing found primes lower than n. As an optimization it does not consider even numbers and prepends 2 as a final step.

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

Answer 18

And this famous code from a famous JS Ninja

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

Answer 19

You can use this for any size of array of prime numbers. Hope this helps

 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>

Answer 20

Here are the Brute-force iterative method and Sieve of Eratosthenes method to find prime numbers upto n. The performance of the second method is better than first in terms of time complexity

Brute-force iterative

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

Sieve of Eratosthenes method

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

Answer 21

Here is my solution using Sieve of Eratosthenes method:

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

Answer 22

I have created a JSFiddle showing how it should work in a readable way,

idea is to have two functions isPrime and getPrimeNumbers to separate functionality, as well as using Math.pow and initial value of 2, as it should be always there, see the jsfiddle attached 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);
  })();
};

Answer 23

Here's how I solved it. Rewrote it from Java to JavaScript, so excuse me if there's a syntax error.

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

A number, n, is a prime if it isn't divisible by any other number other than by 1 and itself. Also, it's sufficient to check the numbers [2, sqrt(n)].

Answer 24

This is my solution

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

Answer 25

How about something like this.

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

Answer 26

Did anyone try this? It's simple and efficient ...

function Prime(num) {
  if (num <= 2)return false;
  for(var i = 2; i < num; i++){
    if (num % i == 0) return false;
  }
  return true;
}

function PrimeWithin(userinput){
  for(var i = 2; i < userinput; i++){
    if(Prime(i)){
        console.log(i);
    }
  }
}

PrimeWithin(500);

Answer 27

Sieve of Eratosthenes. its bit look but its simple and it works!

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

Answer 28

I modified Rinto's answer just for those who don't want to use the prompt method and just want to see the program print prime numbers . its working

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

Answer 29

To find prime numbers between 0 to n. You just have to check if a number x is getting divisible by any number between 0 - (square root of x). If we pass n and to find all prime numbers between 0 and n, logic can be implemented as -

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

Answer 30

Here is a way to test if number is prime number.

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