# Number of ways to get a given sum with n number of m-faced dices

Given n dices each with m faces, numbered from 1 to m, find the number of ways to get a given sum X. X is the summation of values on each face when all the dice are thrown.

Examples:

Input : faces = 4 throws = 2 sum =4
Output : 3
Ways to reach sum equal to 4 in 2 throws can be { (1, 3), (2, 2), (3, 1) }

Input : faces = 6 throws = 3 sum = 12
Output : 25

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
Basically, it is asked to achieve sum in n number of operations using the values in the range [1…m].
Use dynamic programming top down methodology for this problem. The steps are:

• Base Cases:
1. If (sum == 0 and noofthrowsleft ==0) return 1 . It means that sum x has
been achieved.
2. If (sum < 0 and noofthrowsleft ==0) return 0.It means that sum x has not
been achieved in all throws.
• If present sum with present noofthrowsleft is already achieved then return it from table instead of re computation.
• Then we will loop through all the values of faces from i=[1..m] and recursively moving to achieve sum-i and also decrease the noofthrowsleft by 1.
• Finally we will store current values in the dp array

Below is the implementation of the above method:

## C++

 `// C++ function to calculate the number of ` `// ways to achieve sum x in n no of throws ` `#include ` `using` `namespace` `std; ` `#define mod 1000000007 ` `int` `dp; ` ` `  `// Function to calculate recursively the ` `// number of ways to get sum in given ` `// throws and [1..m] values ` `int` `NoofWays(``int` `face, ``int` `throws, ``int` `sum) ` `{ ` `    ``// Base condition 1 ` `    ``if` `(sum == 0 && throws == 0) ` `        ``return` `1; ` ` `  `    ``// Base condition 2 ` `    ``if` `(sum < 0 || throws == 0) ` `        ``return` `0; ` ` `  `    ``// If value already calculated dont ` `    ``// move into re-computation ` `    ``if` `(dp[throws][sum] != -1) ` `        ``return` `dp[throws][sum]; ` ` `  `    ``int` `ans = 0; ` `    ``for` `(``int` `i = 1; i <= face; i++) { ` ` `  `        ``// Recusively moving for sum-i in ` `        ``// throws-1 no of throws left ` `        ``ans += NoofWays(face, throws - 1, sum - i); ` `    ``} ` ` `  `    ``// Inserting present values in dp ` `    ``return` `dp[throws][sum] = ans; ` `} ` ` `  `// Driver function ` `int` `main() ` `{ ` `    ``int` `faces = 6, throws = 3, sum = 12; ` ` `  `    ``memset``(dp, -1, ``sizeof` `dp); ` ` `  `    ``cout << NoofWays(faces, throws, sum) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java function to calculate the number of  ` `// ways to achieve sum x in n no of throwsVal  ` `class` `GFG  ` `{ ` ` `  `    ``static` `int` `mod = ``1000000007``; ` `    ``static` `int``[][] dp = ``new` `int``[``55``][``55``]; ` ` `  `    ``// Function to calculate recursively the  ` `    ``// number of ways to get sum in given  ` `    ``// throwsVal and [1..m] values  ` `    ``static` `int` `NoofWays(``int` `face, ``int` `throwsVal, ``int` `sum) ` `    ``{ ` `        ``// Base condition 1  ` `        ``if` `(sum == ``0` `&& throwsVal == ``0``) ` `        ``{ ` `            ``return` `1``; ` `        ``} ` ` `  `        ``// Base condition 2  ` `        ``if` `(sum < ``0` `|| throwsVal == ``0``)  ` `        ``{ ` `            ``return` `0``; ` `        ``} ` ` `  `        ``// If value already calculated dont  ` `        ``// move into re-computation  ` `        ``if` `(dp[throwsVal][sum] != -``1``)  ` `        ``{ ` `            ``return` `dp[throwsVal][sum]; ` `        ``} ` ` `  `        ``int` `ans = ``0``; ` `        ``for` `(``int` `i = ``1``; i <= face; i++) ` `        ``{ ` ` `  `            ``// Recusively moving for sum-i in  ` `            ``// throwsVal-1 no of throwsVal left  ` `            ``ans += NoofWays(face, throwsVal - ``1``, sum - i); ` `        ``} ` ` `  `        ``// Inserting present values in dp  ` `        ``return` `dp[throwsVal][sum] = ans; ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `faces = ``6``, throwsVal = ``3``, sum = ``12``; ` `        ``for` `(``int` `i = ``0``; i < ``55``; i++)  ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < ``55``; j++)  ` `            ``{ ` `                ``dp[i][j] = -``1``; ` `            ``} ` `        ``} ` ` `  `        ``System.out.println(NoofWays(faces, throwsVal, sum)); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 function to calculate the number of  ` `# ways to achieve sum x in n no of throws  ` `import` `numpy as np ` ` `  `mod ``=` `1000000007``; ` ` `  `dp ``=` `np.zeros((``55``,``55``));  ` ` `  `# Function to calculate recursively the  ` `# number of ways to get sum in given  ` `# throws and [1..m] values  ` `def` `NoofWays(face, throws, ``sum``) :  ` ` `  `    ``# Base condition 1  ` `    ``if` `(``sum` `=``=` `0` `and` `throws ``=``=` `0``) : ` `        ``return` `1``;  ` ` `  `    ``# Base condition 2  ` `    ``if` `(``sum` `< ``0` `or` `throws ``=``=` `0``) : ` `        ``return` `0``;  ` ` `  `    ``# If value already calculated dont  ` `    ``# move into re-computation  ` `    ``if` `(dp[throws][``sum``] !``=` `-``1``) : ` `        ``return` `dp[throws][``sum``];  ` ` `  `    ``ans ``=` `0``;  ` `    ``for` `i ``in` `range``(``1``, face ``+` `1``) :  ` ` `  `        ``# Recusively moving for sum-i in  ` `        ``# throws-1 no of throws left  ` `        ``ans ``+``=` `NoofWays(face, throws ``-` `1``, ``sum` `-` `i);  ` ` `  `    ``# Inserting present values in dp  ` `    ``dp[throws][``sum``] ``=` `ans; ` `     `  `    ``return` `ans; ` ` `  ` `  `# Driver function  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``faces ``=` `6``; throws ``=` `3``; ``sum` `=` `12``;  ` ` `  `    ``for` `i ``in` `range``(``55``) : ` `        ``for` `j ``in` `range``(``55``) : ` `            ``dp[i][j] ``=` `-``1` ` `  `    ``print``(NoofWays(faces, throws, ``sum``)) ;  ` `     `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# function to calculate the number of  ` `// ways to achieve sum x in n no of throwsVal  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``static` `int``[,]dp = ``new` `int``[55,55]; ` ` `  `    ``// Function to calculate recursively the  ` `    ``// number of ways to get sum in given  ` `    ``// throwsVal and [1..m] values  ` `    ``static` `int` `NoofWays(``int` `face, ``int` `throwsVal, ``int` `sum) ` `    ``{ ` `        ``// Base condition 1  ` `        ``if` `(sum == 0 && throwsVal == 0) ` `        ``{ ` `            ``return` `1; ` `        ``} ` ` `  `        ``// Base condition 2  ` `        ``if` `(sum < 0 || throwsVal == 0)  ` `        ``{ ` `            ``return` `0; ` `        ``} ` ` `  `        ``// If value already calculated dont  ` `        ``// move into re-computation  ` `        ``if` `(dp[throwsVal,sum] != -1)  ` `        ``{ ` `            ``return` `dp[throwsVal,sum]; ` `        ``} ` ` `  `        ``int` `ans = 0; ` `        ``for` `(``int` `i = 1; i <= face; i++) ` `        ``{ ` ` `  `            ``// Recusively moving for sum-i in  ` `            ``// throwsVal-1 no of throwsVal left  ` `            ``ans += NoofWays(face, throwsVal - 1, sum - i); ` `        ``} ` ` `  `        ``// Inserting present values in dp  ` `        ``return` `dp[throwsVal,sum] = ans; ` `    ``} ` ` `  `    ``// Driver code  ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `faces = 6, throwsVal = 3, sum = 12; ` `        ``for` `(``int` `i = 0; i < 55; i++)  ` `        ``{ ` `            ``for` `(``int` `j = 0; j < 55; j++)  ` `            ``{ ` `                ``dp[i,j] = -1; ` `            ``} ` `        ``} ` ` `  `    ``Console.WriteLine(NoofWays(faces, throwsVal, sum)); ` `    ``} ` `} ` ` `  `// This code is contributed by ajit. `

Output:

```25
```

Time complexity : O(throws*faces)
Space complexity : O(faces*sum)

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 Competitive Programmer, Full Stack Developer, Technical Content Writer, Machine Learner

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : AnkitRai01, 29AjayKumar, jit_t