Related Articles
Count different numbers that can be generated such that there digits sum is equal to ‘n’
• Difficulty Level : Medium
• Last Updated : 20 Dec, 2018

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
be made:
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)

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.

My Personal Notes arrow_drop_up