# Count different numbers that can be generated such that there digits sum is equal to ‘n’

Given an positive integer n. Count the different numbers that can be generated using digits 1, 2, 3 and 4 such that digits sum is the number ‘n’. Here digit ‘4’ will be treated as ‘1’. For instance,
32 = 3 + 2 = 5
1341 = 1 + 3 + 1 + 1 = 6
441 = 1 + 1 + 1 = 3
Note: Answer the value in mod = 109+7

```Input: 2
Output: 5
Explanation
There are only '5' numbers that can
11 = 1 + 1 = 2
14 = 1 + 1 = 2
41 = 1 + 1 = 2
44 = 1 + 1 = 2
2  = 2

Input: 3
Output: 13
Explanation
There are only '13' numbers that can
be made i.e., 111, 114, 141, 144, 411,
414, 441, 444, 12, 21, 42, 24, 3.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The approach is to use Dynamic programming. The problem is same as coin change and Ways to write n as sum of two or more positive integers problems. The only difference is that, instead of iterating up-to ‘n’, iterate only from 1 to 3 as according to question, only 1, 2, 3 and 4 digits are allowed. But since ‘4’ can be replaced with ‘1’ therefore iterate through 1, 2 and 3 and double the count of ‘1’ for compensation of digit ‘4’.

## C++

 `// C++ program to count ways to write ` `// 'n' as sum of digits ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count 'num' as sum of ` `// digits(1, 2, 3, 4) ` `int` `countWays(``int` `num) ` `{ ` `    ``// Initialize dp[] array ` `    ``int` `dp[num+1]; ` ` `  `    ``const` `int` `MOD = 1e9 + 7; ` `    ``// Base case ` `    ``dp = 2; ` ` `  `    ``for``(``int` `i = 2; i <= num; ++i) ` `    ``{ ` `        ``// Initialize the current dp[]  ` `        ``// array as '0' ` `        ``dp[i] = 0; ` ` `  `        ``for``(``int` `j = 1; j <= 3; ++j) ` `        ``{ ` `            ``/* if i == j then there is only ` `               ``one way to write with element ` `               ``itself 'i' */` `            ``if``(i - j == 0) ` `               ``dp[i] += 1; ` ` `  `            ``/* If j == 1, then there exist ` `               ``two ways, one from '1' and ` `               ``other from '4' */` `            ``else` `if` `(j == 1) ` `               ``dp[i] += dp[i-j] * 2; ` ` `  `            ``/* if i - j is positive then ` `               ``pick the element from 'i-j' ` `               ``element of dp[] array */` `            ``else` `if``(i - j > 0) ` `               ``dp[i] += dp[i-j]; ` ` `  `        ``// Check for modulas ` `        ``if``(dp[i] >= MOD) ` `            ``dp[i] %= MOD; ` `        ``} ` ` `  `    ``} ` ` `  `    ``// return the final answer ` `    ``return` `dp[num]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 3; ` `    ``cout << countWays(n); ` `     `  `    ``return` `0; ` `} `

## Java

 `// Java program to count ways to  ` `// write 'n' as sum of digits ` `import` `java.io.*; ` ` `  `public` `class` `GFG ` `{ ` ` `  `// Function to count 'num' as  ` `// sum of digits(1, 2, 3, 4) ` `static` `int` `countWays(``int` `num) ` `{ ` `     `  `    ``// Initialize dp[] array ` `    ``int` `[]dp= ``new` `int``[num + ``1``]; ` `    ``int` `MOD = (``int``)1E9 + ``7``; ` `     `  `    ``// Base case ` `    ``dp[``1``] = ``2``; ` ` `  `    ``for``(``int` `i = ``2``; i <= num; ++i) ` `    ``{ ` `        ``// Initialize the current ` `        ``// dp[] array as '0'  ` `        ``dp[i] = ``0``; ` ` `  `        ``for``(``int` `j = ``1``; j <= ``3``; ++j) ` `        ``{ ` `            ``// if i == j then there is  ` `            ``// only one way to write with ` `            ``// element itself 'i' ` `            ``if``(i - j == ``0``) ` `            ``dp[i] += ``1``; ` ` `  `            ``// If j == 1, then there exist ` `            ``// two ways, one from '1' and ` `            ``// other from '4'  ` `            ``else` `if` `(j == ``1``) ` `                ``dp[i] += dp[i - j] * ``2``; ` ` `  `            ``// if i - j is positive then ` `            ``// pick the element from 'i-j' ` `            ``// element of dp[] array  ` `            ``else` `if``(i - j > ``0``) ` `                ``dp[i] += dp[i - j]; ` ` `  `        ``// Check for modulas ` `        ``if``(dp[i] >= MOD) ` `            ``dp[i] %= MOD; ` `        ``} ` ` `  `    ``} ` ` `  `    ``// return the final answer ` `    ``return` `dp[num]; ` `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `main (String[] args) ` `    ``{ ` `        ``int` `n = ``3``; ` `        ``System.out.println(countWays(n)); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

## Python3

 `# Python3 program to count ways to write  ` `# 'n' as sum of digits  ` ` `  `# Function to count 'num' as sum of  ` `# digits(1, 2, 3, 4)  ` `def` `countWays(num):  ` ` `  `    ``# Initialize dp[] array  ` `    ``dp ``=` `[``0``] ``*` `(num ``+` `1``);  ` ` `  `    ``MOD ``=` `100000000` `+` `7``;  ` `     `  `    ``# Base case  ` `    ``dp[``1``] ``=` `2``;  ` ` `  `    ``for` `i ``in` `range``(``2``, num ``+` `1``): ` `         `  `        ``# Initialize the current dp[]  ` `        ``# array as '0'  ` `        ``dp[i] ``=` `0``;  ` ` `  `        ``for` `j ``in` `range``(``1``, ``4``):  ` `             `  `            ``# if i == j then there is only  ` `            ``# one way to write with element  ` `            ``# itself 'i'  ` `            ``if``(i ``-` `j ``=``=` `0``): ` `                ``dp[i] ``+``=` `1``;  ` ` `  `            ``# If j == 1, then there exist  ` `            ``# two ways, one from '1' and  ` `            ``# other from '4' ` `            ``elif` `(j ``=``=` `1``): ` `                ``dp[i] ``+``=` `dp[i ``-` `j] ``*` `2``;  ` ` `  `            ``# if i - j is positive then  ` `            ``# pick the element from 'i-j'  ` `            ``# element of dp[] array  ` `            ``elif``(i ``-` `j > ``0``): ` `                ``dp[i] ``+``=` `dp[i ``-` `j];  ` ` `  `        ``# Check for modulas  ` `        ``if``(dp[i] >``=` `MOD):  ` `            ``dp[i] ``%``=` `MOD;  ` ` `  `    ``# return the final answer  ` `    ``return` `dp[num];  ` ` `  `# Driver code  ` `n ``=` `3``;  ` `print``(countWays(n));  ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to count ways to  ` `// write 'n' as sum of digits ` `using` `System; ` ` `  `public` `class` `GFG ` `{ ` ` `  `// Function to count 'num' as  ` `// sum of digits(1, 2, 3, 4) ` `static` `int` `countWays(``int` `num) ` `{ ` `     `  `    ``// Initialize dp[] array ` `    ``int` `[]dp= ``new` `int``[num + 1]; ` `    ``int` `MOD = (``int``)1E9 + 7; ` `     `  `    ``// Base case ` `    ``dp = 2; ` ` `  `    ``for``(``int` `i = 2; i <= num; ++i) ` `    ``{ ` `        ``// Initialize the current ` `        ``// dp[] array as '0'  ` `        ``dp[i] = 0; ` ` `  `        ``for``(``int` `j = 1; j <= 3; ++j) ` `        ``{ ` `            ``// if i == j then there is  ` `            ``// only one way to write with ` `            ``// element itself 'i' ` `            ``if``(i - j == 0) ` `            ``dp[i] += 1; ` ` `  `            ``// If j == 1, then there exist ` `            ``// two ways, one from '1' and ` `            ``// other from '4'  ` `            ``else` `if` `(j == 1) ` `                ``dp[i] += dp[i - j] * 2; ` ` `  `            ``// if i - j is positive then ` `            ``// pick the element from 'i-j' ` `            ``// element of dp[] array  ` `            ``else` `if``(i - j > 0) ` `                ``dp[i] += dp[i - j]; ` ` `  `        ``// Check for modulas ` `        ``if``(dp[i] >= MOD) ` `            ``dp[i] %= MOD; ` `        ``} ` ` `  `    ``} ` ` `  `    ``// return the final answer ` `    ``return` `dp[num]; ` `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main (String []args) ` `    ``{ ` `        ``int` `n = 3; ` `        ``Console.WriteLine(countWays(n)); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

## PHP

 ` 0)  ` `            ``\$dp``[``\$i``] += ``\$dp``[``\$i` `- ``\$j``];  ` ` `  `        ``// Check for modulas  ` `        ``if``(``\$dp``[``\$i``] >= ``\$MOD``)  ` `            ``\$dp``[``\$i``] %= ``\$MOD``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// return the final answer  ` `    ``return` `\$dp``[``\$num``];  ` `}  ` ` `  `// Driver code  ` `\$n` `= 3;  ` `echo` `countWays(``\$n``);  ` ` `  `// This code is contributed by jit_t ` `?> `

Output

```13
```

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

Note: Asked in Directi coding round(2014 and 2017)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : vt_m, jit_t, Mithun Kumar

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.