Climbing Stairs Problem in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Climbing Stairs Recursive Code

What is the output of the following Java code that calculates the number of ways to climb 4 stairs?

DSA Java

public class ClimbingStairs {
    public static int climbStairs(int n) {
        if (n <= 2) return n;
        return climbStairs(n - 1) + climbStairs(n - 2);
    }
    public static void main(String[] args) {
        System.out.println(climbStairs(4));
    }
}

A 5

B 7

C 6

D 4

💡 Hint

Think about how many ways to reach step 4 by summing ways to reach step 3 and step 2.

The number of ways to climb 4 stairs is climbStairs(3) + climbStairs(2) = 3 + 2 = 5.

❓ Predict Output

intermediate

Output of Climbing Stairs with Memoization

What is the output of this Java code that uses memoization to calculate ways to climb 5 stairs?

DSA Java

import java.util.HashMap;
public class ClimbingStairsMemo {
    private static HashMap<Integer, Integer> memo = new HashMap<>();
    public static int climbStairs(int n) {
        if (n <= 2) return n;
        if (memo.containsKey(n)) return memo.get(n);
        int result = climbStairs(n - 1) + climbStairs(n - 2);
        memo.put(n, result);
        return result;
    }
    public static void main(String[] args) {
        System.out.println(climbStairs(5));
    }
}

A 8

B 7

C 5

D 10

💡 Hint

Use the formula ways(n) = ways(n-1) + ways(n-2) and remember ways(1)=1, ways(2)=2.

For 5 stairs, ways = ways(4) + ways(3) = 5 + 3 = 8.

🔧 Debug

advanced

Identify the Logical Error in Climbing Stairs Code

What is the output of this Java code snippet? Identify the logical error causing the output.

DSA Java

public class ClimbingStairsBug {
    public static int climbStairs(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;
        return climbStairs(n - 2) + climbStairs(n - 3);
    }
    public static void main(String[] args) {
        System.out.println(climbStairs(4));
    }
}

A 2

B 5

C StackOverflowError

D 3

💡 Hint

Check the recursive calls and base cases carefully.

The code incorrectly calls climbStairs(n-2) + climbStairs(n-3) instead of climbStairs(n-1) + climbStairs(n-2), so it returns 3 for input 4.

🧠 Conceptual

advanced

Time Complexity of Climbing Stairs Recursive Solution

What is the time complexity of the naive recursive solution for the climbing stairs problem without memoization?

A O(n)

B O(2^n)

C O(n^2)

D O(log n)

💡 Hint

Consider how many calls are made for each step.

The naive recursive solution calls itself twice for each n, leading to exponential growth in calls, O(2^n).

🚀 Application

expert

Number of Ways to Climb Stairs with Steps 1, 3, or 5

Given you can climb stairs by taking 1, 3, or 5 steps at a time, what is the number of ways to climb 6 stairs? Use the code below to find the output.

DSA Java

public class ClimbingStairsVariant {
    public static int climbStairs(int n) {
        if (n == 0) return 1;
        if (n < 0) return 0;
        return climbStairs(n - 1) + climbStairs(n - 3) + climbStairs(n - 5);
    }
    public static void main(String[] args) {
        System.out.println(climbStairs(6));
    }
}

A 9

B 10

C 8

D 13

💡 Hint

Break down the problem by subtracting 1, 3, or 5 steps and summing ways.

The function sums ways to climb n-1, n-3, and n-5 stairs. For n=6, total ways = 8.

Practice

1. What does the Climbing Stairs problem ask you to find?
Given n steps, how many distinct ways can you climb to the top if you can take 1 or 2 steps at a time?

easy

A. The maximum number of steps you can take at once

B. The minimum number of steps to reach the top

C. The total number of distinct ways to reach the top

D. The number of steps you skip

Solution

1. Step 1: Understand the problem statement

   The problem asks for the count of different ways to climb to the top using 1 or 2 steps at a time.

2. Step 2: Identify what is being counted

   We count all possible sequences of 1-step and 2-step moves that sum to n steps.

3. Final Answer:

   The total number of distinct ways to reach the top -> Option C

4. Quick Check:

   Counting ways = total distinct sequences [OK]

Hint: Count sequences of 1 or 2 steps summing to n [OK]

Common Mistakes:

• Confusing number of ways with minimum steps
• Thinking about maximum steps allowed
• Counting skipped steps instead of ways

2. Which of the following Java method signatures correctly represents a function to solve the Climbing Stairs problem for n steps?

easy

A. public int climbStairs(int n)

B. public void climbStairs(int n)

C. public int climbStairs()

D. public int climbStairs(String n)

Solution

1. Step 1: Check method return type and parameters

   The method should return an integer count and accept an integer input for steps.

2. Step 2: Validate each option

   public int climbStairs(int n) returns int and takes int n, which fits the problem. Others either have wrong return type or parameter type.

3. Final Answer:

   public int climbStairs(int n) -> Option A

4. Quick Check:

   Return int count, input int steps [OK]

Hint: Return int, input int n for steps [OK]

Common Mistakes:

• Using void return type instead of int
• Missing input parameter
• Using wrong parameter type like String

3. What is the output of the following Java code snippet?

public class Solution {
  public static int climbStairs(int n) {
    if (n <= 2) return n;
    int a = 1, b = 2, c = 0;
    for (int i = 3; i <= n; i++) {
      c = a + b;
      a = b;
      b = c;
    }
    return c;
  }
  public static void main(String[] args) {
    System.out.println(climbStairs(4));
  }
}

medium

A. 3

B. 7

C. 4

D. 5

Solution

1. Step 1: Trace the loop for n=4

   Initial a=1, b=2. Loop runs for i=3 and i=4.
   i=3: c=1+2=3, a=2, b=3
   i=4: c=2+3=5, a=3, b=5

2. Step 2: Return value after loop

   Return c=5, which is the number of ways to climb 4 steps.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Ways(4) = 5 [OK]

Hint: Use Fibonacci-like addition for steps > 2 [OK]

Common Mistakes:

• Returning b instead of c
• Off-by-one errors in loop
• Misunderstanding base cases

4. Identify the error in the following Java code for climbing stairs:

public int climbStairs(int n) {
  if (n == 1) return 1;
  int[] dp = new int[n];
  dp[0] = 1;
  dp[1] = 2;
  for (int i = 2; i <= n; i++) {
    dp[i] = dp[i-1] + dp[i-2];
  }
  return dp[n];
}

medium

A. Wrong return statement should be dp[n-1]

B. Array index out of bounds due to dp size and loop range

C. Incorrect base case for n == 1

D. Missing initialization of dp[2]

Solution

1. Step 1: Check array size and indexing

   Array dp size is n, but loop runs i from 2 to n inclusive, accessing dp[n], which is out of bounds.

2. Step 2: Identify correct loop range and return

   Loop should run i < n, and return dp[n-1] to avoid index error.

3. Final Answer:

   Array index out of bounds due to dp size and loop range -> Option B

4. Quick Check:

   Loop index exceeds array size [OK]

Hint: Array size n means max index n-1 [OK]

Common Mistakes:

• Looping to i <= n instead of i < n
• Returning dp[n] instead of dp[n-1]
• Incorrect base case handling

5. You want to find the number of ways to climb 10 steps but now you can take 1, 2, or 3 steps at a time. Which approach correctly adapts the Climbing Stairs problem?

hard

A. Use dp[i] = dp[i-1] + dp[i-2] + dp[i-3] with base dp[0]=1, dp[1]=1, dp[2]=2

B. Use dp[i] = dp[i-1] * dp[i-2] * dp[i-3] with base dp[0]=1

C. Use dp[i] = dp[i-1] + dp[i-2] only, ignoring 3 steps

D. Use recursion without memoization for all steps

Solution

1. Step 1: Understand the new step options

   Since you can take 1, 2, or 3 steps, ways to reach step i depend on previous 3 steps.

2. Step 2: Formulate dp relation and base cases

   dp[i] = dp[i-1] + dp[i-2] + dp[i-3]. Base cases: dp[0]=1 (one way to stand still), dp[1]=1, dp[2]=2.

3. Final Answer:

   Use dp[i] = dp[i-1] + dp[i-2] + dp[i-3] with base dp[0]=1, dp[1]=1, dp[2]=2 -> Option A

4. Quick Check:

   Include all step sizes in dp sum [OK]

Hint: Sum dp of last 3 steps for 1,2,3 step moves [OK]

Common Mistakes:

• Ignoring 3-step moves in dp formula
• Multiplying dp values instead of adding
• Using recursion without caching causing slow run