Intuition behind the base case for counting the number of steps - c++

Question

I coded the following solution with some online help. The aim is basically to find the number of ways in which a person can climb a ladder of n steps, if at each step he can climb 1 or 2 steps.
class Solution {
public:
int climbStairs(int n) {
if(n<0)
return 0;
//what is the logic used for the following return?
if(n==0)
return 1;
return climbStairs(n-1)+climbStairs(n-2);
}
};
While I am more or less aware about what exactly I am doing, I fail to understand the intuition behind returning 1 if the number of steps to be climbed is 0. Since we can take strides of length either 1 or 2, if the total number of steps to be climbed is 0, then shouldn't we return just a 0 (since no steps of length 1 or 2 can be taken)? Unfortunately, I don't get the correct answer if I return 0.
Could someone please explain what exactly is going on and the intuition behind returning 1 (instead of a 0)?

Answer 1

Instead of thinking about it in terms of how many different ways you can take steps to the top, think of it in terms of how many ways you can get to the top when you have n steps left to climb. If n == 0 you have one way to get to the top: stay where you are. That's the intuition.
The practical reason is that without that definition for n == 0, you'd need two more base cases, for n == 1 and n == 2 to get the right answer for all n > 0. And then you would be free to puzzle over what the right answer should be for n == 0.
Per request, here's why you'd need additional base cases if climbStairs(0) was 0. (Well, either you need additional base cases or you need to alter your recursion formula.) Whenever n is not a base case, climbStairs(n) is defined in terms of climbStairs(n-1) and climbStairs(n-2). If you define the n == 0 case as being 0, then, as you noticed, you don't get the right answer for n == 1 or n == 2. Therefore you'd have to define those as additional base cases. (Just fixing the n == 1 still wouldn't give the right answer for n == 2.) Once those additional base cases are established, the recursion formula will continue to give the correct answer for all n > 2.

Answer 2

There's one way to climb no stairs: do nothing. Or you can think of it mathematically: an empty sum is 0.
If you feel uncomfortable with that intuition, you can rephrase your code to eliminate the zero case:
int climbStairs(int n) {
if (n == 1) return 1; // 1
if (n == 2) return 2; // 1+1 or 2
return climbStairs(n-1) + climbStairs(n-2);
}
Incidental to your actual question, but this function is the Fibonacci sequence, and there are better ways (eg: linear or log time rather than exponential) to compute it.

Answer 3

When a person climbs the stairs, Let's say he goes from point A to point B by climbing n stairs. Now as one can easily understand there's some an vertical distance and bn horizontal distance between A and B. Where a and b are dimensions of each stair.
'Could someone please explain what exactly is going on and the intuition behind returning 1 (instead of a 0)?'
Now when there is 0 stairs there is no vertical distance between A and B. But there is 'b' horizontal distance that has to be covered and which will require 1 step.

Answer 4

If we returned 0 when n == 0 and when n < 0, then both our base cases would return 0 and we would always get 0 as our final answer, since return climbStairs(n-1)+climbStairs(n-2); would always perform 0+0. Don't worry about how a ladder with zero steps can even be "climbed" at all - it just has to do with making the program give the correct answer for higher cases.