# Number of n digit stepping numbers

Given n, find count of n digit Stepping numbers. A number is called stepping number if all adjacent digits have an absolute difference of 1. 321 is a Stepping Number while 421 is not.

Examples :

```Input : 2
Output : 17
Explanation: The numbers are 10, 12, 21,
23, 32, 34, 43, 45, 54, 56, 65, 67, 76,
78, 87, 89, 98.

Input : 1
Output : 10
Explanation: the numbers are 0, 1, 2, 3,
4, 5, 6, 7, 8, 9.
```

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

A naive approach is to run a loop for all n digit numbers and check for every number if it is Stepping.

An efficient approach is to use dynamic programming.

```In dp[i][j], i denotes number of
digits and j denotes last digit.

// If there is only one digit
if (i == 1)
dp(i, j) = 1;

// If last digit is 0.
if (j == 0)
dp(i, j) = dp(i-1, j+1)

// If last digit is 9
else if (j == 9)
dp(i, j) = dp(i-1, j-1)

// If last digit is neither 0
// nor 9.
else
dp(i, j) = dp(i-1, j-1) +
dp(i-1, j+1)

Result is ∑dp(n, j) where j varies
from 1 to 9.
```

## C++

 `// CPP program to calculate the number of ` `// n digit stepping numbers. ` `#include ` `using` `namespace` `std; ` ` `  `// function that calculates the answer ` `long` `long` `answer(``int` `n) ` `{ ` `    ``// dp[i][j] stores count of i digit ` `    ``// stepping numbers ending with digit ` `    ``// j. ` `    ``int` `dp[n + 1]; ` ` `  `    ``// if n is 1 then answer will be 10. ` `    ``if` `(n == 1) ` `        ``return` `10; ` ` `  `    ``// Initialize values for count of ` `    ``// digits equal to 1. ` `    ``for` `(``int` `j = 0; j <= 9; j++) ` `        ``dp[j] = 1; ` ` `  `    ``// Compute values for count of digits ` `    ``// more than 1. ` `    ``for` `(``int` `i = 2; i <= n; i++) { ` `        ``for` `(``int` `j = 0; j <= 9; j++) { ` ` `  `            ``// If ending digit is 0 ` `            ``if` `(j == 0) ` `                ``dp[i][j] = dp[i - 1][j + 1]; ` ` `  `            ``// If ending digit is 9 ` `            ``else` `if` `(j == 9) ` `                ``dp[i][j] = dp[i - 1][j - 1]; ` ` `  `            ``// For other digits. ` `            ``else` `                ``dp[i][j] = dp[i - 1][j - 1] +  ` `                           ``dp[i - 1][j + 1]; ` `        ``} ` `    ``} ` ` `  `    ``// stores the final answer ` `    ``long` `long` `sum = 0; ` `    ``for` `(``int` `j = 1; j <= 9; j++) ` `        ``sum += dp[n][j]; ` `    ``return` `sum; ` `} ` ` `  `// driver program to test the above function ` `int` `main() ` `{ ` `    ``int` `n = 2; ` `    ``cout << answer(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to calculate the number of ` `// n digit stepping numbers. ` ` `  `class` `GFG { ` `         `  `    ``// function that calculates the answer ` `    ``static` `long` `answer(``int` `n) ` `    ``{ ` `        ``// dp[i][j] stores count of i  ` `        ``// digit stepping numbers ending  ` `        ``// with digit j. ` `        ``int` `dp[][] = ``new` `int``[n+``1``][``10``]; ` `      `  `        ``// if n is 1 then answer will be 10. ` `        ``if` `(n == ``1``) ` `            ``return` `10``; ` `      `  `        ``// Initialize values for count of ` `        ``// digits equal to 1. ` `        ``for` `(``int` `j = ``0``; j <= ``9``; j++) ` `            ``dp[``1``][j] = ``1``; ` `      `  `        ``// Compute values for count of  ` `        ``// digits more than 1. ` `        ``for` `(``int` `i = ``2``; i <= n; i++) { ` `            ``for` `(``int` `j = ``0``; j <= ``9``; j++) { ` `      `  `                ``// If ending digit is 0 ` `                ``if` `(j == ``0``) ` `                    ``dp[i][j] = dp[i - ``1``][j + ``1``]; ` `      `  `                ``// If ending digit is 9 ` `                ``else` `if` `(j == ``9``) ` `                    ``dp[i][j] = dp[i - ``1``][j - ``1``]; ` `      `  `                ``// For other digits. ` `                ``else` `                    ``dp[i][j] = dp[i - ``1``][j - ``1``] +  ` `                               ``dp[i - ``1``][j + ``1``]; ` `            ``} ` `        ``} ` `      `  `        ``// stores the final answer ` `        ``long` `sum = ``0``; ` `        ``for` `(``int` `j = ``1``; j <= ``9``; j++) ` `            ``sum += dp[n][j]; ` `        ``return` `sum; ` `    ``} ` `      `  `    ``// driver program to test the above function ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``2``; ` `        ``System.out.println(answer(n)); ` `    ``} ` `} ` ` `  `/*This code is contributed by Nikita tiwari.*/`

## Python3

 `# Python3 program to calculate  ` `# the number of n digit ` `# stepping numbers. ` ` `  `# function that calculates ` `# the answer ` `def` `answer(n): ` `     `  `    ``# dp[i][j] stores count of  ` `    ``# i digit stepping numbers  ` `    ``# ending with digit j. ` `    ``dp ``=` `[[``0` `for` `x ``in` `range``(``10``)]  ` `             ``for` `y ``in` `range``(n ``+` `1``)]; ` ` `  `    ``# if n is 1 then answer ` `    ``# will be 10. ` `    ``if` `(n ``=``=` `1``): ` `        ``return` `10``; ` `    ``for` `j ``in` `range``(``10``): ` `        ``dp[``1``][j] ``=` `1``; ` ` `  `    ``# Compute values for count  ` `    ``# of digits more than 1. ` `    ``for` `i ``in` `range``(``2``, n ``+` `1``):  ` `        ``for` `j ``in` `range``(``10``):  ` `             `  `            ``# If ending digit is 0 ` `            ``if` `(j ``=``=` `0``): ` `                ``dp[i][j] ``=` `dp[i ``-` `1``][j ``+` `1``]; ` `                 `  `            ``# If ending digit is 9 ` `            ``elif` `(j ``=``=` `9``): ` `                ``dp[i][j] ``=` `dp[i ``-` `1``][j ``-` `1``]; ` `                 `  `            ``# For other digits. ` `            ``else``: ` `                ``dp[i][j] ``=` `(dp[i ``-` `1``][j ``-` `1``] ``+`  `                            ``dp[i ``-` `1``][j ``+` `1``]); ` `                 `  `    ``# stores the final answer ` `    ``sum` `=` `0``; ` `    ``for` `j ``in` `range``(``1``, ``10``): ` `        ``sum` `=` `sum` `+` `dp[n][j]; ` `    ``return` `sum``; ` ` `  `# Driver Code ` `n ``=` `2``; ` `print``(answer(n)); ` ` `  `# This code is contributed  ` `# by mits `

## C#

 `// C# program to calculate the number of ` `// n digit stepping numbers. ` `using` `System; ` ` `  `class` `GFG { ` `         `  `    ``// function that calculates the answer ` `    ``static` `long` `answer(``int` `n) ` `    ``{ ` `         `  `        ``// dp[i][j] stores count of i  ` `        ``// digit stepping numbers ending  ` `        ``// with digit j. ` `        ``int` `[,]dp = ``new` `int``[n+1,10]; ` `     `  `        ``// if n is 1 then answer will be 10. ` `        ``if` `(n == 1) ` `            ``return` `10; ` `     `  `        ``// Initialize values for count of ` `        ``// digits equal to 1. ` `        ``for` `(``int` `j = 0; j <= 9; j++) ` `            ``dp[1,j] = 1; ` `     `  `        ``// Compute values for count of  ` `        ``// digits more than 1. ` `        ``for` `(``int` `i = 2; i <= n; i++) { ` `            ``for` `(``int` `j = 0; j <= 9; j++) { ` `     `  `                ``// If ending digit is 0 ` `                ``if` `(j == 0) ` `                    ``dp[i,j] = dp[i - 1,j + 1]; ` `     `  `                ``// If ending digit is 9 ` `                ``else` `if` `(j == 9) ` `                    ``dp[i,j] = dp[i - 1,j - 1]; ` `     `  `                ``// For other digits. ` `                ``else` `                    ``dp[i,j] = dp[i - 1,j - 1] +  ` `                               ``dp[i - 1,j + 1]; ` `            ``} ` `        ``} ` `     `  `        ``// stores the final answer ` `        ``long` `sum = 0; ` `        ``for` `(``int` `j = 1; j <= 9; j++) ` `            ``sum += dp[n,j]; ` `             `  `        ``return` `sum; ` `    ``} ` `     `  `    ``// driver program to test the above function ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 2; ` `         `  `        ``Console.WriteLine(answer(n)); ` `    ``} ` `} ` ` `  `/*This code is contributed by vt_m.*/`

## PHP

 ` `

Output :

```17
```

Time Complexity: O(n)
Auxiliary Space: O(n)Number of n digit stepping numbers | Space optimized solution

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Improved By : jit_t, Mithun Kumar