Number of ways to reach Nth floor by taking at-most K leaps

Given N number of stairs. Also given the number of steps that one can cover at most in one leap (K). The task is to find the number of possible ways one (only consider combinations) can climb to the top of the building in K leaps or less from the ground floor.

Examples:

Input: N = 5, K = 3
Output: 5
To reach stair no-5 we can choose following combination of leaps:
1 1 1 1 1
1 1 1 2
1 2 2
1 1 3
2 3

Input: N = 29, K = 5
Output: 603

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Let combo[i] be the number of ways to reach the i-th floor. Hence the number of ways to reach combo[i] from combo[j] by taking a leap of i-j will be combo[i] += combo[j]. So iterate for all possible leaps, and for each possible leaps keep adding the possible combinations to the combo array. The final answer will be stored in combo[N].

Below is the implementation of the above approach.

C++

 `// C++ program to reach N-th stair  ` `// by taking a maximum of K leap  ` `#include   ` ` `  `using` `namespace` `std;  ` ` `  `int` `solve(``int` `N, ``int` `K)  ` `{  ` ` `  `    ``// elements of combo[] stores the no of  ` `    ``// possible ways to reach it by all  ` `    ``// combinations of k leaps or less  ` ` `  `    ``int` `combo[N + 1] = { 0 };  ` ` `  `    ``// assuming leap 0 exist and assigning  ` `    ``// its value to 1 for calculation  ` `    ``combo[0] = 1;  ` ` `  `    ``// loop to iterate over all  ` `    ``// possible leaps upto k;  ` `    ``for` `(``int` `i = 1; i <= K; i++) {  ` ` `  `        ``// in this loop we count all possible  ` `        ``// leaps to reach the jth stair with  ` `        ``// the help of ith leap or less  ` `        ``for` `(``int` `j = 0; j <= N; j++) {  ` ` `  `            ``// if the leap is not more than the i-j  ` `            ``if` `(j >= i) {  ` ` `  `                ``// calculate the value and  ` `                ``// store in combo[j]  ` `                ``// to reuse it for next leap  ` `                ``// calculation for the jth stair  ` `                ``combo[j] += combo[j - i];  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// returns the no of possible number  ` `    ``// of leaps to reach the top of  ` `    ``// building of n stairs  ` `    ``return` `combo[N];  ` `}  ` ` `  `// Driver Code  ` `int` `main()  ` `{  ` `    ``// N i the no of total stairs  ` `    ``// K is the value of the greatest leap  ` `    ``int` `N = 29;  ` `    ``int` `K = 5;  ` ` `  `    ``cout << solve(N, K);  ` ` `  `    ``solve(N, K);  ` `    ``return` `0;  ` `}  `

Java

 `// Java program to reach N-th  ` `// stair by taking a maximum  ` `// of K leap ` `class` `GFG ` `{ ` `static` `int` `solve(``int` `N, ``int` `K) ` `{ ` ` `  `    ``// elements of combo[] stores  ` `    ``// the no. of possible ways  ` `    ``// to reach it by all combinations ` `    ``// of k leaps or less ` `    ``int``[] combo; ` `    ``combo = ``new` `int``[``50``]; ` ` `  `    ``// assuming leap 0 exist  ` `    ``// and assigning its value ` `    ``// to 1 for calculation ` `    ``combo[``0``] = ``1``; ` ` `  `    ``// loop to iterate over all ` `    ``// possible leaps upto k; ` `    ``for` `(``int` `i = ``1``; i <= K; i++)  ` `    ``{ ` ` `  `        ``// in this loop we count all ` `        ``// possible leaps to reach ` `        ``// the jth stair with the  ` `        ``// help of ith leap or less ` `        ``for` `(``int` `j = ``0``; j <= N; j++)  ` `        ``{ ` ` `  `            ``// if the leap is not ` `            ``// more than the i-j ` `            ``if` `(j >= i) ` `            ``{ ` ` `  `                ``// calculate the value and  ` `                ``// store in combo[j] to  ` `                ``// reuse it for next leap ` `                ``// calculation for the  ` `                ``// jth stair ` `                ``combo[j] += combo[j - i]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// returns the no of possible  ` `    ``// number of leaps to reach  ` `    ``// the top of building of  ` `    ``// n stairs ` `    ``return` `combo[N]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``// N i the no of total stairs ` `    ``// K is the value of the  ` `    ``// greatest leap ` `    ``int` `N = ``29``; ` `    ``int` `K = ``5``; ` ` `  `    ``System.out.println(solve(N, K)); ` ` `  `    ``solve(N, K); ` `} ` `} ` ` `  `// This code is contributed  ` `// by ankita_saini `

Python 3

 `# Python3 program to reach N-th stair ` `# by taking a maximum of K leap  ` ` `  `def` `solve(N, K) : ` ` `  `    ``# elements of combo[] stores the no of   ` `    ``# possible ways to reach it by all   ` `    ``# combinations of k leaps or less  ` `    ``combo ``=` `[``0``] ``*` `(N ``+` `1``) ` ` `  `    ``# assuming leap 0 exist and assigning   ` `    ``# its value to 1 for calculation  ` `    ``combo[``0``] ``=` `1` ` `  `    ``# loop to iterate over all   ` `    ``# possible leaps upto k;  ` `    ``for` `i ``in` `range``(``1``, K ``+` `1``) : ` ` `  `        ``#  in this loop we count all possible   ` `        ``# leaps to reach the jth stair with   ` `        ``# the help of ith leap or less   ` `        ``for` `j ``in` `range``(``0``, N ``+` `1``) : ` ` `  `            ``# if the leap is not more than the i-j   ` `            ``if` `j >``=` `i : ` ` `  `                ``# calculate the value and   ` `                ``# store in combo[j]   ` `                ``# to reuse it for next leap   ` `                ``# calculation for the jth stair  ` `                ``combo[j] ``+``=` `combo[j ``-` `i] ` ` `  ` `  `    ``# returns the no of possible number   ` `    ``# of leaps to reach the top of   ` `    ``# building of n stairs   ` `    ``return` `combo[N] ` `   `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``# N i the no of total stairs   ` `    ``# K is the value of the greatest leap  ` `    ``N, K ``=` `29``, ``5` ` `  `    ``print``(solve(N, K)) ` ` `  `# This code is contributed by ANKITRAI1 `

C#

 `// C# program to reach N-th  ` `// stair by taking a maximum  ` `// of K leap ` `using` `System; ` ` `  `class` `GFG ` `{ ` `static` `int` `solve(``int` `N, ``int` `K) ` `{ ` ` `  `    ``// elements of combo[] stores  ` `    ``// the no. of possible ways  ` `    ``// to reach it by all combinations ` `    ``// of k leaps or less ` `    ``int``[] combo; ` `    ``combo = ``new` `int``[50]; ` ` `  `    ``// assuming leap 0 exist  ` `    ``// and assigning its value ` `    ``// to 1 for calculation ` `    ``combo[0] = 1; ` ` `  `    ``// loop to iterate over all ` `    ``// possible leaps upto k; ` `    ``for` `(``int` `i = 1; i <= K; i++)  ` `    ``{ ` ` `  `        ``// in this loop we count all ` `        ``// possible leaps to reach ` `        ``// the jth stair with the  ` `        ``// help of ith leap or less ` `        ``for` `(``int` `j = 0; j <= N; j++)  ` `        ``{ ` ` `  `            ``// if the leap is not ` `            ``// more than the i-j ` `            ``if` `(j >= i) ` `            ``{ ` ` `  `                ``// calculate the value and  ` `                ``// store in combo[j] to  ` `                ``// reuse it for next leap ` `                ``// calculation for the  ` `                ``// jth stair ` `                ``combo[j] += combo[j - i]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// returns the no of possible  ` `    ``// number of leaps to reach  ` `    ``// the top of building of  ` `    ``// n stairs ` `    ``return` `combo[N]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``// N i the no of total stairs ` `    ``// K is the value of the  ` `    ``// greatest leap ` `    ``int` `N = 29; ` `    ``int` `K = 5; ` ` `  `    ``Console.WriteLine(solve(N, K)); ` `    ``solve(N, K); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Akanksha Rai(Abby_akku) `

PHP

 `= ``\$i``) ` `            ``{  ` ` `  `                ``// calculate the value and  ` `                ``// store in combo[j]  ` `                ``// to reuse it for next leap  ` `                ``// calculation for the jth stair  ` `                ``\$combo``[``\$j``] += ``\$combo``[``\$j` `- ``\$i``];  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// returns the no of possible  ` `    ``// number of leaps to reach  ` `    ``// the top of building of n stairs  ` `    ``return` `\$combo``[``\$N``];  ` `}  ` ` `  `// Driver Code  ` ` `  `// N i the no of total stairs  ` `// K is the value of the greatest leap  ` `\$N` `= 29;  ` `\$K` `= 5;  ` ` `  `echo` `solve(``\$N``, ``\$K``);  ` ` `  `solve(``\$N``, ``\$K``);  ` ` `  `// This code is contributed  ` `// by Akanksha Rai(Abby_akku)  ` `?> `

Output:

```603
```

Time Complexity: O(N*K)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up

Do your best to show the world what you are capable of

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.