Skip to content
Related Articles
Count number of ways to divide a number in 4 parts
• Difficulty Level : Medium
• Last Updated : 13 Apr, 2021

Given a positive integer n, find number of ways to divide n in four parts or represent n as sum of four positive integers. Here n varies from 0 to 5000.
Examples :

```Input:  n =  5
Output: 1
There is only one way (1, 1, 1, 2)

Input:  n =  6
Output: 2
There are two ways (1, 1, 1, 3) and
(1, 1, 2, 2)

Input:  n =  8
Output: 5
There are five ways (2, 2, 2, 2), (1, 1, 1, 5),
(1, 1, 3, 3), (1, 1, 2, 4) and (1, 2, 2, 3)```

Method 1 (Simple Solution) Run four nested loops to generate all possible different quadruplet. Below is C++ implementation of the simple algorithm.
Below is the implementation of above approach:

## C++

 `// A Simple C++ program to count number of ways to``// represent a number n as sum of four.``#include``using` `namespace` `std;` `// Returns count of ways``int` `countWays(``int` `n)``{``    ``int` `counter = 0; ``// Initialize result` `    ``// Generate all possible quadruplet and increment``    ``// counter when sum of a quadruplet is equal to n``    ``for` `(``int` `i = 1; i < n; i++)``        ``for` `(``int` `j = i; j < n; j++)``            ``for` `(``int` `k = j; k < n; k++)``                ``for` `(``int` `l = k; l < n; l++)``                    ``if` `(i + j + k + l == n)``                       ``counter++;``    ``return` `counter;``}` `// Driver program``int` `main()``{``   ``int` `n = 8;``   ``cout << countWays(n);``   ``return` `0;``}`

## Java

 `// A Simple Java  program to count number of ways to``// represent a number n as sum of four.` `import` `java.io.*;` `class` `GFG {``    ` `// Returns count of ways``static` `int` `countWays(``int` `n)``{``    ``int` `counter = ``0``; ``// Initialize result` `    ``// Generate all possible quadruplet and increment``    ``// counter when sum of a quadruplet is equal to n``    ``for` `(``int` `i = ``1``; i < n; i++)``        ``for` `(``int` `j = i; j < n; j++)``            ``for` `(``int` `k = j; k < n; k++)``                ``for` `(``int` `l = k; l < n; l++)``                    ``if` `(i + j + k + l == n)``                    ``counter++;``    ``return` `counter;``}` `// Driver program``    ` `    ``public` `static` `void` `main (String[] args) {``        ``int` `n = ``8``;``        ``System.out.println (countWays(n));``    ``}``}`

## Python3

 `# A Simple python3 program to count``# number of ways to represent a number``# n as sum of four.` `# Returns count of ways``def` `countWays(n):` `    ``counter ``=` `0` `# Initialize result` `    ``# Generate all possible quadruplet``    ``# and increment counter when sum of``    ``# a quadruplet is equal to n``    ``for` `i ``in` `range``(``1``, n):``        ``for` `j ``in` `range``(i, n):``            ``for` `k ``in` `range``(j, n):``                ``for` `l ``in` `range``(k, n):``                    ``if` `(i ``+` `j ``+` `k ``+` `l ``=``=` `n):``                        ``counter ``+``=` `1``    ``return` `counter` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``n ``=` `8``    ``print` `(countWays(n))` `# This code is contributed by ita_c`

## C#

 `// A Simple C# program to count number``// of ways to represent a number n as``// sum of four.``using` `System;` `class` `GFG``{``        ` `// Returns count of ways``static` `int` `countWays(``int` `n)``{``    ``int` `counter = 0; ``// Initialize result` `    ``// Generate all possible quadruplet``    ``// and increment counter when sum of``    ``// a quadruplet is equal to n``    ``for` `(``int` `i = 1; i < n; i++)``        ``for` `(``int` `j = i; j < n; j++)``            ``for` `(``int` `k = j; k < n; k++)``                ``for` `(``int` `l = k; l < n; l++)``                    ``if` `(i + j + k + l == n)``                    ``counter++;``    ``return` `counter;``}` `// Driver Code``static` `public` `void` `Main ()``{``    ``int` `n = 8;``    ``Console.WriteLine(countWays(n));``}``}` `// This code is contributed by Sachin`

## PHP

 ``

## Javascript

 ``

Output :

`5`

Time complexity of above solution is O(n4)
Method 2 (Uses Dynamic Programming)
The idea is based on below recursive solution.

```countWays(n, parts, nextPart) = ∑countWays(n, parts, i)
nextPart <= i  Input number
parts    --> Count of parts of n. Initially parts = 4
nextPart --> Starting point for next part to be tried
We try for all values from nextPart to n.

We initially call the function as countWays(n, 4, 1)
```

Below is Dynamic Programming based on solution of above idea.

## C++

 `// A Dynamic Programming based solution to count number``// of ways to represent n as sum of four numbers``#include``using` `namespace` `std;``int` `dp;` `// "parts" is number of parts left, n is the value left``// "nextPart" is starting point from where we start trying``// for next part.``int` `countWaysUtil(``int` `n, ``int` `parts, ``int` `nextPart)``{``    ``// Base cases``    ``if` `(parts == 0 && n == 0) ``return` `1;``    ``if` `(n <= 0 || parts <= 0) ``return` `0;` `    ``// If this subproblem is already solved``    ``if` `(dp[n][nextPart][parts] != -1)``       ``return` `dp[n][nextPart][parts];` `    ``int` `ans = 0; ``// Initialize result` `    ``// Count number of ways for remaining number n-i``    ``// remaining parts "parts-1", and for all part``    ``// varying from 'nextPart' to 'n'``    ``for` `(``int` `i = nextPart; i <= n; i++)``        ``ans += countWaysUtil(n-i, parts-1, i);` `    ``// Store computed answer in table and return``    ``// result``    ``return` `(dp[n][nextPart][parts] = ans);``}` `// This function mainly initializes dp table and``// calls countWaysUtil()``int` `countWays(``int` `n)``{``    ``memset``(dp, -1, ``sizeof``(dp));``    ``return` `countWaysUtil(n, 4, 1);``}` `// Driver program``int` `main()``{``   ``int` `n = 8;``   ``cout << countWays(n) << endl;``   ``return` `0;``}`

## Java

 `// A Dynamic Programming based solution to count number``// of ways to represent n as sum of four numbers``class` `GFG``{` `static` `int` `dp[][][] = ``new` `int``[``5001``][``5001``][``5``];` `// "parts" is number of parts left, n is the value left``// "nextPart" is starting point from where we start trying``// for next part.``static` `int` `countWaysUtil(``int` `n, ``int` `parts, ``int` `nextPart)``{``    ``// Base cases``    ``if` `(parts == ``0` `&& n == ``0``) ``return` `1``;``    ``if` `(n <= ``0` `|| parts <= ``0``) ``return` `0``;` `    ``// If this subproblem is already solved``    ``if` `(dp[n][nextPart][parts] != -``1``)``    ``return` `dp[n][nextPart][parts];` `    ``int` `ans = ``0``; ``// Initialize result` `    ``// Count number of ways for remaining number n-i``    ``// remaining parts "parts-1", and for all part``    ``// varying from 'nextPart' to 'n'``    ``for` `(``int` `i = nextPart; i <= n; i++)``        ``ans += countWaysUtil(n-i, parts-``1``, i);` `    ``// Store computed answer in table and return``    ``// result``    ``return` `(dp[n][nextPart][parts] = ans);``}` `// This function mainly initializes dp table and``// calls countWaysUtil()``static` `int` `countWays(``int` `n)``{``    ``for``(``int` `i = ``0``; i < ``5001``; i++)``    ``{``        ``for``(``int` `j = ``0``; j < ``5001``; j++)``        ``{``            ``for``(``int` `l = ``0``; l < ``5``; l++)``            ``dp[i][j][l] = -``1``;``        ``}``    ``}``    ``return` `countWaysUtil(n, ``4``, ``1``);``}` `// Driver program``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``8``;``    ``System.out.println(countWays(n));``}``}` `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# A Dynamic Programming based solution``# to count number of ways to represent``# n as sum of four numbers` `dp ``=` `[[[``-``1` `for` `i ``in` `range``(``5``)]``           ``for` `i ``in` `range``(``501``)]``           ``for` `i ``in` `range``(``501``)]` `# "parts" is number of parts left, n is``# the value left "nextPart" is starting``# point from where we start trying``# for next part.``def` `countWaysUtil(n, parts, nextPart):``    ` `    ``# Base cases``    ``if` `(parts ``=``=` `0` `and` `n ``=``=` `0``):``        ``return` `1``    ``if` `(n <``=` `0` `or` `parts <``=` `0``):``        ``return` `0` `    ``# If this subproblem is already solved``    ``if` `(dp[n][nextPart][parts] !``=` `-``1``):``        ``return` `dp[n][nextPart][parts]` `    ``ans ``=` `0` `# Initialize result` `    ``# Count number of ways for remaining``    ``# number n-i remaining parts "parts-1",``    ``# and for all part varying from``    ``# 'nextPart' to 'n'``    ``for` `i ``in` `range``(nextPart, n ``+` `1``):``        ``ans ``+``=` `countWaysUtil(n ``-` `i, parts ``-` `1``, i)` `    ``# Store computed answer in table``    ``# and return result``    ``dp[n][nextPart][parts] ``=` `ans``    ``return` `(ans)` `# This function mainly initializes dp``# table and calls countWaysUtil()``def` `countWays(n):``    ``return` `countWaysUtil(n, ``4``, ``1``)` `# Driver Code``n ``=` `8``print``(countWays(n))` `# This code is contributed``# by sahishelangia`

## C#

 `// A Dynamic Programming based solution to count number``// of ways to represent n as sum of four numbers``using` `System;``    ` `class` `GFG``{` `static` `int` `[,,]dp = ``new` `int``[5001, 5001, 5];` `// "parts" is number of parts left, n is the value left``// "nextPart" is starting point from where we start trying``// for next part.``static` `int` `countWaysUtil(``int` `n, ``int` `parts, ``int` `nextPart)``{``    ``// Base cases``    ``if` `(parts == 0 && n == 0) ``return` `1;``    ``if` `(n <= 0 || parts <= 0) ``return` `0;` `    ``// If this subproblem is already solved``    ``if` `(dp[n,nextPart,parts] != -1)``    ``return` `dp[n,nextPart,parts];` `    ``int` `ans = 0; ``// Initialize result` `    ``// Count number of ways for remaining number n-i``    ``// remaining parts "parts-1", and for all part``    ``// varying from 'nextPart' to 'n'``    ``for` `(``int` `i = nextPart; i <= n; i++)``        ``ans += countWaysUtil(n - i, parts - 1, i);` `    ``// Store computed answer in table and return``    ``// result``    ``return` `(dp[n,nextPart,parts] = ans);``}` `// This function mainly initializes dp table and``// calls countWaysUtil()``static` `int` `countWays(``int` `n)``{``    ``for``(``int` `i = 0; i < 5001; i++)``    ``{``        ``for``(``int` `j = 0; j < 5001; j++)``        ``{``            ``for``(``int` `l = 0; l < 5; l++)``            ``dp[i, j, l] = -1;``        ``}``    ``}``    ``return` `countWaysUtil(n, 4, 1);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 8;``    ``Console.WriteLine(countWays(n));``}``}` `// This code contributed by Rajput-Ji`

## PHP

 ``

## Javascript

 ``

Output :

`5`

Time complexity of this solution is O(n3). There are Θ(n2) entries, every entry is filled only once and filling an entry takes O(n) time.
Method 3 (A O(n2 Log n) Solution)
We can use the solution discussed in this post to find all quadruplets.
Thanks to Gaurav Ahirwar for suggesting above solutions.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up