 Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 09 May, 2022

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.```

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 modulus``        ``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 modulus``        ``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 modulus``        ``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 modulus``        ``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 modulus``        ``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``?>`

## Javascript

 ``

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