Count ways to reach the Nth stair using multiple 1 or 2 steps and a single step 3
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.
Last Updated :
01 Nov, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...