 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));``    ``}``}`

Output

`64`

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

My Personal Notes arrow_drop_up