Solving "Sum All Primes" / freeCodeCamp Algorithm Challenges
Tags: freecodecamp, algorithms, challenge, javascript
Published: 2020-07-28 20:08:56

---
title: Solving "Sum All Primes" / freeCodeCamp Algorithm Challenges
published: true
description: My guide, notes, and solution to freeCodeCamp's intermediate algorithm challenge, "Sum All Primes" 
tags: #freeCodeCamp, #algorithms, #challenge, #javascript
canonical_url: https://virenb.cc/fcc-029-sum-all-primes
series: Solving freeCodeCamp's Algorithm Challenges
---

*Post can also be found on [https://virenb.cc/fcc-029-sum-all-primes](https://virenb.cc/fcc-029-sum-all-primes "Solution on virenb.cc blog")*

![Sum All Primes](//images.ctfassets.net/yzwpq1epaq68/1fKgl2exWYQTxO8tCgP42L/829b55ff2210fad120f6ca171e439b28/ss-029.png)

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



### Starter Code

```javascript
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.



```javascript
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.



```javascript
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.



```javascript
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`.



```javascript
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:



```javascript
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:



```javascript
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.



```javascript
let sum = 0;
```



```javascript
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`.



```javascript
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.



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





# Our Solution

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



# Links & Resources

['Sum All Primes' Challenge on fCC]( https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes "Intermediate Algorithm Scripting: Sum All Primes on fCC Website")

[freeCodeCamp](https://www.freecodecamp.org/, "freeCodeCamp")

[Donate to FCC!](https://www.freecodecamp.org/donate "fCC Donation Page")

[Solution on my GitHub](https://github.com/virenb/fcc-algorithms/blob/master/029---sum-all-primes.js "GitHub Solution")



Thank you for reading!