Recursive Methods: Testing with Jest

[nikitarevenco]

Checks

• This is not a duplicate of an existing issue (please have a look through our open issues list to make sure)
• I have thoroughly read and understand The Odin Project Contributing Guide
• Would you like to work on this issue?

Describe your suggestion

The website linked for solving recursive problems (9 problems in NodeJS path) (7 problems in Ruby path) would be better suited as an exercise in my opinion that users can fork and test using jest.

NodeJS Path

We can create 9 new exercise folders in javascript-exercises repository that will have a README.md, exercise.js, exercise.spec.js, and a solutions folder containing the solution and the solution spec, similar to the first 12 exercises.

Below is an example of how the first exercise could be added.

Exercise 13 - sumRange

README.md

Implement a recursive function that will take a number and return the sum of all numbers from 1 up to to the number passed in.

sumRange(5) // should add 1 + 2 + 3 + 4 + 5 and return 15

sumRange.js

const sumRange = function() {

};

// Do not edit below this line
module.exports = sumRange;

sumRange.spec.js

const sumRange = require('./sumRange')

describe('sumRange', () => {
  test('Sums numbers in a small range', () => {
    const range = 4;
    expect(sumRange(range)).toBe(10);
  });
  test('Sums numbers in a large range', () => {
    const range = 100;
    expect(sumRange(range)).toBe(5050);
  });
  test('Returns undefined for negative range', () => {
    const range = -3;
    expect(sumRange(range)).toBe(undefined);
  });
  test('Returns undefined for non integer range', () => {
    const range = 3.7;
    expect(sumRange(range)).toBe(undefined);
  });
});

sumRange-solution.js

function sumRange(num){
  if (!Number.isInteger(num) || num < 0) return undefined;

  if(num === 1) return 1;

  return num + sumRange(num - 1);
}

module.exports = sumRange;

Ruby path

Similarly, we can create a new folder in the Ruby path repository ruby-exercises to align with the current structure of that repository called 'ruby_recursive' and place the recursive problems there.

Path

Ruby / Rails, Node / JS

Lesson Url

https://www.theodinproject.com/lessons/ruby-recursive-methods

(Optional) Discord Name

Revenco

(Optional) Additional Comments

No response

[JoshDevHub]

I think it's a cool idea to bring this stuff in-house for a couple of reasons:

1. Similar to the exercises in foundations, our provided tests can make sure learners' solutions are correct and properly consider certain edge cases.
2. One of the solutions in the JS exercises (problem 6) is incorrect. There's also quite a bit of dated syntax.
3. We'd have full control over what the problems are, how many there are, etc.

Anyways, I'll check with the team and see if they agree.

[github-actions]

This issue is stale because it has had no activity for the last 30 days.

[JoshDevHub]

Alright revisiting this because I have some time to pursue it.

Is this still something you're interested in working on @nikitarevenco ?

[nikitarevenco]

Alright revisiting this because I have some time to pursue it.

Is this still something you're interested in working on @nikitarevenco ?

Yes, I'm happy to work on this!

[JoshDevHub]

Awesome.

Before we start, we can think some about what exercises we want to do. One of the nice things about moving this in-house is that we have full control over the problems. We could also use the same problem set for both paths.

I really like the following ones because they actually present good usecases for recursion rather than being "loop" problems we're telling the learner to think of in a recursive way.

• contains() from the JS challenges
• totalIntegers() from the JS challenges
• sumSquares() from the JS challenges
• #flatten from the Ruby challenges

It's also probably nice to have an easier one in there like a factorial problem. I probably don't want to do a Fibonacci problem because there's already a project using it that comes later.

Do you have any opinions on this? @nikitarevenco

[nikitarevenco]

Awesome.

Before we start, we can think some about what exercises we want to do. One of the nice things about moving this in-house is that we have full control over the problems. We could also use the same problem set for both paths.

I really like the following ones because they actually present good usecases for recursion rather than being "loop" problems we're telling the learner to think of in a recursive way.

• contains() from the JS challenges
• totalIntegers() from the JS challenges
• sumSquares() from the JS challenges
• #flatten from the Ruby challenges

It's also probably nice to have an easier one in there like a factorial problem. I probably don't want to do a Fibonacci problem because there's already a project using it that comes later.

Do you have any opinions on this? @nikitarevenco

Yeah, great ideas. I like the flatten challenge and having the exercises go from easier, starting with the factorial to more difficult sounds like a plan.

Some additional ideas for the exercises

• Function to find the greatest common divisor of an array of integers, eg if we input 24, 60 and 84 it will return 12.

• A classic one is the tower of hanoi, we have 3 stacks, the first stack is filled with n consecutive integers, the others are empty. The numbers can only be placed onto a stack if the number before is smaller and can only be moved one at a time.

• I think another interesting one that would be a great recursive function would be like pascal(n) which will return the nth row of the pascal's triangle in an array

• Since we already have a calculator exercise, would be interesting to make a recursive version. The task is to make a calculator(string) function that accepts a mathematical expression like (3÷9)×(3+2) and evaluates it. Learners will not be allowed to use eval

• permutations function that accepts a string and finds all of the possible permutations of every character in the string

[JoshDevHub]

I think most of those options have cool potential. I'm maybe a bit skeptical of greatest common denominator. It's definitely a famous recursion problem, but I don't think learners are going to be able to just come up with Euclid's algorithm on the spot. Maybe the README for the exercise could mention it?

Anyways let's proceed with adding all of these in (the ones in my list and the ones in yours), and we can filter out the ones that don't work when it comes to review time and we get some outside input.

So for your part, you want to add the new exercises to our javascript exercises repo. When you make your PR there, you'll want to reference this issue. I'll handle adding them to the ruby exercises repo.

[JoshDevHub]

Actually let's keep things a bit constrained to start. Maybe we can move faster after we get things rolling, but for now, let's try to keep PRs small. We'll definitely need at least a JS maintainer to look over the new exercises you add in the javascript-exercises repo, and I'd rather not hit the reviewer with a massive PR 😅

So let's just work on a PR for a factorial exercise for right now and plan to move slowly unless/until reviewers are okay with looking over more work.

Does that sound good @nikitarevenco ?

[nikitarevenco]

Actually let's keep things a bit constrained to start. Maybe we can move faster after we get things rolling, but for now, let's try to keep PRs small. We'll definitely need at least a JS maintainer to look over the new exercises you add in the javascript-exercises repo, and I'd rather not hit the reviewer with a massive PR 😅

So let's just work on a PR for a factorial exercise for right now and plan to move slowly unless/until reviewers are okay with looking over more work.

Does that sound good @nikitarevenco ?

Oh yeah, certainly. It would be better to split a single massive PR into many smaller ones.

[nikitarevenco]

Actually let's keep things a bit constrained to start. Maybe we can move faster after we get things rolling, but for now, let's try to keep PRs small. We'll definitely need at least a JS maintainer to look over the new exercises you add in the javascript-exercises repo, and I'd rather not hit the reviewer with a massive PR 😅

So let's just work on a PR for a factorial exercise for right now and plan to move slowly unless/until reviewers are okay with looking over more work.

Does that sound good @nikitarevenco ?

Take a look at the new exercise

[nikitarevenco]

How many more exercises are we going to add?

I'll give a brief explanation of the current ideas I have that are currently draft PRs and I haven't started working on.

• recursiveCalculator: Takes in a string like 4 - (3 + 9) and evaluates it. can be a lot more nested. The problem with this exercise that I've realised it is a lot more about string manipulation than it is about recursion. I've learnt quite a lot of regex while attempting to come up with a solution for it. While it is nice to be able to understand regex now, I don't think we want to have this as an exercise as the main goal of these new sets of exercises is to practice recursion.

• pascal: Get the nth row of the pascals triangle. Like pascal(3) returns [1, 3, 3, 1]. And so on, negative numbers supported.

• tower of hanoi: Classic problem with n disks and 3 stacks. We start at the first stack. we want to move our disks to the third tower, but we can only move one at a time.

Let's decide which ones we want to keep and which ones we want to work on in the future.

@MaoShizhong @JoshDevHub

[MaoShizhong]

At first glance, Tower of Hanoi seems like a classic puzzle suited for recursion. I haven't actually looked into it myself, so can't comment on whether it'd be suitable to include in the proposed exercises when you also take into account how many there would be.

Calculator, I'll push back on. Those challenges would not be suited to recursion, so doing them recursively would just be shoehorning recursion where it doesn't belong.

Can't comment at this time on Pascal in terms of suitability as an exercise to add, nor when also considering the context of the other exercises.

[MaoShizhong]

Very honestly, I think just having approx. 5-6 exercises is plenty. Especially if we're also considering porting recursive fibonacci and/or merge sort over as well.

For me, something like

1. Factorial
2. Fibonacci
3. Contains
4. Total Integers
5. Permutations
6. Tower of Hanoi

Maybe also merge sort somewhere there as well, but I've no strong feelings for whether we need or don't need it.

At a glance seems sufficient for that section. As usual, just my personal opinion taking into account the pedagogy of the whole CS section and the "flow" of the course.

[nikitarevenco]

Very honestly, I think just having approx. 5-6 exercises is plenty. Especially if we're also considering porting recursive fibonacci and/or merge sort over as well.

For me, something like

1. Factorial
2. Fibonacci
3. Contains
4. Total Integers
5. Permutations
6. Tower of Hanoi

Maybe also merge sort somewhere there as well, but I've no strong feelings for whether we need or don't need it.

At a glance seems sufficient for that section. As usual, just my personal opinion taking into account the pedagogy of the whole CS section and the "flow" of the course.

I agree with you that about 6ish should be good. I think that pascal is worth including though since I feel like its an interesting challenge, thoughts?

[MaoShizhong]

Hmmmm, partially due to unfamiliarity with a Pascal solution, I'd probably prefer including merge sort to be honest.

The sorting algo itself is quite a unique pattern compared to the other exercises, and lends itself very well to recursion. So on reflection, I think it can teach good lessons that warrant its inclusion. And I'm hesitant to go beyond 7, given the current exercises' complexities.

[MaoShizhong]

Very honestly, I think just having approx. 5-6 exercises is plenty. Especially if we're also considering porting recursive fibonacci and/or merge sort over as well.

For me, something like

1. Factorial
2. Fibonacci
3. Contains
4. Total Integers
5. Permutations
6. Tower of Hanoi

Maybe also merge sort somewhere there as well, but I've no strong feelings for whether we need or don't need it.

At a glance seems sufficient for that section. As usual, just my personal opinion taking into account the pedagogy of the whole CS section and the "flow" of the course.

@JoshDevHub thoughts on the above as the order of new exercises? Merge sort can be throw in there as a 7th (but put somewhere in the middle, I feel). Not all too familiar with the Pascal suggestion but am more familiar with merge sort and feel it would be good to have merge sort in there as well. Hence I'm leaning towards omitting the Pascal exercise due to a quantity thing.

[nikitarevenco]

Very honestly, I think just having approx. 5-6 exercises is plenty. Especially if we're also considering porting recursive fibonacci and/or merge sort over as well.
For me, something like

1. Factorial
2. Fibonacci
3. Contains
4. Total Integers
5. Permutations
6. Tower of Hanoi

Maybe also merge sort somewhere there as well, but I've no strong feelings for whether we need or don't need it.
At a glance seems sufficient for that section. As usual, just my personal opinion taking into account the pedagogy of the whole CS section and the "flow" of the course.

@JoshDevHub thoughts on the above as the order of new exercises? Merge sort can be throw in there as a 7th (but put somewhere in the middle, I feel). Not all too familiar with the Pascal suggestion but am more familiar with merge sort and feel it would be good to have merge sort in there as well. Hence I'm leaning towards omitting the Pascal exercise due to a quantity thing.

I have already the Pascal and Hanoi solutions down and I think they are very interesting. Once I have internet on my computer I will publish them as PRs. I think the solutions are very interesting for both.

[nikitarevenco]

So that makes the following new exercises:

• Factorial
• Contains
• Total Integers
• Permutations
• Pascal
• Hanoi

And the two ported from existing project:

• Merge Sort
• Fibonacci

[nikitarevenco]

@MaoShizhong @JoshDevHub at some point let's decide the order in which we want the exercises to be in. Obviously it makes sense for it to go easiest to hardest (it's hard to measure exactly - of course it'll vary for everyone. But having some kind of standard is better in my opinion than having none):

1. Factorial (easiest)
2. Total Integers
3. Permutations
4. Contains
5. Merge Sort
6. Fibonacci
7. Pascal
8. Tower of Hanoi (hardest)

[JoshDevHub]

Merge sort and Fibonacci will both need some extra consideration. I think it's probably better if they're moved to the exercises, but it will involve some extra work/discussion because they're already a part of an existing "project" lesson.

That project would have to be removed from the curriculum, effectively "orphaning" all existing submissions to it. Maybe the team doesn't mind, but I don't know for sure as we haven't discussed that yet.

Just letting you know of potential issues around those two problems.