 Open in App
Not now

# Counting numbers of n digits that are monotone

• Difficulty Level : Medium
• Last Updated : 29 Nov, 2022

Call decimal number a monotone if: . Write a program that takes the positive number n on input and returns a number of decimal numbers of length n that are monotone. Numbers can’t start with 0.

Examples :

Input : 1
Output : 9
Numbers are 1, 2, 3, ... 9

Input : 2
Output : 45
Numbers are 11, 12, 13, .... 22, 23
...29, 33, 34, ... 39.
Count is 9 + 8 + 7 ... + 1 = 45

Explanation: Let’s start by example of monotone numbers: All those numbers are monotone as each digit on higher place is than the one before it. What are the monotone numbers are of length 1 and digits 1 or 2? It is question to ask yourself at the very beginning. We can see that possible numbers are: That was easy, now lets expand the question to digits 1, 2 and 3: Now different question, what are the different monotone numbers consisting of only 1 and length 3 are there? Lets try now draw this very simple observation in 2 dimensional array for number of length 3, where first column is the length of string and first row is possible digits: Let’s try to fill 3rd row 3rd column(number of monotone numbers consisting from numbers 1 or 2 with length 2). This should be: If we will look closer we already have subsets of this set i.e: – Monotone numbers that has length 2 and consist of 1 or 2 – Monotone numbers of length 2 and consisting of number 2 We just need to add previous values to get the longer one. Final matrix should look like this: ## C++

 // CPP program to count numbers of n digits // that are  monotone. #include  #include    // Considering all possible digits as {1, 2, 3, ..9} int static const DP_s = 9;   int getNumMonotone(int len) {     // DP[i][j] is going to store monotone numbers of length     // i+1 considering j+1 digits.     int DP[len][DP_s];     memset(DP, 0, sizeof(DP));     // Unit length numbers     for (int i = 0; i < DP_s; ++i)         DP[i] = i + 1;     // Single digit numbers     for (int i = 0; i < len; ++i)         DP[i] = 1;     // Filling rest of the entries in bottom     // up manner.     for (int i = 1; i < len; ++i)         for (int j = 1; j < DP_s; ++j)             DP[i][j] = DP[i - 1][j] + DP[i][j - 1];     return DP[len - 1][DP_s - 1]; }   // Driver code. int main() {     std::cout << getNumMonotone(10);     return 0; }   // This code is contributed by Sania Kumari Gupta

## C

 // C program to count numbers of n digits // that are monotone. #include  #include    // Considering all possible digits as // {1, 2, 3, ..9} int static const DP_s = 9;   int getNumMonotone(int len) {       // DP[i][j] is going to store monotone numbers of length     // i+1 considering j+1 digits.     int DP[len][DP_s];     memset(DP, 0, sizeof(DP));       // Unit length numbers     for (int i = 0; i < DP_s; ++i)         DP[i] = i + 1;       // Single digit numbers     for (int i = 0; i < len; ++i)         DP[i] = 1;       // Filling rest of the entries in bottom up manner.     for (int i = 1; i < len; ++i)         for (int j = 1; j < DP_s; ++j)             DP[i][j] = DP[i - 1][j] + DP[i][j - 1];       return DP[len - 1][DP_s - 1]; }   // Driver code. int main() {     printf("%d", getNumMonotone(10));     return 0; }   // This code is contributed by Sania Kumari Gupta

## Java

 // Java program to count numbers  // of n digits that are monotone.   class GFG  {     // Considering all possible      // digits as {1, 2, 3, ..9}     static final int DP_s = 9;           static int getNumMonotone(int len)     {               // DP[i][j] is going to store          // monotone numbers of length          // i+1 considering j+1 digits.         int[][] DP = new int[len][DP_s];               // Unit length numbers         for (int i = 0; i < DP_s; ++i)             DP[i] = i + 1;               // Single digit numbers         for (int i = 0; i < len; ++i)             DP[i] = 1;               // Filling rest of the entries          // in bottom up manner.         for (int i = 1; i < len; ++i)             for (int j = 1; j < DP_s; ++j)                 DP[i][j] = DP[i - 1][j]                             + DP[i][j - 1];               return DP[len - 1][DP_s - 1];     }           // Driver code.     public static void main (String[] args)      {         System.out.println(getNumMonotone(10));     } }   // This code is contributed by Ansu Kumari.

## Python3

 # Python3 program to count numbers of n  # digits that are monotone.   # Considering all possible digits as # {1, 2, 3, ..9} DP_s = 9   def getNumMonotone(ln):       # DP[i][j] is going to store monotone     # numbers of length i+1 considering     # j+1 digits.     DP = [*DP_s for i in range(ln)]       # Unit length numbers     for i in range(DP_s):         DP[i] = i + 1       # Single digit numbers     for i in range(ln):         DP[i] = 1       # Filling rest of the entries       # in bottom up manner.     for i in range(1, ln):           for j in range(1, DP_s):             DP[i][j] = DP[i - 1][j] + DP[i][j - 1]       return DP[ln - 1][DP_s - 1]     # Driver code print(getNumMonotone(10))     # This code is contributed by Ansu Kumari

## C#

 // C# program to count numbers  // of n digits that are monotone. using System;   class GFG  {     // Considering all possible      // digits as {1, 2, 3, ..9}     static int DP_s = 9;           static int getNumMonotone(int len)     {               // DP[i][j] is going to store          // monotone numbers of length          // i+1 considering j+1 digits.         int[,] DP = new int[len,DP_s];               // Unit length numbers         for (int i = 0; i < DP_s; ++i)             DP[0,i] = i + 1;               // Single digit numbers         for (int i = 0; i < len; ++i)             DP[i,0] = 1;               // Filling rest of the entries          // in bottom up manner.         for (int i = 1; i < len; ++i)             for (int j = 1; j < DP_s; ++j)                 DP[i,j] = DP[i - 1,j]                          + DP[i,j - 1];               return DP[len - 1,DP_s - 1];     }           // Driver code.     public static void Main ()      {         Console.WriteLine(getNumMonotone(10));     } }   // This code is contributed by vt_m.

## PHP

 

## Javascript

 

Output

43758

Time complexity: O(n*DP_s)
Auxiliary space: O(n*DP_s)

My Personal Notes arrow_drop_up
Related Articles