# Number of decimal numbers of length k, that are strict monotone

We call a decimal number strict monotone if: D[i-1] < D[i], 0 < i < |D|

Write a program which takes positive number n on input and returns number of decimal numbers of length n that are strict monotone. Number can’t start with 0. Examples :

```Input : 2
Output : 36
Numbers are 12, 13, ... 19, 23
24, ... 29, .... 89.

Input : 3
Output : 84```

Explanations of this problem follows the same rules as applied on: Number of decimal numbers of length k, that are monotone The only difference is that now we cannot take duplicates, so previously computed values are the one on the left and left top diagonal.

## C++

 `// CPP program to count numbers of k``// digits that are strictly monotone.``#include ``#include ` `int` `static` `const` `DP_s = 9;` `int` `getNumStrictMonotone(``int` `len)``{``    ``// DP[i][j] is going to store monotone``    ``// numbers of length i+1 considering``    ``// j+1 digits (1, 2, 3, ..9)``    ``int` `DP[len][DP_s];``    ``memset``(DP, 0, ``sizeof``(DP));`` ` `    ``// Unit length numbers``    ``for` `(``int` `i = 0; i < DP_s; ++i) ``        ``DP[0][i] = i + 1;    ` `    ``// Building dp[] in bottom up``    ``for` `(``int` `i = 1; i < len; ++i) ``        ``for` `(``int` `j = 1; j < DP_s; ++j) ``            ``DP[i][j] = DP[i - 1][j - 1] + DP[i][j - 1];        ``    ` `    ``return` `DP[len - 1][DP_s - 1];``}` `// Driver code``int` `main()``{``    ``std::cout << getNumStrictMonotone(2); ``    ``return` `0;``}`

## Java

 `// Java program to count numbers of k``// digits that are strictly monotone.``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``static` `int` `DP_s = ``9``;``    ` `    ``static` `int` `getNumStrictMonotone(``int` `len) ``    ``{``        ``// DP[i][j] is going to store monotone``        ``// numbers of length i+1 considering``        ``// j+1 digits (1, 2, 3, ..9)``        ``int``[][] DP = ``new` `int``[len][DP_s];``    ` `        ``// Unit length numbers``        ``for` `(``int` `i = ``0``; i < DP_s; ++i)``        ``DP[``0``][i] = i + ``1``;``    ` `        ``// Building dp[] in bottom up``        ``for` `(``int` `i = ``1``; i < len; ++i)``             ``for` `(``int` `j = ``1``; j < DP_s; ++j)``                ``DP[i][j] = DP[i - ``1``][j - ``1``] ``                             ``+ DP[i][j - ``1``];``    ` `        ``return` `DP[len - ``1``][DP_s - ``1``];``    ``}``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``int` `n = ``2``;``        ``System.out.println(getNumStrictMonotone(n));``    ``}``}` `// This code is contributed by Gitanjali.`

## Python3

 `# Python3 program to count numbers of k``# digits that are strictly monotone.` `DP_s ``=` `9` `def` `getNumStrictMonotone(ln):``    ` `    ``# DP[i][j] is going to store monotone``    ``# numbers of length i+1 considering``    ``# j+1 digits (1, 2, 3, ..9)``    ``DP ``=` `[[``0``] ``*` `DP_s ``for` `_ ``in` `range``(ln)]` `    ``# Unit length numbers``    ``for` `i ``in` `range``(DP_s):``        ``DP[``0``][i] ``=` `i ``+` `1` `    ``# Building dp[] in bottom up``    ``for` `i ``in` `range``(``1``, ln):``        ` `        ``for` `j ``in` `range``(``1``, DP_s):``            ` `            ``DP[i][j] ``=` `DP[i ``-` `1``][j ``-` `1``] ``+` `DP[i][j ``-` `1``]     ``    ` `    ``return` `DP[ln ``-` `1``][DP_s ``-` `1``]` `# Driver code``print``(getNumStrictMonotone(``2``))`  `# This code is contributed by Ansu Kumari.`

## C#

 `// C# program to count numbers of k``// digits that are strictly monotone.``using` `System;` `class` `GFG {` `    ``static` `int` `DP_s = 9;``    ` `    ``static` `int` `getNumStrictMonotone(``int` `len) ``    ``{``        ``// DP[i][j] is going to store monotone``        ``// numbers of length i+1 considering``        ``// j+1 digits (1, 2, 3, ..9)``        ``int``[,] DP = ``new` `int``[len,DP_s];``    ` `        ``// Unit length numbers``        ``for` `(``int` `i = 0; i < DP_s; ++i)``        ``DP[0,i] = i + 1;``    ` `        ``// Building dp[] in bottom up``        ``for` `(``int` `i = 1; i < len; ++i)``            ``for` `(``int` `j = 1; j < DP_s; ++j)``                ``DP[i,j] = DP[i - 1,j - 1] ``                            ``+ DP[i,j - 1];``    ` `        ``return` `DP[len - 1,DP_s - 1];``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main() ``    ``{``        ``int` `n = 2;``        ``Console.WriteLine(getNumStrictMonotone(n));``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output
`36`

Time Complexity: O(k) where k is the given length
Auxiliary Space: O(k)

Previous
Next