Total number of non-decreasing numbers with n digits

A number is non-decreasing if every digit (except the first one) is greater than or equal to previous digit. For example, 223, 4455567, 899, are non-decreasing numbers.

So, given the number of digits n, you are required to find the count of total non-decreasing numbers with n digits.

Examples:

Input:  n = 1
Output: count  = 10

Input:  n = 2
Output: count  = 55

Input:  n = 3
Output: count  = 220

We strongly recommend you to minimize your browser and try this yourself first.

One way to look at the problem is, count of numbers is equal to count n digit number ending with 9 plus count of ending with digit 8 plus count for 7 and so on. How to get count ending with a particular digit? We can recur for n-1 length and digits smaller than or equal to the last digit. So below is recursive formula.



Count of n digit numbers = (Count of (n-1) digit numbers Ending with digit 9) +
                           (Count of (n-1) digit numbers Ending with digit 8) +
                           .............................................+ 
                           .............................................+
                           (Count of (n-1) digit numbers Ending with digit 0) 

Let count ending with digit ‘d’ and length n be count(n, d)

count(n, d) = ∑(count(n-1, i)) where i varies from 0 to d

Total count = ∑count(n-1, d) where d varies from 0 to n-1

The above recursive solution is going to have many overlapping subproblems. Therefore, we can use Dynamic Programming to build a table in bottom up manner.
Below is the implementation of above idea :

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count non-decreasing number with n digits
#include<bits/stdc++.h>
using namespace std;
  
long long int countNonDecreasing(int n)
{
    // dp[i][j] contains total count of non decreasing
    // numbers ending with digit i and of length j
    long long int dp[10][n+1];
    memset(dp, 0, sizeof dp);
  
    // Fill table for non decreasing numbers of length 1
    // Base cases 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    for (int i = 0; i < 10; i++)
        dp[i][1] = 1;
  
    // Fill the table in bottom-up manner
    for (int digit = 0; digit <= 9; digit++)
    {
        // Compute total numbers of non decreasing
        // numbers of length 'len'
        for (int len = 2; len <= n; len++)
        {
            // sum of all numbers of length of len-1
            // in which last digit x is <= 'digit'
            for (int x = 0; x <= digit; x++)
                dp[digit][len] += dp[x][len-1];
        }
    }
  
    long long int count = 0;
  
    // There total nondecreasing numbers of length n
    // wiint be dp[0][n] +  dp[1][n] ..+ dp[9][n]
    for (int i = 0; i < 10; i++)
        count += dp[i][n];
  
    return count;
}
  
// Driver program
int main()
{
    int n = 3;
    cout << countNonDecreasing(n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

class NDN
{
    static int countNonDecreasing(int n)
    {
        // dp[i][j] contains total count of non decreasing
        // numbers ending with digit i and of length j
        int dp[][] = new int[10][n+1];
       
        // Fill table for non decreasing numbers of length 1
        // Base cases 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
        for (int i = 0; i < 10; i++)
            dp[i][1] = 1;
       
        // Fill the table in bottom-up manner
        for (int digit = 0; digit <= 9; digit++)
        {
            // Compute total numbers of non decreasing
            // numbers of length 'len'
            for (int len = 2; len <= n; len++)
            {
                // sum of all numbers of length of len-1
                // in which last digit x is <= 'digit'
                for (int x = 0; x <= digit; x++)
                    dp[digit][len] += dp[x][len-1];
            }
        }
       
        int count = 0;
       
        // There total nondecreasing numbers of length n
        // wiint be dp[0][n] +  dp[1][n] ..+ dp[9][n]
        for (int i = 0; i < 10; i++)
            count += dp[i][n];
       
        return count;
    }
    public static void main(String args[])
    {
       int n = 3;
       System.out.println(countNonDecreasing(n));
    }
}/* This code is contributed by Rajat Mishra */

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to count
# non-decreasing number with n digits
def countNonDecreasing(n):
      
    # dp[i][j] contains total count 
    # of non decreasing numbers ending 
    # with digit i and of length j 
    dp = [[0 for i in range(n + 1)]
             for i in range(10)]
               
    # Fill table for non decreasing
    # numbers of length 1.
    # Base cases 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  
    for i in range(10):
        dp[i][1] = 1
  
    # Fill the table in bottom-up manner 
    for digit in range(10):
          
        # Compute total numbers of non 
        # decreasing numbers of length 'len'
        for len in range(2, n + 1):
              
            # sum of all numbers of length 
            # of len-1 in which last 
            # digit x is <= 'digit'
            for x in range(digit + 1):
                dp[digit][len] += dp[x][len - 1]
    count = 0
      
    # There total nondecreasing numbers 
    # of length n won't be dp[0][n] + 
    # dp[1][n] ..+ dp[9][n] 
    for i in range(10):
        count += dp[i][n]
    return count
      
# Driver Code 
n = 3
print(countNonDecreasing(n))
  
# This code is contributed
# by sahilshelangia

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to print sum 
// triangle for a given array
using System;
  
class GFG {
      
    static int countNonDecreasing(int n)
    {
        // dp[i][j] contains total count
        // of non decreasing numbers ending
        // with digit i and of length j
        int [,]dp = new int[10,n + 1];
      
        // Fill table for non decreasing
        // numbers of length 1 Base cases 
        // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
        for (int i = 0; i < 10; i++)
            dp[i, 1] = 1;
      
        // Fill the table in bottom-up manner
        for (int digit = 0; digit <= 9; digit++)
        {
              
            // Compute total numbers of non decreasing
            // numbers of length 'len'
            for (int len = 2; len <= n; len++)
            {
                  
                // sum of all numbers of length of len-1
                // in which last digit x is <= 'digit'
                for (int x = 0; x <= digit; x++)
                    dp[digit, len] += dp[x, len - 1];
            }
        }
      
        int count = 0;
      
        // There total nondecreasing numbers
        // of length n wiint be dp[0][n]
        // + dp[1][n] ..+ dp[9][n]
        for (int i = 0; i < 10; i++)
            count += dp[i, n];
      
        return count;
    }
      
    // Driver code
    public static void Main()
    {
        int n = 3;
        Console.WriteLine(countNonDecreasing(n));
    }
}
  
// This code is contributed by Sam007.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
  
// PHP program to count non-decreasing number with n digits
   
function countNonDecreasing($n)
{
    // dp[i][j] contains total count of non decreasing
    // numbers ending with digit i and of length j
    $dp = array_fill(0,10,array_fill(0,$n+1,NULL));
   
    // Fill table for non decreasing numbers of length 1
    // Base cases 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    for ($i = 0; $i < 10; $i++)
        $dp[$i][1] = 1;
   
    // Fill the table in bottom-up manner
    for ($digit = 0; $digit <= 9; $digit++)
    {
        // Compute total numbers of non decreasing
        // numbers of length 'len'
        for ($len = 2; $len <= $n; $len++)
        {
            // sum of all numbers of length of len-1
            // in which last digit x is <= 'digit'
            for ($x = 0; $x <= $digit; $x++)
                $dp[$digit][$len] += $dp[$x][$len-1];
        }
    }
   
    $count = 0;
   
    // There total nondecreasing numbers of length n
    // wiint be dp[0][n] +  dp[1][n] ..+ dp[9][n]
    for ($i = 0; $i < 10; $i++)
        $count += $dp[$i][$n];
   
    return $count;
}
   
// Driver program
  
$n = 3;
echo  countNonDecreasing($n);
return 0;
?>

chevron_right


Output:

220

Thanks to Gaurav Ahirwar for suggesting above method.

Another method is based on below direct formula

Count of non-decreasing numbers with n digits = 
                                N*(N+1)/2*(N+2)/3* ....*(N+n-1)/n
Where N = 10

Below is the program to compute count using above formula.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count non-decreasing numner with n digits
#include<bits/stdc++.h>
using namespace std;
  
long long int countNonDecreasing(int n)
{
    int N = 10;
  
    // Compute value of N*(N+1)/2*(N+2)/3* ....*(N+n-1)/n
    long long count = 1;
    for (int i=1; i<=n; i++)
    {
        count *= (N+i-1);
        count /= i;
    }
  
    return count;
}
  
// Driver program
int main()
{
    int n = 3;
    cout << countNonDecreasing(n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// java program to count non-decreasing
// numner with n digits
public class GFG {
      
    static long countNonDecreasing(int n)
    {
        int N = 10;
       
        // Compute value of N * (N+1)/2 *
        // (N+2)/3 * ....* (N+n-1)/n
        long count = 1;
           
        for (int i = 1; i <= n; i++)
        {
            count *= (N + i - 1);
            count /= i;
        }
       
        return count;
    }
  
    // Driver code
    public static void main(String args[]) {
          
        int n = 3;
        System.out.print(countNonDecreasing(n));
    }   
}
  
// This code is contributed by Sam007.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# python program to count non-decreasing
# numner with n digits
  
def countNonDecreasing(n):
    N = 10
  
    # Compute value of N*(N+1)/2*(N+2)/3
    # * ....*(N+n-1)/n
    count = 1
    for i in range(1, n+1):
        count = int(count * (N+i-1))
        count = int(count / i )
          
    return count
  
# Driver program
n = 3;
print(countNonDecreasing(n))
      
# This code is contributed by Sam007

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count non-decreasing
// numner with n digits
using System;
  
class GFG {
      
    static long countNonDecreasing(int n)
    {
        int N = 10;
      
        // Compute value of N * (N+1)/2 *
        // (N+2)/3 * ....* (N+n-1)/n
        long count = 1;
          
        for (int i = 1; i <= n; i++)
        {
            count *= (N + i - 1);
            count /= i;
        }
      
        return count;
    }
  
      
    public static void Main()
    {
        int n = 3;
          
        Console.WriteLine(countNonDecreasing(n));
    }
}
  
// This code is contributed by Sam007.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to count non-decreasing
// numner with n digits
  
function countNonDecreasing($n)
{
    $N = 10;
  
    // Compute value of N*(N+1)/2*(N+2)/3* ...
    // ....*(N+n-1)/n
    $count = 1;
    for ($i = 1; $i <= $n; $i++)
    {
        $count *= ($N + $i - 1);
        $count /= $i;
    }
  
    return $count;
}
  
    // Driver Code
    $n = 3;
    echo countNonDecreasing($n);
      
// This code is contributed by Sam007
?>

chevron_right



Output:

220

Thanks to Abhishek Somani for suggesting this method.

How does this formula work?

N * (N+1)/2 * (N+2)/3 * .... * (N+n-1)/n
Where N = 10 

Let us try for different values of n.

For n = 1, the value is N from formula.
Which is true as for n = 1, we have all single digit
numbers, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

For n = 2, the value is N(N+1)/2 from formula
We can have N numbers beginning with 0, (N-1) numbers 
beginning with 1, and so on.
So sum is N + (N-1) + .... + 1 = N(N+1)/2

For n = 3, the value is N(N+1)/2(N+2)/3 from formula
We can have N(N+1)/2 numbers beginning with 0, (N-1)N/2 
numbers beginning with 1 (Note that when we begin with 1, 
we have N-1 digits left to consider for remaining places),
(N-2)(N-1)/2 beginning with 2, and so on.
Count = N(N+1)/2 + (N-1)N/2 + (N-2)(N-1)/2 + 
                               (N-3)(N-2)/2 .... 3 + 1 
     [Combining first 2 terms, next 2 terms and so on]
     = 1/2[N2 + (N-2)2 + .... 4]
     = N*(N+1)*(N+2)/6  [Refer this , putting n=N/2 in the 
                         even sum formula]

For general n digit case, we can apply Mathematical Induction. The count would be equal to count n-1 digit beginning with 0, i.e., N*(N+1)/2*(N+2)/3* ….*(N+n-1-1)/(n-1). Plus count of n-1 digit numbers beginning with 1, i.e., (N-1)*(N)/2*(N+1)/3* ….*(N-1+n-1-1)/(n-1) (Note that N is replaced by N-1) and so on.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up