diff --git a/curriculum/challenges/english/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.english.md b/curriculum/challenges/english/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.english.md
index 0106910d68..0cf58778f4 100644
--- a/curriculum/challenges/english/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.english.md
+++ b/curriculum/challenges/english/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.english.md
@@ -8,31 +8,31 @@ forumTopicId: 301175
 
 ## Description
 <section id='description'>
-Recursion is the concept that a function can be expressed in terms of itself. To help understand this, start by thinking about the following task: multiply the elements from <code>0</code> to <code>n</code> inclusive in an array to create the product of those elements. Using a <code>for</code> loop, you could do this:
+Recursion is the concept that a function can be expressed in terms of itself. To help understand this, start by thinking about the following task: multiply the first <code>n</code> elements of an array to create the product of those elements. Using a <code>for</code> loop, you could do this:
 
 ```js
   function multiply(arr, n) {
-    var product = arr[0];
-    for (var i = 1; i <= n; i++) {
+    var product = 1;
+    for (var i = 0; i < n; i++) {
         product *= arr[i];
     }
     return product;
   }
 ```
 
-However, notice that <code>multiply(arr, n) == multiply(arr, n - 1) * arr[n]</code>. That means you can rewrite <code>multiply</code> in terms of itself and never need to use a loop.
+However, notice that <code>multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]</code>. That means you can rewrite <code>multiply</code> in terms of itself and never need to use a loop.
 
 ```js
   function multiply(arr, n) {
     if (n <= 0) {
-      return arr[0];
+      return 1;
     } else {
-      return multiply(arr, n - 1) * arr[n];
+      return multiply(arr, n - 1) * arr[n - 1];
     }
   }
 ```
 
-The recursive version of <code>multiply</code> breaks down like this. In the <dfn>base case</dfn>, where <code>n <= 0</code>, it returns the result, <code>arr[0]</code>. For larger values of <code>n</code>, it calls itself, but with <code>n - 1</code>. That function call is evaluated in the same way, calling <code>multiply</code> again until <code>n = 0</code>.  At this point, all the functions can return and the original <code>multiply</code> returns the answer.
+The recursive version of <code>multiply</code> breaks down like this. In the <dfn>base case</dfn>, where <code>n <= 0</code>, it returns 1. For larger values of <code>n</code>, it calls itself, but with <code>n - 1</code>. That function call is evaluated in the same way, calling <code>multiply</code> again until <code>n <= 0</code>.  At this point, all the functions can return and the original <code>multiply</code> returns the answer.
 
 <strong>Note:</strong> Recursive functions must have a base case when they return without calling the function again (in this example, when <code>n <= 0</code>), otherwise they can never finish executing.
 
@@ -41,7 +41,7 @@ The recursive version of <code>multiply</code> breaks down like this. In the <df
 ## Instructions
 <section id='instructions'>
 
-Write a recursive function, <code>sum(arr, n)</code>, that returns the sum of the elements from <code>0</code> to <code>n</code> inclusive in an array <code>arr</code>.
+Write a recursive function, <code>sum(arr, n)</code>, that returns the sum of the first <code>n</code> elements of an array <code>arr</code>.
 
 </section>
 
@@ -50,10 +50,12 @@ Write a recursive function, <code>sum(arr, n)</code>, that returns the sum of th
 
 ``` yml
 tests:
-  - text: <code>sum([1], 0)</code> should equal 1.
-    testString: assert.equal(sum([1], 0), 1);
-  - text: <code>sum([2, 3, 4], 1)</code> should equal 5.
-    testString: assert.equal(sum([2, 3, 4], 1), 5);
+  - text: <code>sum([1], 0)</code> should equal 0.
+    testString: assert.equal(sum([1], 0), 0);
+  - text: <code>sum([2, 3, 4], 1)</code> should equal 2.
+    testString: assert.equal(sum([2, 3, 4], 1), 2);
+  - text: <code>sum([2, 3, 4, 5], 3)</code> should equal 9.
+    testString: assert.equal(sum([2, 3, 4, 5], 3), 9);
   - text: Your code should not rely on any kind of loops (<code>for</code> or <code>while</code> or higher order functions such as <code>forEach</code>, <code>map</code>, <code>filter</code>, or <code>reduce</code>.).
     testString: assert(!removeJSComments(code).match(/for|while|forEach|map|filter|reduce/g));
   - text: You should use recursion to solve this problem.
@@ -97,9 +99,9 @@ const removeJSComments = str => str.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, '');
 function sum(arr, n) {
   // Only change code below this line
   if(n <= 0) {
-    return arr[0];
+    return 0;
   } else {
-    return sum(arr, n - 1) + arr[n];
+    return sum(arr, n - 1) + arr[n - 1];
   }
   // Only change code above this line
 }