First attempt at generating prime numbers

Question

I had to look up some other solutions online because I could not figure it out on my own. I really wish I could have come up with it completely on my own, but that didn't happen. Nevertheless, please review my prime number program and let me know if there are any improvements I should make or advice your would like to give me about it.

     var primes = [];                    // will become a list of prime numbers

primes_loop:
for (var n = 2; n < 10; n++) {

    if (n === 2) {
        primes.push(n);              // first prime number is stored
        continue primes_loop;        // continue iteration of the loop
    }

    divisors_loop:
    for (var i = 2; i < n; i++) {

        if (n % i === 0) {
            break divisors_loop;     // n is not prime if condition is true
        }
        else {
            primes.push(n);          // update prime list with the prime number
        }

    }

}

for (var index = 0; index < primes.length; index++) {
    console.log(primes[index]);
}

Answer 1

First of all, there's a slight problem with your code. I get this output:

2, 3, 5, 5, 5, 7, 7, 7, 7, 7, 9

So it repeats quite a bit, and -- wait, 9 is not a prime number. Oops.

For, say, numbers up to 25, you'd get 21 instances of 23 in your array. And we'd get a 24 too, although that's not prime. We'll deal with that in a second.

The way your code runs, you don't need the labels (primes_loop and divisors_loop); when you continue or break you do so for the "closest" loop you're in. So simply writing continue with no label will skip to the next iteration of the outer (prime) loop, and break will break the inner (divisor) loop.

However, a label might be handy for a revised version that actually does find primes and only primes (of course, there are other, smarter approaches to all of this, but I'm just sticking to the code that was posted):

var primes = [],
    limit = 10,
    n, divisor;

outerLoop: for( n = 2 ; n <= limit ; n++ ) {
  for( divisor = 2 ; divisor < n ; divisor++ ) {
    if( n % divisor === 0 ) {                     
      continue outerLoop; // not a prime, try the next n
    }
  }
  primes.push(n); // if we made it all the way here, then n is prime
}

After that, you'll be left with a primes array that looks like this:

[ 2, 3, 5, 7 ]

No repetition, and no false positives.

Of course, it'd be nicer to wrap as a function:

function findPrimes(limit) {
  var primes = [], n, divisor;

  outerLoop: for( n = 2 ; n <= limit ; n++ ) {
    for( divisor = 2 ; divisor < n ; divisor++ ) {
      if( n % divisor === 0 ) {
        continue outerLoop;
      }
    }
    primes.push(n);
  }

  return primes;
}

Answer 2

First, let's correct your algorithm (using this very similar code) and reformat just a little bit your code (with Fiddle's TidyUp):

JSFIDDLE

 var primes = []; // will become a list of prime numbers

 primes_loop: for (var n = 2; n < 10; n++) {

     if (n === 2) {
         primes.push(n); // first prime number is stored
         continue primes_loop; // continue iteration of the loop
     }

     divisors_loop: for (var i = 2; i < n; i++) {

         if (n % i === 0) {
             break divisors_loop; // n is not prime if condition is true
         }

     }

     if (n === i) {
         primes.push(n); // update prime list with the prime number
     }

 }

 for (var index = 0; index < primes.length; index++) {
     console.log(primes[index]);
 }

It printed repeatedly numbers because of the condition for primes.push, and it needed another condition, outside of the loop, to be correct (as it was, it only found odd numbers).

Next up, we don't really need tags for the inner loop. It's clear and very reasonable to remove it, and we even save the condition we just added:

 var primes = []; // will become a list of prime numbers

 primes_loop: for (var n = 2; n < 10; n++) {

     if (n === 2) {
         primes.push(n); // first prime number is stored
         continue; // continue iteration of the loop
     }

     for (var i = 2; i < n; i++) {

         if (n % i === 0) {
             break primes_loop; // n is not prime if condition is true
         }

     }

     primes.push(n); // update prime list with the prime number

 }

 for (var index = 0; index < primes.length; index++) {
     console.log(primes[index]);
 }

But, we might be able to wrap it up in a function and make it work faster, by skipping all multiples of 2:

JSFIDDLE

function findPrimes(lowerLimit, upperLimit) {

    var primes = []; // will become a list of prime numbers

    if (lowerLimit === 2) {
        primes.push(2);
    }

    if (lowerLimit % 2 === 0) {
        lowerLimit++;
    }

    primes_loop: for (var n = lowerLimit; n < upperLimit; n = n + 2) {

        for (var i = 2; i < n; i++) {

            if (n % i === 0) {
                break primes_loop; // n is not prime if condtion is ture
            }

        }

        primes.push(n); // update prime list with the prime number

    }

    for (var index = 0; index < primes.length; index++) {
        alert(primes[index]);
    }

}

findPrimes(2, 10);

This may get you started, but if primes is what you want, there are better methods (indeed, even this method may be optimized further).