 Open in App
Not now

# Count of different ways to express N as the sum of 1, 3 and 4

• Difficulty Level : Easy

Given N, count the number of ways to express N as sum of 1, 3 and 4.

Examples:

```Input :  N = 4
Output : 4
Explanation: 1+1+1+1
1+3
3+1
4

Input : N = 5
Output : 6
Explanation: 1 + 1 + 1 + 1 + 1
1 + 4
4 + 1
1 + 1 + 3
1 + 3 + 1
3 + 1 + 1```

Approach : Divide the problem into sub-problems for solving it. Let DP[n] be the number of ways to write N as the sum of 1, 3, and 4. Consider one possible solution with n = x1 + x2 + x3 + … xn. If the last number is 1, then sum of the remaining numbers is n-1. So the number that ends with 1 is equal to DP[n-1]. Taking other cases into account where the last number is 3 and 4. The final recurrence would be:

`DPn = DPn-1 + DPn-3 + DPn-4`
```Base case :
DP = DP = DP = 1 and DP = 2```

## C++

 `// C++ program to illustrate the number of` `// ways to represent N as sum of 1, 3 and 4.` `#include ` `using` `namespace` `std;`   `// function to count the number of` `// ways to represent n as sum of 1, 3 and 4` `int` `countWays(``int` `n)` `{` `    ``int` `DP[n + 1];`   `    ``// base cases` `    ``DP = DP = DP = 1;` `    ``DP = 2;`   `    ``// iterate for all values from 4 to n` `    ``for` `(``int` `i = 4; i <= n; i++) ` `        ``DP[i] = DP[i - 1] + DP[i - 3] + DP[i - 4];` `    `  `    ``return` `DP[n];` `}`   `// driver code` `int` `main()` `{` `    ``int` `n = 10;` `    ``cout << countWays(n);` `    ``return` `0;` `}`

## Java

 `// Java program to illustrate ` `// the number of ways to represent ` `// N as sum of 1, 3 and 4.`   `class` `GFG {`   `    ``// Function to count the ` `    ``// number of ways to represent ` `    ``// n as sum of 1, 3 and 4` `    ``static` `int` `countWays(``int` `n)` `    ``{` `        ``int` `DP[] = ``new` `int``[n + ``1``];`   `        ``// base cases` `        ``DP[``0``] = DP[``1``] = DP[``2``] = ``1``;` `        ``DP[``3``] = ``2``;`   `        ``// iterate for all values from 4 to n` `        ``for` `(``int` `i = ``4``; i <= n; i++)` `            ``DP[i] = DP[i - ``1``] + DP[i - ``3``] ` `                    ``+ DP[i - ``4``];`   `        ``return` `DP[n];` `    ``}`   `    ``// driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``10``;` `        ``System.out.println(countWays(n));` `    ``}` `}`   `// This code is contributed ` `// by prerna saini.`

## Python3

 `# Python program to illustrate the number of` `# ways to represent N as sum of 1, 3 and 4.`   `# Function to count the number of` `# ways to represent n as sum of 1, 3 and 4` `def` `countWays(n):`   `    ``DP ``=` `[``0` `for` `i ``in` `range``(``0``, n ``+` `1``)]` `    `  `    ``# base cases` `    ``DP[``0``] ``=` `DP[``1``] ``=` `DP[``2``] ``=` `1` `    ``DP[``3``] ``=` `2`   `    ``# Iterate for all values from 4 to n` `    ``for` `i ``in` `range``(``4``, n ``+` `1``):` `        ``DP[i] ``=` `DP[i ``-` `1``] ``+` `DP[i ``-` `3``] ``+` `DP[i ``-` `4``]` `    `  `    ``return` `DP[n]`   `    `  `# Driver code ` `n ``=` `10` `print` `(countWays(n))`   `# This code is contributed by Gitanjali.`

## C#

 `// C# program to illustrate ` `// the number of ways to represent ` `// N as sum of 1, 3 and 4.` `using` `System;`   `class` `GFG {`   `    ``// Function to count the ` `    ``// number of ways to represent ` `    ``// n as sum of 1, 3 and 4` `    ``static` `int` `countWays(``int` `n)` `    ``{` `        ``int` `[]DP = ``new` `int``[n + 1];`   `        ``// base cases` `        ``DP = DP = DP = 1;` `        ``DP = 2;`   `        ``// iterate for all values from 4 to n` `        ``for` `(``int` `i = 4; i <= n; i++)` `            ``DP[i] = DP[i - 1] + DP[i - 3] ` `                    ``+ DP[i - 4];`   `        ``return` `DP[n];` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 10;` `        ``Console.WriteLine(countWays(n));` `    ``}` `}`   `// This code is contributed ` `// by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

`64`

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

Method – 2: Constant Space Complexity Solution (O(1) space complexity)

In the above solution we are storing all the dp states, i.e. we create n + 1 size dp array, but to calculate the particular dp[i state we only need the dp[i-1], dp[i-3] and dp[i-4] states. so we can use this observation and conclude that we only store the previous 4 states to calculate the current dp[i] state.

so here we use

```dp_i which store dp[i]
dp_i_1 which store dp[i-1]
dp_i_2 which store dp[i-2]
dp_i_3 which store dp[i-3]
dp_i_4 which store dp[i-4] ```

so in this solution we only need 5 variable so space complexity = O(5) ~= O(1)

below is the Implementation for this approach

## C++

 `// C++ program to illustrate the number of ways to represent N as sum of 1, 3 and 4.`   `#include ` `using` `namespace` `std;`   `// function to count the number of ways to represent n as sum of 1, 3 and 4` `int` `countWays(``int` `n) {` `    ``int` `dp_i, dp_i_1, dp_i_2, dp_i_3, dp_i_4;`   `    ``if` `(n == 0 || n == 1 || n == 2) ``return` `1;` `    ``else` `if` `(n == 3) ``return` `2;`   `    ``// base cases` `    ``dp_i_4 = dp_i_3 = dp_i_2 = 1;` `    ``dp_i_1 = 2;`   `    ``// iterate for all values from 4 to n` `    ``for` `(``int` `i = 4; i <= n; i++) {` `        ``dp_i = dp_i_1 + dp_i_3 + dp_i_4;` `        ``// Updating Variable value so in next Iteration they become relevant ` `        ``dp_i_4 = dp_i_3;` `        ``dp_i_3 = dp_i_2;` `        ``dp_i_2 = dp_i_1;` `        ``dp_i_1 = dp_i;` `    ``}`   `    ``return` `dp_i;` `}`   `// driver code` `int` `main() {` `    ``int` `n = 10;` `    ``cout << countWays(n);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `public` `class` `Main {` `    ``// function to count the number of ways to represent n as sum of 1, 3 and 4` `    ``public` `static` `int` `countWays(``int` `n) {` `        ``int` `dp_i = ``0``, dp_i_1, dp_i_2, dp_i_3, dp_i_4;`   `        ``if` `(n == ``0` `|| n == ``1` `|| n == ``2``) ``return` `1``;` `        ``else` `if` `(n == ``3``) ``return` `2``;`   `        ``// base cases` `        ``dp_i_4 = dp_i_3 = dp_i_2 = ``1``;` `        ``dp_i_1 = ``2``;`   `        ``// iterate for all values from 4 to n` `        ``for` `(``int` `i = ``4``; i <= n; i++) {` `            ``dp_i = dp_i_1 + dp_i_3 + dp_i_4;` `            ``// Updating Variable value so in next Iteration they become relevant ` `            ``dp_i_4 = dp_i_3;` `            ``dp_i_3 = dp_i_2;` `            ``dp_i_2 = dp_i_1;` `            ``dp_i_1 = dp_i;` `        ``}`   `        ``return` `dp_i;` `    ``}`   `    ``// driver code` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `n = ``10``;` `        ``System.out.println(countWays(n));` `    ``}` `}`

## Python3

 `# Python program to illustrate the number of ways to represent N as sum of 1, 3 and 4.`   `# function to count the number of ways to represent n as sum of 1, 3 and 4` `def` `countWays(n):` `    ``if` `n ``=``=` `0` `or` `n ``=``=` `1` `or` `n ``=``=` `2``:` `        ``return` `1` `    ``elif` `n ``=``=` `3``:` `        ``return` `2`   `    ``# base cases` `    ``dp_i_4 ``=` `dp_i_3 ``=` `dp_i_2 ``=` `1` `    ``dp_i_1 ``=` `2`   `    ``# iterate for all values from 4 to n` `    ``for` `i ``in` `range``(``4``, n``+``1``):` `        ``dp_i ``=` `dp_i_1 ``+` `dp_i_3 ``+` `dp_i_4` `        ``# Updating Variable value so in next Iteration they become relevant ` `        ``dp_i_4, dp_i_3, dp_i_2, dp_i_1 ``=` `dp_i_3, dp_i_2, dp_i_1, dp_i`   `    ``return` `dp_i`   `# driver code` `n ``=` `10` `print``(countWays(n))`

## C#

 `using` `System;`   `public` `class` `GFG` `{` `    ``// function to count the number of ways to represent n as sum of 1, 3 and 4` `    ``public` `static` `int` `CountWays(``int` `n)` `    ``{` `        ``int` `dp_i = 0, dp_i_1, dp_i_2, dp_i_3, dp_i_4;`   `        ``if` `(n == 0 || n == 1 || n == 2) ``return` `1;` `        ``else` `if` `(n == 3) ``return` `2;`   `        ``// base cases` `        ``dp_i_4 = dp_i_3 = dp_i_2 = 1;` `        ``dp_i_1 = 2;`   `        ``// iterate for all values from 4 to n` `        ``for` `(``int` `i = 4; i <= n; i++)` `        ``{` `            ``dp_i = dp_i_1 + dp_i_3 + dp_i_4;` `            ``// Updating Variable value so in next Iteration they become relevant ` `            ``dp_i_4 = dp_i_3;` `            ``dp_i_3 = dp_i_2;` `            ``dp_i_2 = dp_i_1;` `            ``dp_i_1 = dp_i;` `        ``}`   `        ``return` `dp_i;` `    ``}`   `    ``// driver code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `n = 10;` `        ``Console.WriteLine(CountWays(n));` `    ``}` `}`

## Javascript

 `function` `countWays(n) {` `    ``let dp_i, dp_i_1, dp_i_2, dp_i_3, dp_i_4;`   `    ``if` `(n == 0 || n == 1 || n == 2) ``return` `1;` `    ``else` `if` `(n == 3) ``return` `2;`   `    ``// base cases` `    ``dp_i_4 = dp_i_3 = dp_i_2 = 1;` `    ``dp_i_1 = 2;`   `    ``// iterate for all values from 4 to n` `    ``for` `(let i = 4; i <= n; i++) {` `        ``dp_i = dp_i_1 + dp_i_3 + dp_i_4;` `        ``// Updating Variable value so in next Iteration they become relevant ` `        ``dp_i_4 = dp_i_3;` `        ``dp_i_3 = dp_i_2;` `        ``dp_i_2 = dp_i_1;` `        ``dp_i_1 = dp_i;` `    ``}`   `    ``return` `dp_i;` `}`   `// driver code` `let n = 10;` `console.log(countWays(n));`

Output

`64`

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

My Personal Notes arrow_drop_up
Related Articles