Open In App

# Count of n digit numbers whose sum of digits equals to given sum

Given two integers ‘n’ and ‘sum’, find count of all n digit numbers with sum of digits as ‘sum’. Leading 0’s are not counted as digits.

Constrains:
1 <= n <= 100 and
1 <= sum <= 500

Example:

Input: n = 2, sum = 2
Output: 2
Explanation: Numbers are 11 and 20

Input: n = 2, sum = 5
Output: 5
Explanation: Numbers are 14, 23, 32, 41 and 50

Input: n = 3, sum = 6
Output: 21

### Naive approach:

The idea is simple, we subtract all values from 0 to 9 from given sum and recur for sum minus that digit. Below is recursive formula.

```    countRec(n, sum) = ∑countRec(n-1, sum-x)
where 0 =< x = 0
One important observation is, leading 0's must be
handled explicitly as they are not counted as digits.
So our final count can be written as below.
finalCount(n, sum) = ∑countRec(n-1, sum-x)
where 1 =< x = 0```

Below is a simple recursive solution based on above recursive formula.

## C++

 `// A C++ program using recursion to count numbers``// with sum of digits as given 'sum'``#include``using` `namespace` `std;` `// Recursive function to count 'n' digit numbers``// with sum of digits as 'sum'. This function``// considers leading 0's also as digits, that is``// why not directly called``unsigned ``long` `long` `int` `countRec(``int` `n, ``int` `sum)``{``    ``// Base case``    ``if` `(n == 0)``    ``return` `sum == 0;` `    ``if` `(sum == 0)``    ``return` `1;` `    ``// Initialize answer``    ``unsigned ``long` `long` `int` `ans = 0;` `    ``// Traverse through every digit and count``    ``// numbers beginning with it using recursion``    ``for` `(``int` `i=0; i<=9; i++)``    ``if` `(sum-i >= 0)``        ``ans += countRec(n-1, sum-i);` `    ``return` `ans;``}` `// This is mainly a wrapper over countRec. It``// explicitly handles leading digit and calls``// countRec() for remaining digits.``unsigned ``long` `long` `int` `finalCount(``int` `n, ``int` `sum)``{``    ``// Initialize final answer``    ``unsigned ``long` `long` `int` `ans = 0;` `    ``// Traverse through every digit from 1 to``    ``// 9 and count numbers beginning with it``    ``for` `(``int` `i = 1; i <= 9; i++)``    ``if` `(sum-i >= 0)``        ``ans += countRec(n-1, sum-i);` `    ``return` `ans;``}` `// Driver program``int` `main()``{``    ``int` `n = 2, sum = 5;``    ``cout << finalCount(n, sum);``    ``return` `0;``}`

## Java

 `// A Java program using recursion to count numbers``// with sum of digits as given 'sum'``import` `java.io.*;``public` `class` `sum_dig``{``    ``// Recursive function to count 'n' digit numbers``    ``// with sum of digits as 'sum'. This function``    ``// considers leading 0's also as digits, that is``    ``// why not directly called``    ``static` `int` `countRec(``int` `n, ``int` `sum)``    ``{``        ``// Base case``        ``if` `(n == ``0``)``        ``return` `sum == ``0` `?``1``:``0``;` `            ``if` `(sum == ``0``)``            ``return` `1``;``    ` `        ``// Initialize answer``        ``int` `ans = ``0``;``    ` `        ``// Traverse through every digit and count``        ``// numbers beginning with it using recursion``        ``for` `(``int` `i=``0``; i<=``9``; i++)``        ``if` `(sum-i >= ``0``)``            ``ans += countRec(n-``1``, sum-i);``    ` `        ``return` `ans;``    ``}``    ` `    ``// This is mainly a wrapper over countRec. It``    ``// explicitly handles leading digit and calls``    ``// countRec() for remaining digits.``    ``static` `int` `finalCount(``int` `n, ``int` `sum)``    ``{``        ``// Initialize final answer``        ``int` `ans = ``0``;``    ` `        ``// Traverse through every digit from 1 to``        ``// 9 and count numbers beginning with it``        ``for` `(``int` `i = ``1``; i <= ``9``; i++)``        ``if` `(sum-i >= ``0``)``            ``ans += countRec(n-``1``, sum-i);``    ` `        ``return` `ans;``    ``}` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main (String args[])``    ``{``        ``int` `n = ``2``, sum = ``5``;``        ``System.out.println(finalCount(n, sum));``    ``}``}``/* This code is contributed by Rajat Mishra */`

## Python3

 `# A python 3 program using recursion to count numbers``# with sum of digits as given 'sum'` `# Recursive function to count 'n' digit``# numbers with sum of digits as 'sum'``# This function considers leading 0's``# also as digits, that is why not``# directly called``def` `countRec(n, ``sum``) :``    ` `    ``# Base case``    ``if` `(n ``=``=` `0``) :``        ``return` `(``sum` `=``=` `0``)` `    ``if` `(``sum` `=``=` `0``) :``        ``return` `1` `    ``# Initialize answer``    ``ans ``=` `0` `    ``# Traverse through every digit and``    ``# count numbers beginning with it``    ``# using recursion``    ``for` `i ``in` `range``(``0``, ``10``) :``        ``if` `(``sum``-``i >``=` `0``) :``            ``ans ``=` `ans ``+` `countRec(n``-``1``, ``sum``-``i)` `    ``return` `ans``    ` `    ` `# This is mainly a wrapper over countRec. It``# explicitly handles leading digit and calls``# countRec() for remaining digits.``def` `finalCount(n, ``sum``) :``    ` `    ``# Initialize final answer``    ``ans ``=` `0` `    ``# Traverse through every digit from 1 to``    ``# 9 and count numbers beginning with it``    ``for` `i ``in` `range``(``1``, ``10``) :``        ``if` `(``sum``-``i >``=` `0``) :``            ``ans ``=` `ans ``+` `countRec(n``-``1``, ``sum``-``i)` `    ``return` `ans`  `# Driver program``n ``=` `2``sum` `=` `5``print``(finalCount(n, ``sum``))`  `# This code is contributed by Nikita tiwari.`

## C#

 `// A C# program using recursion to count numbers``// with sum of digits as given 'sum'``using` `System;``class` `GFG {``    ` `    ``// Recursive function to``    ``// count 'n' digit numbers``    ``// with sum of digits as``    ``// 'sum'. This function``    ``// considers leading 0's``    ``// also as digits, that is``    ``// why not directly called``    ``static` `int` `countRec(``int` `n, ``int` `sum)``    ``{``        ` `        ``// Base case``        ``if` `(n == 0)``        ``return` `sum == 0 ? 1 : 0;` `            ``if` `(sum == 0)``            ``return` `1;``    ` `        ``// Initialize answer``        ``int` `ans = 0;``    ` `        ``// Traverse through every``        ``// digit and count numbers``        ``// beginning with it using``        ``// recursion``        ``for` `(``int` `i = 0; i <= 9; i++)``        ``if` `(sum - i >= 0)``            ``ans += countRec(n - 1, sum - i);``    ` `        ``return` `ans;``    ``}``    ` `    ``// This is mainly a``    ``// wrapper over countRec. It``    ``// explicitly handles leading``    ``// digit and calls countRec()``    ``// for remaining digits.``    ``static` `int` `finalCount(``int` `n, ``int` `sum)``    ``{``        ` `        ``// Initialize final answer``        ``int` `ans = 0;``    ` `        ``// Traverse through every``        ``// digit from 1 to 9 and``        ``// count numbers beginning``        ``// with it``        ``for` `(``int` `i = 1; i <= 9; i++)``        ``if` `(sum - i >= 0)``            ``ans += countRec(n - 1, sum - i);``    ` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main ()``    ``{``        ``int` `n = 2, sum = 5;``        ``Console.Write(finalCount(n, sum));``    ``}``}` `// This code is contributed by nitin mittal.`

## Javascript

 ``

## PHP

 `= 0)``        ``\$ans` `+= countRec(``\$n``-1, ``\$sum``-``\$i``);` `    ``return` `\$ans``;``}` `// This is mainly a wrapper``// over countRec. It``// explicitly handles leading``// digit and calls``// countRec() for remaining digits.``function` `finalCount(``\$n``, ``\$sum``)``{``    ` `    ``// Initialize final answer``    ``\$ans` `= 0;` `    ``// Traverse through every``    ``// digit from 1 to``    ``// 9 and count numbers``    ``// beginning with it``    ``for` `(``\$i` `= 1; ``\$i` `<= 9; ``\$i``++)``    ``if` `(``\$sum` `- ``\$i` `>= 0)``        ``\$ans` `+= countRec(``\$n` `- 1, ``\$sum` `- ``\$i``);` `    ``return` `\$ans``;``}` `    ``// Driver Code``    ``\$n` `= 2;``    ``\$sum` `= 5;``    ``echo` `finalCount(``\$n``, ``\$sum``);``    ` `// This code is contributed by ajit``?>`

Output

`5`

Time Complexity: O(2n)
Auxiliary Space: O(n)

## C++

 `// A C++ memoization based recursive program to count``// numbers with sum of n as given 'sum'``#include``using` `namespace` `std;` `// A lookup table used for memoization``unsigned ``long` `long` `int` `lookup[101][501];` `// Memoization based implementation of recursive``// function``unsigned ``long` `long` `int` `countRec(``int` `n, ``int` `sum)``{``    ``// Base case``    ``if` `(n == 0)``    ``return` `sum == 0;` `    ``// If this subproblem is already evaluated,``    ``// return the evaluated value``    ``if` `(lookup[n][sum] != -1)``    ``return` `lookup[n][sum];` `    ``// Initialize answer``    ``unsigned ``long` `long` `int` `ans = 0;` `    ``// Traverse through every digit and``    ``// recursively count numbers beginning``    ``// with it``    ``for` `(``int` `i=0; i<10; i++)``    ``if` `(sum-i >= 0)``        ``ans += countRec(n-1, sum-i);` `    ``return` `lookup[n][sum] = ans;``}` `// This is mainly a wrapper over countRec. It``// explicitly handles leading digit and calls``// countRec() for remaining n.``unsigned ``long` `long` `int` `finalCount(``int` `n, ``int` `sum)``{``    ``// Initialize all entries of lookup table``    ``memset``(lookup, -1, ``sizeof` `lookup);` `    ``// Initialize final answer``    ``unsigned ``long` `long` `int` `ans = 0;` `    ``// Traverse through every digit from 1 to``    ``// 9 and count numbers beginning with it``    ``for` `(``int` `i = 1; i <= 9; i++)``    ``if` `(sum-i >= 0)``        ``ans += countRec(n-1, sum-i);``    ``return` `ans;``}` `// Driver program``int` `main()``{``    ``int` `n = 3, sum = 5;``    ``cout << finalCount(n, sum);``    ``return` `0;``}`

## Java

 `// A Java memoization based recursive program to count``// numbers with sum of n as given 'sum'``import` `java.io.*;``public` `class` `sum_dig``{``    ``// A lookup table used for memoization``    ``static` `int` `lookup[][] = ``new` `int``[``101``][``501``];``    ` `    ``// Memoization based implementation of recursive``    ``// function``    ``static` `int` `countRec(``int` `n, ``int` `sum)``    ``{``        ``// Base case``        ``if` `(n == ``0``)``        ``return` `sum == ``0` `? ``1` `: ``0``;``    ` `        ``// If this subproblem is already evaluated,``        ``// return the evaluated value``        ``if` `(lookup[n][sum] != -``1``)``        ``return` `lookup[n][sum];``    ` `        ``// Initialize answer``        ``int` `ans = ``0``;``    ` `        ``// Traverse through every digit and``        ``// recursively count numbers beginning``        ``// with it``        ``for` `(``int` `i=``0``; i<``10``; i++)``        ``if` `(sum-i >= ``0``)``            ``ans += countRec(n-``1``, sum-i);``    ` `        ``return` `lookup[n][sum] = ans;``    ``}``    ` `    ``// This is mainly a wrapper over countRec. It``    ``// explicitly handles leading digit and calls``    ``// countRec() for remaining n.``    ``static` `int` `finalCount(``int` `n, ``int` `sum)``    ``{``        ``// Initialize all entries of lookup table``        ``for``(``int` `i = ``0``; i <= ``100``; ++i){``            ``for``(``int` `j = ``0``; j <= ``500``; ++j){``                ``lookup[i][j] = -``1``;``            ``}``        ``}``    ` `        ``// Initialize final answer``        ``int` `ans = ``0``;``    ` `        ``// Traverse through every digit from 1 to``        ``// 9 and count numbers beginning with it``        ``for` `(``int` `i = ``1``; i <= ``9``; i++)``        ``if` `(sum-i >= ``0``)``            ``ans += countRec(n-``1``, sum-i);``        ``return` `ans;``    ``}` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main (String args[])``    ``{``        ``int` `n = ``3``, sum = ``5``;``        ``System.out.println(finalCount(n, sum));``    ``}``}``/* This code is contributed by Rajat Mishra */`

## Python3

 `# A Python3 memoization based recursive``# program to count numbers with Sum of n``# as given 'Sum'` `# A lookup table used for memoization``lookup ``=` `[[``-``1` `for` `i ``in` `range``(``501``)]``              ``for` `i ``in` `range``(``101``)]` `# Memoization based implementation``# of recursive function``def` `countRec(n, ``Sum``):` `    ``# Base case``    ``if` `(n ``=``=` `0``):``        ``return` `Sum` `=``=` `0` `    ``# If this subproblem is already evaluated,``    ``# return the evaluated value``    ``if` `(lookup[n][``Sum``] !``=` `-``1``):``        ``return` `lookup[n][``Sum``]` `    ``# Initialize answer``    ``ans ``=` `0` `    ``# Traverse through every digit and``    ``# recursively count numbers beginning``    ``# with it``    ``for` `i ``in` `range``(``10``):``        ``if` `(``Sum``-``i >``=` `0``):``            ``ans ``+``=` `countRec(n ``-` `1``, ``Sum``-``i)``    ``lookup[n][``Sum``] ``=` `ans    ` `    ``return` `lookup[n][``Sum``]` `# This is mainly a wrapper over countRec. It``# explicitly handles leading digit and calls``# countRec() for remaining n.``def` `finalCount(n, ``Sum``):` `    ``# Initialize final answer``    ``ans ``=` `0` `    ``# Traverse through every digit from 1 to``    ``# 9 and count numbers beginning with it``    ``for` `i ``in` `range``(``1``, ``10``):``        ``if` `(``Sum` `-` `i >``=` `0``):``            ``ans ``+``=` `countRec(n ``-` `1``, ``Sum` `-` `i)``    ``return` `ans` `# Driver Code``n, ``Sum` `=` `3``, ``5``print``(finalCount(n, ``Sum``))` `# This code is contributed by mohit kumar 29`

## C#

 `// A C# memoization based recursive program to count``// numbers with sum of n as given 'sum'` `using` `System;``class` `sum_dig``{``    ``// A lookup table used for memoization``    ``static` `int` `[,]lookup = ``new` `int``[101,501];``     ` `    ``// Memoization based implementation of recursive``    ``// function``    ``static` `int` `countRec(``int` `n, ``int` `sum)``    ``{``        ``// Base case``        ``if` `(n == 0)``        ``return` `sum == 0 ? 1 : 0;``     ` `        ``// If this subproblem is already evaluated,``        ``// return the evaluated value``        ``if` `(lookup[n,sum] != -1)``        ``return` `lookup[n,sum];``     ` `        ``// Initialize answer``        ``int` `ans = 0;``     ` `        ``// Traverse through every digit and``        ``// recursively count numbers beginning``        ``// with it``        ``for` `(``int` `i=0; i<10; i++)``        ``if` `(sum-i >= 0)``            ``ans += countRec(n-1, sum-i);``     ` `        ``return` `lookup[n,sum] = ans;``    ``}``     ` `    ``// This is mainly a wrapper over countRec. It``    ``// explicitly handles leading digit and calls``    ``// countRec() for remaining n.``    ``static` `int` `finalCount(``int` `n, ``int` `sum)``    ``{``        ``// Initialize all entries of lookup table``        ``for``(``int` `i = 0; i <= 100; ++i){``            ``for``(``int` `j = 0; j <= 500; ++j){``                ``lookup[i,j] = -1;``            ``}``        ``}``     ` `        ``// Initialize final answer``        ``int` `ans = 0;``     ` `        ``// Traverse through every digit from 1 to``        ``// 9 and count numbers beginning with it``        ``for` `(``int` `i = 1; i <= 9; i++)``        ``if` `(sum-i >= 0)``            ``ans += countRec(n-1, sum-i);``        ``return` `ans;``    ``}`` ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `Main ()``    ``{``        ``int` `n = 3, sum = 5;``        ``Console.Write(finalCount(n, sum));``    ``}``}`

## Javascript

 ``

## PHP

 `= 0)``        ``\$ans` `+= countRec(``\$n` `- 1, ``\$sum` `- ``\$i``);` `    ``return` `\$lookup``[``\$n``][``\$sum``] = ``\$ans``;``}` `// This is mainly a wrapper over countRec. It``// explicitly handles leading digit and calls``// countRec() for remaining n.``function` `finalCount(``\$n``, ``\$sum``)``{``    ``// Initialize all entries of lookup table` `    ``// Initialize final answer``    ``\$ans` `= 0;` `    ``// Traverse through every digit from 1 to``    ``// 9 and count numbers beginning with it``    ``for` `(``\$i` `= 1; ``\$i` `<= 9; ``\$i``++)``    ``if` `(``\$sum``-``\$i` `>= 0)``        ``\$ans` `+= countRec(``\$n` `- 1, ``\$sum` `- ``\$i``);``    ``return` `\$ans``;``}` `// Driver Code``\$n` `= 3;``\$sum` `= 5;``echo` `finalCount(``\$n``, ``\$sum``);` `// This code is contributed by mits``?>`

Output

`15`

Time Complexity: O(n*sum)
Auxiliary Space: O(101*501)

Another Method: We can easily count n digit numbers whose sum of digit equals to given sum by iterating all n digits and checking if current n digit number’s sum is equal to given sum, if it is then we will start increment number by 9 until it reaches to number whose sum of digit’s is greater than given sum, then again we will increment by 1 until we found another number with given sum.

## C++

 `// C++ program to Count of n digit numbers``// whose sum of digits equals to given sum``#include ``#include ``using` `namespace` `std;`` ``void` `findCount(``int` `n, ``int` `sum) {``        ` `        ``//in case n = 2 start is 10 and end is (100-1) = 99``        ``int` `start = ``pow``(10, n-1);``        ``int` `end = ``pow``(10, n)-1;``    ` `        ``int` `count = 0;``        ``int` `i = start;``        ` `                ``while``(i <= end) {``            ` `            ``int` `cur = 0;``            ``int` `temp = i;``            ` `            ``while``( temp != 0) {``                ``cur += temp % 10;``                ``temp = temp / 10;``            ``}``            ` `            ``if``(cur == sum) {            ``                ``count++;            ``                ``i += 9;        ``            ``}``else``                ``i++;``            ` `        ``}    ``            ``cout << count;` `        ``/* This code is contributed by Anshuman */``    ``}``int` `main() {``        ``int` `n = 3;``        ``int` `sum = 5;    ``        ``findCount(n,sum);``        ` `    ` `    ``return` `0;``}`

## Java

 `// Java program to Count of n digit numbers``// whose sum of digits equals to given sum``import` `java.io.*;``public` `class` `GFG {` `    ``public` `static` `void` `main(String[] args) {``        ` `        ``int` `n = ``3``;``        ``int` `sum = ``5``;    ``        ``findCount(n,sum);``        ` `    ``}``    ` `    ``private` `static` `void` `findCount(``int` `n, ``int` `sum) {``        ` `        ``//in case n = 2 start is 10 and end is (100-1) = 99``        ``int` `start = (``int``) Math.pow(``10``, n-``1``);``        ``int` `end = (``int``) Math.pow(``10``, n)-``1``;``    ` `        ``int` `count = ``0``;``        ``int` `i = start;``        ` `                ``while``(i < end) {``            ` `            ``int` `cur = ``0``;``            ``int` `temp = i;``            ` `            ``while``( temp != ``0``) {``                ``cur += temp % ``10``;``                ``temp = temp / ``10``;``            ``}``            ` `            ``if``(cur == sum) {            ``                ``count++;            ``                ``i += ``9``;        ``            ``}``else``                ``i++;``            ` `        ``}    ``        ``System.out.println(count);` `        ``/* This code is contributed by Anshuman */``    ``}``}`

## Python3

 `# Python3 program to Count of n digit numbers``# whose sum of digits equals to given sum``import` `math` `def` `findCount(n, ``sum``):``    ` `    ``# in case n = 2 start is 10 and``    ``# end is (100-1) = 99``    ``start ``=` `math.``pow``(``10``, n ``-` `1``);``    ``end ``=` `math.``pow``(``10``, n) ``-` `1``;` `    ``count ``=` `0``;``    ``i ``=` `start;``    ` `    ``while``(i <``=` `end):``        ` `        ``cur ``=` `0``;``        ``temp ``=` `i;``        ` `        ``while``(temp !``=` `0``):``            ``cur ``+``=` `temp ``%` `10``;``            ``temp ``=` `temp ``/``/` `10``;``        ` `        ``if``(cur ``=``=` `sum``):    ``            ``count ``=` `count ``+` `1``;        ``            ``i ``+``=` `9``;    ``        ``else``:``            ``i ``=` `i ``+` `1``;``        ` `    ``print``(count);` `# Driver Code``n ``=` `3``;``sum` `=` `5``;    ``findCount(n, ``sum``);` `# This code is contributed``# by Akanksha Rai`

## C#

 `// C# program to Count of n digit numbers``// whose sum of digits equals to given sum``using` `System;` `class` `GFG``{``private` `static` `void` `findCount(``int` `n,``                              ``int` `sum)``{``    ` `    ``// in case n = 2 start is 10 and``    ``// end is (100-1) = 99``    ``int` `start = (``int``) Math.Pow(10, n - 1);``    ``int` `end = (``int``) Math.Pow(10, n) - 1;` `    ``int` `count = 0;``    ``int` `i = start;``    ` `    ``while``(i < end)``    ``{``        ` `        ``int` `cur = 0;``        ``int` `temp = i;``        ` `        ``while``( temp != 0)``        ``{``            ``cur += temp % 10;``            ``temp = temp / 10;``        ``}``        ` `        ``if``(cur == sum)``        ``{        ``            ``count++;            ``            ``i += 9;    ``        ``}``        ``else``            ``i++;``        ` `    ``}``    ``Console.WriteLine(count);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `n = 3;``    ``int` `sum = 5;    ``    ``findCount(n,sum);``}``}` `// This code is contributed``// by Akanksha Rai`

## Javascript

 ``

## PHP

 ``

Output

`15`

Time Complexity: O(log n)
Auxiliary Space: O(1)

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