Count ways to reach the Nth stair using multiple 1 or 2 steps and a single step 3
Last Updated :
01 Nov, 2023
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:
- Initialize the length of the sequence to (N – 2).
- Initialize the count of 1-steps to (N – 3).
- Initialize the count of 2-steps to 0
- Initialize 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++
#include <bits/stdc++.h>
using namespace std;
int factorial( int n)
{
return (n == 1 || n == 0) ? 1 :
n * factorial(n - 1);
}
int ways( int n)
{
if (n < 3)
{
return 0;
}
int c2 = 0;
int c1 = n - 3;
int l = c1 + 1;
int s = 0;
int exp_c2 = c1 / 2;
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;
}
int main()
{
int n = 7;
int ans = ways(n);
cout << ans << endl;
return 0;
}
|
Java
class GFG {
static int factorial( int n)
{
return (n == 1 || n == 0 ) ? 1 :
n * factorial(n - 1 );
}
static int ways( int n)
{
if (n < 3 )
{
return 0 ;
}
int c2 = 0 ;
int c1 = n - 3 ;
int l = c1 + 1 ;
int s = 0 ;
int exp_c2 = c1 / 2 ;
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;
}
public static void main(String args[])
{
int n = 7 ;
int ans = ways(n);
System.out.println(ans);
}
}
|
Python3
import math
def ways(n):
if n < 3 :
return 0
c2 = 0
c1 = n - 3
l = c1 + 1
s = 0
exp_c2 = c1 / 2
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
if __name__ = = "__main__" :
N = 7
print (ways(N))
|
C#
using System;
class GFG{
static int factorial( int n)
{
return (n == 1 || n == 0) ? 1 :
n * factorial(n - 1);
}
static int ways( int n)
{
if (n < 3)
{
return 0;
}
int c2 = 0;
int c1 = n - 3;
int l = c1 + 1;
int s = 0;
int exp_c2 = c1 / 2;
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;
}
static void Main()
{
int n = 7;
int ans = ways(n);
Console.WriteLine(ans);
}
}
|
Javascript
<script>
function factorial(n)
{
return (n == 1 || n == 0) ? 1 :
n * factorial(n - 1);
}
function ways(n)
{
if (n < 3)
{
return 0;
}
let c2 = 0;
let c1 = n - 3;
let l = c1 + 1;
let s = 0;
let exp_c2 = Math.floor(c1 / 2);
while (exp_c2 >= c2)
{
let f1 = factorial(l);
let f2 = factorial(c1);
let f3 = factorial(c2);
let f4 = (f2 * f3);
s += Math.floor(f1 / f4);
c2 += 1;
c1 -= 2;
l -= 1;
}
return s;
}
let n = 7;
let ans = ways(n);
document.write(ans);
</script>
|
Performance Analysis:
- Time Complexity: As in the above approach, there is one loop to check the possible permutations for each sequence which can go up till (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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...