JavaScript recursive function to find the sum of array elements that equals to the given target number n

Question

JavaScript recursive function to find the sum of array elements that equals to the given target number n

Currently, I am making my way through the Javascript course available on freecodecamp. However, in one of the lessons that cover recursive functions, I have hit a bit of a roadblock.

The code snippet that is causing me confusion is as follows:

function sum(arr, n) {
        
    if(n<=0) {
        return 0;
    } else {
        return sum(arr, n-1) + arr[n-1];
    }
}

sum([10,20,30,40], 3);

In particular, I find myself struggling to grasp this line of code:

arr[n-1];

So, wouldn't the return statement essentially translate to sum([10,20,30,40], 3-1) + arr[3-1] resulting in 30+30 = 60?

If anyone could offer assistance on this matter, it would be highly appreciated. I welcome any guidance or direction to further resources for better understanding.

Thank you!

javascript function recursion

Answer 1

Answer №1

To make the original code more intuitive, let's start by placing arr[n-1] first. This will allow us to progressively expand each call to sum() towards the right.

Before we begin, let's outline what each call to sum(arr, n) will return for different values of n:

If n > 0 => arr[n-1] + sum(arr, n-1)
If n == 0 => 0

For n = 3 => arr[2] + sum(arr, 2)
For n = 2 => arr[1] + sum(arr, 1)
For n = 1 => arr[0] + sum(arr, 0)
For n = 0 => 0

Now, let's break down the process step by step:

sum(arr, 3)
== arr[2] + sum(arr, 2) // expanding sum(arr,2) with n = 2
== arr[2] + arr[1] + sum(arr, 1)  // expanding sum(arr,1)
== arr[2] + arr[1] + arr[0] + sum(arr,0) // expanding sum(arr,0)
== arr[2] + arr[1] + arr[0] + 0
== 30 + 20 + 10 + 0

Answer 2

To make the original code more intuitive, let's start by placing arr[n-1] first. This will allow us to progressively expand each call to sum() towards the right.

Before we begin, let's outline what each call to sum(arr, n) will return for different values of n:

If n > 0 => arr[n-1] + sum(arr, n-1)
If n == 0 => 0

For n = 3 => arr[2] + sum(arr, 2)
For n = 2 => arr[1] + sum(arr, 1)
For n = 1 => arr[0] + sum(arr, 0)
For n = 0 => 0

Now, let's break down the process step by step:

sum(arr, 3)
== arr[2] + sum(arr, 2) // expanding sum(arr,2) with n = 2
== arr[2] + arr[1] + sum(arr, 1)  // expanding sum(arr,1)
== arr[2] + arr[1] + arr[0] + sum(arr,0) // expanding sum(arr,0)
== arr[2] + arr[1] + arr[0] + 0
== 30 + 20 + 10 + 0

Answer 3

Answer №2

Let's explore a test case:

function sum(arr, n) {
    console.log(`running sum(arr, ${n})`);
    if(n<=0) {
        console.log(`returning 0`);
        return 0;
    } else {
        console.log(`calculating [sum(arr, ${n-1}) + ${arr[n-1]}]`);
        let s = sum(arr, n-1);;
        console.log(`returning [sum(arr, ${n-1}) + ${arr[n-1]}] = [${s} + ${arr[n-1]}]`);
        return s + arr[n-1];
    }
}

sum([10,20,30,40], 3);

The result will show:

running sum(arr, 3)

calculating [sum(arr, 2) + 30]

running sum(arr, 2)

calculating [sum(arr, 1) + 20]

running sum(arr, 1)

calculating [sum(arr, 0) + 10]

running sum(arr, 0)

returning 0

returning [sum(arr, 0) + 10] = [0 + 10]

returning [sum(arr, 1) + 20] = [10 + 20]

returning [sum(arr, 2) + 30] = [30 + 30]

Two other timeless examples of basic recursive functions are factorial and fibonacci, as they inherently rely on recursion. Furthermore, you can also approach multiplication in a recursive manner, thinking of it as a repeated addition of one number.

If you're looking to implement these functions in code, here's a clue for the last example:

5 * 10 can be seen as 5 + 5 * 9, which is equivalent to 5 + 5 + 5 * 8, and so forth.

Answer 4

Let's explore a test case:

function sum(arr, n) {
    console.log(`running sum(arr, ${n})`);
    if(n<=0) {
        console.log(`returning 0`);
        return 0;
    } else {
        console.log(`calculating [sum(arr, ${n-1}) + ${arr[n-1]}]`);
        let s = sum(arr, n-1);;
        console.log(`returning [sum(arr, ${n-1}) + ${arr[n-1]}] = [${s} + ${arr[n-1]}]`);
        return s + arr[n-1];
    }
}

sum([10,20,30,40], 3);

The result will show:

running sum(arr, 3)

calculating [sum(arr, 2) + 30]

running sum(arr, 2)

calculating [sum(arr, 1) + 20]

running sum(arr, 1)

calculating [sum(arr, 0) + 10]

running sum(arr, 0)

returning 0

returning [sum(arr, 0) + 10] = [0 + 10]

returning [sum(arr, 1) + 20] = [10 + 20]

returning [sum(arr, 2) + 30] = [30 + 30]

Two other timeless examples of basic recursive functions are factorial and fibonacci, as they inherently rely on recursion. Furthermore, you can also approach multiplication in a recursive manner, thinking of it as a repeated addition of one number.

If you're looking to implement these functions in code, here's a clue for the last example:

5 * 10 can be seen as 5 + 5 * 9, which is equivalent to 5 + 5 + 5 * 8, and so forth.

Answer 5

Answer №3

When you pass [10, 20, 30, 40] and 3-1 as arguments to the sum function, it triggers another call to the sum function. Consider the implications of this recursive action.

Answer 6

When you pass [10, 20, 30, 40] and 3-1 as arguments to the sum function, it triggers another call to the sum function. Consider the implications of this recursive action.

Answer 7

Answer №4

When dealing with recursive functions, they usually work with an immediately accessible value and another value obtained by calling themselves until a base case is met.

In this scenario, the accessible parameter is a number from an array and the operation simply involves addition. The function reaches the base case when its parameters satisfy the conditions set in the code.

To grasp how the final result is achieved, consider the various iterations that occur:

During the first iteration, sum([10,20,30,40], 3)

The condition in the code is not met because 3 (n) is greater than 0, triggering execution of the else branch's code.

We now have sum([10,20,30,40], 2) + arr[2]. While we do not yet know the outcome of the recursive call, we have the value of the number at the third position in the array, which is 30 (arrays typically start from 0).

Moving onto the second iteration, sum([10,20,30,40], 2)

Once again, this does not satisfy the base case yet, leading to:

sum([10,20,30,40], 2-1) + arr[2-1] ->

sum([10,20,30,40], 1) + arr[1] ->

sum([10,20,30,40], 1) + 20

Continuing to the third iteration, sum([10,20,30,40], 1)

At this point, we have partial results of 30 and 20. These values, along with other iteration outcomes, are all added together due to the nature of the code within the else branch—simple addition.

sum([10,20,30,40], 1-1) + arr[1-1] ->

sum([10,20,30,40], 0) + arr[0] ->

sum([10,20,30,40], 0) + 10

Another partial result of 10 has been accounted for.

Lastly, the fourth and final iteration arrives, sum([10,20,30,40], 0)

Finally reaching the base case, the code executes the logic within the if branch, halting further recursion as there are no additional calls within the code. The result of sum([10,20,30,40], 0) equates to 0.

Looking back on the iterations:

• Third iteration: sum([10,20,30,40], 0) + 10 resolved to 10.

• Second iteration: sum([10,20,30,40], 1) + 20 yielded 30.

• First and initial call to the function: sum([10,20,30,40], 2) + 30 resulted in 60.

While recursive functions may seem intricate initially, grasping the concept of accumulating partial results until reaching the base case will make it easier. Patience is key to understanding this concept.

Answer 8

When dealing with recursive functions, they usually work with an immediately accessible value and another value obtained by calling themselves until a base case is met.

In this scenario, the accessible parameter is a number from an array and the operation simply involves addition. The function reaches the base case when its parameters satisfy the conditions set in the code.

To grasp how the final result is achieved, consider the various iterations that occur:

During the first iteration, sum([10,20,30,40], 3)

The condition in the code is not met because 3 (n) is greater than 0, triggering execution of the else branch's code.

We now have sum([10,20,30,40], 2) + arr[2]. While we do not yet know the outcome of the recursive call, we have the value of the number at the third position in the array, which is 30 (arrays typically start from 0).

Moving onto the second iteration, sum([10,20,30,40], 2)

Once again, this does not satisfy the base case yet, leading to:

sum([10,20,30,40], 2-1) + arr[2-1] ->

sum([10,20,30,40], 1) + arr[1] ->

sum([10,20,30,40], 1) + 20

Continuing to the third iteration, sum([10,20,30,40], 1)

At this point, we have partial results of 30 and 20. These values, along with other iteration outcomes, are all added together due to the nature of the code within the else branch—simple addition.

sum([10,20,30,40], 1-1) + arr[1-1] ->

sum([10,20,30,40], 0) + arr[0] ->

sum([10,20,30,40], 0) + 10

Another partial result of 10 has been accounted for.

Lastly, the fourth and final iteration arrives, sum([10,20,30,40], 0)

Finally reaching the base case, the code executes the logic within the if branch, halting further recursion as there are no additional calls within the code. The result of sum([10,20,30,40], 0) equates to 0.

Looking back on the iterations:

• Third iteration: sum([10,20,30,40], 0) + 10 resolved to 10.

• Second iteration: sum([10,20,30,40], 1) + 20 yielded 30.

• First and initial call to the function: sum([10,20,30,40], 2) + 30 resulted in 60.

While recursive functions may seem intricate initially, grasping the concept of accumulating partial results until reaching the base case will make it easier. Patience is key to understanding this concept.

JavaScript recursive function to find the sum of array elements that equals to the given target number n

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Incorporate a pause into a JavaScript function

The SVG image does not display in browsers other than Internet Explorer (IE)

The Uglify task in Grunt/NPM is having trouble with this particular line of JavaScript code

Refresh the page without reloading to update the value of a dynamically created object

Customizing settings for reinitializing the Ajax range slider in Foundation 5

When a user clicks on JavaScript, it will return true if clicked and false if

Guidelines for creating animation for a single point in SVG Polygon

Transforming a React, Redux, and MUI Menu into an Electron Application

The Vuetify rating system seems to be having trouble displaying

Tips for deactivating dropdown values based on the selection of another dropdown

Implementing a background animation on click in React

Enhance a query parameter in a Node.js application

Using React.js to add MongoDB documents into the database

Utilize an Express.js controller to retrieve information from an API service and display it on the view

JSON Nesting with Ember.js and Rails

Harness the Power of JSON in your JavaScript Applications

Exploring AngularJS's capabilities with asynchronous tasks

How to retrieve a specific item from an array in JavaScript

"HTML and JavaScript: The search functionality fails when trying to search for a string that is sourced from an array

Struggling with updating a user in MongoDB using findOneAndUpdate and encountering a frustrating internal server error 500?