Given an integer n > 0, which denotes the number of digits, the task to find total number of n-digit positive integers which are non-decreasing in nature.

A non-decreasing integer is a one in which all the digits from left to right are in non-decreasing form. ex: 1234, 1135, ..etc.

**Note :**Leading zeros also count in non-decreasing integers such as 0000, 0001, 0023, etc are also non-decreasing integers of 4-digits.

**Examples :**

Input : n = 1 Output : 10 Numbers are 0, 1, 2, ...9. Input : n = 2 Output : 55 Input : n = 4 Output : 715

**Naive Approach :** We generate all possible n-digit numbers and then for each number we check whether it is non-decreasing or not.

Time Complexity : (n*10^n), where 10^n is for generating all possible n-digits number and n is for checking whether a particular number is non-decreasing or not.

**Dynamic Programming : **

If we fill digits one by one from left to right, following conditions hold.

- If current last digit is 9, we can fill only 9s in remaining places. So only one solution is possible if current last digit is 9.
- If current last digit is less than 9, then we can recursively compute count using following formula.
a[i][j] = a[i-1][j] + a[i][j + 1] For every digit j smaller than 9. We consider previous length count and count to be increased by all greater digits.

We build a matrix a[][] where** a[i][j]** = count of all valid i-digit non-decreasing integers with j or greater than j as the leading digit. The solution is based on below observations. We fill this matrix column-wise, first calculating a[1][9] then using this value to compute a[2][8] and so on.

At any instant if we wish to calculate a[i][j] means number of i-digits non-decreasing integers with leading digit as j or digit greater than j, we should add up a[i-1][j] (number of i-1 digit integers which should start from j or greater digit, because in this case if we place j as its left most digit then our number will be i-digit non-decreasing number) and a[i][j+1] (number of i-digit integers which should start with digit equals to greater than j+1). So, **a[i][j] = a[i-1][j] + a[i][j+1]**.

## C/C++

`// C++ program for counting n digit numbers with ` `// non decreasing digits ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns count of non- decreasing numbers with ` `// n digits. ` `int` `nonDecNums(` `int` `n) ` `{ ` ` ` `/* a[i][j] = count of all possible number ` ` ` `with i digits having leading digit as j */` ` ` `int` `a[n + 1][10]; ` ` ` ` ` `// Initialization of all 0-digit number ` ` ` `for` `(` `int` `i = 0; i <= 9; i++) ` ` ` `a[0][i] = 1; ` ` ` ` ` `/* Initialization of all i-digit ` ` ` `non-decreasing number leading with 9*/` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `a[i][9] = 1; ` ` ` ` ` `/* for all digits we should calculate ` ` ` `number of ways depending upon leading ` ` ` `digits*/` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `for` `(` `int` `j = 8; j >= 0; j--) ` ` ` `a[i][j] = a[i - 1][j] + a[i][j + 1]; ` ` ` ` ` `return` `a[n][0]; ` `} ` ` ` `// driver program ` `int` `main() ` `{ ` ` ` `int` `n = 2; ` ` ` `cout << ` `"Non-decreasing digits = "` ` ` `<< nonDecNums(n) << endl; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program for counting n digit numbers with ` `// non decreasing digits ` `import` `java.io.*; ` ` ` `class` `GFG { ` ` ` ` ` `// Function that returns count of non- decreasing numbers ` ` ` `// with n digits ` ` ` `static` `int` `nonDecNums(` `int` `n) ` ` ` `{ ` ` ` `// a[i][j] = count of all possible number ` ` ` `// with i digits having leading digit as j ` ` ` `int` `[][] a = ` `new` `int` `[n + ` `1` `][` `10` `]; ` ` ` ` ` `// Initialization of all 0-digit number ` ` ` `for` `(` `int` `i = ` `0` `; i <= ` `9` `; i++) ` ` ` `a[` `0` `][i] = ` `1` `; ` ` ` ` ` `// Initialization of all i-digit ` ` ` `// non-decreasing number leading with 9 ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) ` ` ` `a[i][` `9` `] = ` `1` `; ` ` ` ` ` `// for all digits we should calculate ` ` ` `// number of ways depending upon leading ` ` ` `// digits ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) ` ` ` `for` `(` `int` `j = ` `8` `; j >= ` `0` `; j--) ` ` ` `a[i][j] = a[i - ` `1` `][j] + a[i][j + ` `1` `]; ` ` ` ` ` `return` `a[n][` `0` `]; ` ` ` `} ` ` ` ` ` `// driver program ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `n = ` `2` `; ` ` ` `System.out.println(` `"Non-decreasing digits = "` `+ nonDecNums(n)); ` ` ` `} ` `} ` ` ` `// Contributed by Pramod Kumar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program for counting n digit ` `# numbers with non decreasing digits ` `import` `numpy as np ` ` ` `# Returns count of non- decreasing ` `# numbers with n digits. ` `def` `nonDecNums(n) : ` ` ` ` ` `# a[i][j] = count of all possible number ` ` ` `# with i digits having leading digit as j ` ` ` `a ` `=` `np.zeros((n ` `+` `1` `, ` `10` `)) ` ` ` ` ` `# Initialization of all 0-digit number ` ` ` `for` `i ` `in` `range` `(` `10` `) : ` ` ` `a[` `0` `][i] ` `=` `1` ` ` ` ` `# Initialization of all i-digit ` ` ` `# non-decreasing number leading with 9 ` ` ` `for` `i ` `in` `range` `(` `1` `, n ` `+` `1` `) : ` ` ` `a[i][` `9` `] ` `=` `1` ` ` ` ` `# for all digits we should calculate ` ` ` `# number of ways depending upon ` ` ` `# leading digits ` ` ` `for` `i ` `in` `range` `(` `1` `, n ` `+` `1` `) : ` ` ` `for` `j ` `in` `range` `(` `8` `, ` `-` `1` `, ` `-` `1` `) : ` ` ` `a[i][j] ` `=` `a[i ` `-` `1` `][j] ` `+` `a[i][j ` `+` `1` `] ` ` ` ` ` `return` `int` `(a[n][` `0` `]) ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `n ` `=` `2` ` ` `print` `(` `"Non-decreasing digits = "` `, ` ` ` `nonDecNums(n)) ` ` ` `# This code is contributed by Ryuga ` |

*chevron_right*

*filter_none*

## C#

`// C# function to find number of diagonals ` `// in n sided convex polygon ` `using` `System; ` ` ` `class` `GFG { ` ` ` ` ` `// Function that returns count of non- ` ` ` `// decreasing numbers with n digits ` ` ` `static` `int` `nonDecNums(` `int` `n) ` ` ` `{ ` ` ` `// a[i][j] = count of all possible number ` ` ` `// with i digits having leading digit as j ` ` ` `int` `[, ] a = ` `new` `int` `[n + 1, 10]; ` ` ` ` ` `// Initialization of all 0-digit number ` ` ` `for` `(` `int` `i = 0; i <= 9; i++) ` ` ` `a[0, i] = 1; ` ` ` ` ` `// Initialization of all i-digit ` ` ` `// non-decreasing number leading with 9 ` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `a[i, 9] = 1; ` ` ` ` ` `// for all digits we should calculate ` ` ` `// number of ways depending upon leading ` ` ` `// digits ` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `for` `(` `int` `j = 8; j >= 0; j--) ` ` ` `a[i, j] = a[i - 1, j] + a[i, j + 1]; ` ` ` ` ` `return` `a[n, 0]; ` ` ` `} ` ` ` ` ` `// driver program ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `n = 2; ` ` ` `Console.WriteLine(` `"Non-decreasing digits = "` `+ ` ` ` `nonDecNums(n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Sam007 ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program for counting ` `// n digit numbers with ` `// non decreasing digits ` ` ` `// Returns count of non- ` `// decreasing numbers with ` `// n digits. ` ` ` `function` `nonDecNums(` `$n` `) ` `{ ` ` ` `/* a[i][j] = count of ` ` ` `all possible number ` ` ` `with i digits having ` ` ` `leading digit as j */` ` ` ` ` `// Initialization of ` ` ` `// all 0-digit number ` ` ` `for` `(` `$i` `= 0; ` `$i` `<= 9; ` `$i` `++) ` ` ` `$a` `[0][` `$i` `] = 1; ` ` ` ` ` `/* Initialization of all ` ` ` `i-digit non-decreasing ` ` ` `number leading with 9*/` ` ` `for` `(` `$i` `= 1; ` `$i` `<= ` `$n` `; ` `$i` `++) ` ` ` `$a` `[` `$i` `][9] = 1; ` ` ` ` ` `/* for all digits we should ` ` ` `calculate number of ways ` ` ` `depending upon leading digits*/` ` ` `for` `(` `$i` `= 1; ` `$i` `<= ` `$n` `; ` `$i` `++) ` ` ` `for` `(` `$j` `= 8; ` `$j` `>= 0; ` `$j` `--) ` ` ` `$a` `[` `$i` `][` `$j` `] = ` `$a` `[` `$i` `- 1][` `$j` `] + ` ` ` `$a` `[` `$i` `][` `$j` `+ 1]; ` ` ` ` ` `return` `$a` `[` `$n` `][0]; ` `} ` ` ` `// Driver Code ` `$n` `= 2; ` `echo` `"Non-decreasing digits = "` `, ` ` ` `nonDecNums(` `$n` `),` `"\n"` `; ` ` ` `// This code is contributed by m_kit ` `?> ` |

*chevron_right*

*filter_none*

**Output :**

Non-decreasing digits = 55

**Time Complexity :** O(10*n) equivalent to O(n).

This article is contributed by **Shivam Pradhan (anuj_charm)**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Count of integers in a range which have even number of odd digits and odd number of even digits
- Find the number of positive integers less than or equal to N that have an odd number of digits
- Number of ways to form a heap with n distinct integers
- Number of arrays of size N whose elements are positive integers and sum is K
- Number of integers in a range [L, R] which are divisible by exactly K of it's digits
- Number of ways to write N as a sum of K non-negative integers
- Count positive integers with 0 as a digit and maximum 'd' digits
- Ways to write n as sum of two or more positive integers
- Count of integers of length N and value less than K such that they contain digits only from the given set
- Ways to write N as sum of two or more positive integers | Set-2
- Sum of integers upto N with given unit digit
- Integers from the range that are composed of a single distinct digit
- Check if the sum of distinct digits of two integers are equal
- Ways to form an array having integers in given range such that total sum is divisible by 2
- Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
- Find the first N integers such that the sum of their digits is equal to 10
- Sum of last digit of all integers from 1 to N divisible by M
- Queries to count integers in a range [L, R] such that their digit sum is prime and divisible by K
- Count of integers obtained by replacing ? in the given string that give remainder 5 when divided by 13
- Count of integers from the range [0, N] whose digit sum is a multiple of K