# Solving "Sum All Primes" / freeCodeCamp Algorithm Challenges

### 7/28/2020

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Sum All Primes'.

### Starter Code

``````function sumPrimes(num) {
return num;
}

sumPrimes(10);
``````

### Instructions

A prime number is a whole number greater than 1 with exactly two divisors: 1 and itself. For example, 2 is a prime number because it is only divisible by 1 and 2. In contrast, 4 is not prime since it is divisible by 1, 2 and 4.

Rewrite `sumPrimes` so it returns the sum of all prime numbers that are less than or equal to num.

### Test Cases

• `sumPrimes(10)` should return a number.
• `sumPrimes(10)` should return 17.
• `sumPrimes(977)` should return 73156.

# Our Approach

The instructions for this challenge are short and to the point.

• Our one input is `num`, an integer.
• We must return an integer.
• We need to do two things. Identify all the prime numbers within `num` and then add them up.

So, before we start, if we re-read the instructions, it provides us with a definition of what a prime number is.

A prime number is a whole number greater than 1 with exactly two divisors: 1 and itself. For example, 2 is a prime number because it is only divisible by 1 and 2. In contrast, 4 is not prime since it is divisible by 1, 2 and 4.

Some examples of prime numbers: 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

So, hopefully that gives a better idea on what a prime number is and how to find out if a number is prime.

For this challenge, I think it would be best if we broke it up into two parts. One part is to write code on figuring out if a number is prime. The second part would be to calculate the sum of all the prime numbers (within `num`).

Let's start with prime numbers. From the above description, a prime number is divisible only by itself and 1. While making our prime number checker function, we can start with an `if` statement. If the argument is less than or equal to one, we can return false as it will not be a prime number. Even though the test cases do not give us a number so small, I included it anyway.

``````function isPrime(n) {
if (n <= 1) return false;
}
``````

The modulo operator will be very useful as we can check the divisibility of each number. I'll opt to use a for loop to check how many divisors `n` will have.

We can start the checking with 2.

``````for (let i = 2; i <= (n/2); i++) {}
``````

So, if our number is 11 (a prime number), it would run 4 times.

Inside the for loop, we can write an `if` statement checking if `n` is divisible by `i`. If it returns a remainder of 0, we know it is not a prime number. We can return false. Here is the updated code.

``````function isPrime(n) {
if (n <= 1) return false;
for (let i = 2; i <= (n/2); i++) {
if (n % i === 0) {
return false
}
}
}
``````

We would determine `n` is divisible by more than just 1 and itself, so it wouldn't be a prime number. We would return false and exit the loop. If it is not divisble by `i` at all, we know it is a prime number. We can return a `true`.

``````function isPrime(n) {
if (n <= 1) return false;
for (let i = 2; i <= (n/2); i++) {
if (n % i === 0) {
return false
}
}
return true;
}
``````

Let us try it out with a small number, 5:

``````isPrime(5);

function isPrime(n) {
if (n <= 1) return false;
for (let i = 2; i <= (n/2); i++) {
if (n % i === 0) {
return false
}
}
return true;
}

// n = 5
// First line, is not true, so keep it running
// First for loop, 5 % 2 !== 0

// There is no second loop, because i = 3 and it is bigger than 5/2
// 5 is a prime number
``````

Let's try with 9 now:

``````isPrime(9);

function isPrime(n) {
if (n <= 1) return false;
for (let i = 2; i <= (n/2); i++) {
if (n % i === 0) {
return false
}
}
return true;
}

// n = 9
// First line, is not true, so keep it running
// First for loop, 9 % 2 !== 0

// Second loop, i = 3, 3 <= (9/2) still true
// 9 % 3 === 0 is true so we return false
// 9 is not prime as it is divisible by 1, 3, 9
``````

Hopefully that helped grasp the prime number part of the challenge. Now that we have a helper function to determine prime numbers, we can see how to sum the prime numbers of `num`.

So we'll be using another for loop. Before we start looping, I will declare a variable, `sum`, and set it to 0. This will be the number we return.

``````let sum = 0;
``````
``````function sumPrimes(num) {
let sum = 0;
// For loop
return sum;
}
``````

So we want to go through every number smaller than `num`, and check if its a prime number. If it is, we will add it into our new variable, `sum`.

``````for (let j = 1; j <= num; j++) {
if (isPrime(j)) {
sum += j;
}
}
``````

Having this helper function makes the this function a lot more cleaner. It evaluates each number, and will add it into the sum if it is prime.

``````function sumPrimes(num) {
let sum = 0;
for (let j = 1; j <= num; j++) {
if (isPrime(j)) {
sum += j;
}
}
return sum;
}
``````

# Our Solution

``````function sumPrimes(num) {
let sum = 0;
for (let j = 1; j <= num; j++) {
if (isPrime(j)) {
sum += j;
}
}
return sum;
}

function isPrime(n) {
if (n <= 1) return false;
for (let i = 2; i <= (n/2); i++) {
if (n % i === 0) {
return false;
}
}
return true;
}
``````