Given an integer N number of stairs, the task is count the number ways to reach the Nth stair by taking 1 or 2 step any number of times but taking a step of 3 exactly once.
Examples:
Input: N = 4
Output: 2
Explanation:
Since a step of 3 has to be taken compulsorily and only once. So, there are only two possible ways: (1, 3) or (3, 1)Input: N = 5
Output: 5
Explanation:
There are five possible ways to reach 5th stair: (2, 3), (3, 2), (1, 1, 3), (1, 3, 1), (3, 1, 1)
Approach: This problem can be solved using the concept of Permutations & Combinations. There is a constraint according to which 3 steps at a time have to be taken exactly once. The idea is to count the number of positions that are possible for 3 steps to be taken.
Now, the next task is to find the number of possible two-steps in the movement to Nth stair, which is (N – 3) / 2. In this way, all the possible ways will be covered if the count of two-step is incremented once at a time and for each step, all the possible combinations are calculated.
After Generalising the steps the possible combinations for each possible sequence will be
Ways = (Length of sequence)! * (Count of 2-step)!
------------------------------------------
(Count of 1-step)!
Algorithm:
- Intialize the length of the sequence to (N – 2).
- Intialize the count of 1-steps to (N – 3).
- Intialize the count of 2-steps to 0
- Intialize the possible count of 2-steps to (N-3)/2.
- Run a loop until the possible count of 2-steps is equal to the actual count of 2-steps.
- Find the possible number of ways with the help of the current length of the sequence, count of 1-steps, count of 2-steps and by above-given formulae.
- Reduce the length of the sequence by 1.
- Increase the count of 2-steps by 1
Below is the implementation of the above approach.
C++
// C++ implementation to find the number // the number of ways to reach Nth stair // by taking 1 or 2 steps at a time and // 3rd step exactly once #include <bits/stdc++.h> using namespace std; int factorial(int n) { // Single line to find factorial return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); } // Function to find // the number of ways int ways(int n) { // Base Case if (n < 3) { return 0; } // Count of 2-steps int c2 = 0; // Count of 1-steps int c1 = n - 3; // Intial length of sequence int l = c1 + 1; int s = 0; // Expected count of 2-steps int exp_c2 = c1 / 2; // Loop to find the ways for // every possible sequence while (exp_c2 >= c2) { int f1 = factorial(l); int f2 = factorial(c1); int f3 = factorial(c2); int f4 = (f2 * f3); s += f1 / f4; c2 += 1; c1 -= 2; l -= 1; } return s; } // Driver code int main() { int n = 7; int ans = ways(n); cout << ans << endl; return 0; } // This code is contributed by coder001 |
Java
// Java implementation to find the number // the number of ways to reach Nth stair // by taking 1 or 2 steps at a time and // 3rd step exactly once class GFG { static int factorial(int n) { // Single line to find factorial return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); } // Function to find // the number of ways static int ways(int n) { // Base Case if (n < 3) { return 0; } // Count of 2-steps int c2 = 0; // Count of 1-steps int c1 = n - 3; // Intial length of sequence int l = c1 + 1; int s = 0; // Expected count of 2-steps int exp_c2 = c1 / 2; // Loop to find the ways for // every possible sequence while (exp_c2 >= c2) { int f1 = factorial(l); int f2 = factorial(c1); int f3 = factorial(c2); int f4 = (f2 * f3); s += f1 / f4; c2 += 1; c1 -= 2; l -= 1; } return s; } // Driver Code public static void main(String args[]) { int n = 7; int ans = ways(n); System.out.println(ans); } } // This code is contributed by rutvik_56 |
Python3
# Python3 implementation to find the number # the number of ways to reach Nth stair # by taking 1 or 2 steps at a time and # 3rd Step exactly once import math # Function to find # the number of ways def ways(n): # Base Case if n < 3: return 0 # Count of 2-steps c2 = 0 # Count of 1-steps c1 = n-3 # Intial length of sequence l = c1 + 1 s = 0 # expected count of 2-steps exp_c2 = c1 / 2 # Loop to find the ways for # every possible sequence while exp_c2 >= c2: f1 = math.factorial(l) f2 = math.factorial(c1) f3 = math.factorial(c2) s += f1//(f2 * f3) c2 += 1 c1 -= 2 l -= 1 return s # Driver Code if __name__ == "__main__": N = 7 print(ways(N)) |
C#
// C# implementation to find the number // the number of ways to reach Nth stair // by taking 1 or 2 steps at a time and // 3rd step exactly once using System; class GFG{ static int factorial(int n) { // Single line to find factorial return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); } // Function to find // the number of ways static int ways(int n) { // Base Case if (n < 3) { return 0; } // Count of 2-steps int c2 = 0; // Count of 1-steps int c1 = n - 3; // Intial length of sequence int l = c1 + 1; int s = 0; // Expected count of 2-steps int exp_c2 = c1 / 2; // Loop to find the ways for // every possible sequence while (exp_c2 >= c2) { int f1 = factorial(l); int f2 = factorial(c1); int f3 = factorial(c2); int f4 = (f2 * f3); s += f1 / f4; c2 += 1; c1 -= 2; l -= 1; } return s; } // Driver code static void Main() { int n = 7; int ans = ways(n); Console.WriteLine(ans); } } // This code is contributed by divyeshrabadiya07 |
20
Performance Analysis:
- Time Complexity: As in the above approach, there is one loop to check the possible permutations for each sequence which can go uptil (N-3) which takes O(N) time and to find the possible combinations it will take O(N), Hence the Time Complexity will be O(N2).
- Space Complexity: As in the above approach, there is no extra space used, Hence the space complexity will be O(1).
Note: The time complexity can be improved up to O(N) by precomputing the factorials for every number till N.
