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 =4Output :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 = 12Output :25

**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:
*If (sum == 0 and noofthrowsleft ==0) return 1*. It means that sum x has

been achieved.*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 the 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 <bits/stdc++.h>` `using` `namespace` `std;` `#define mod 1000000007` `int` `dp[55][55];` `// 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.` |

## Javascript

`<script>` `// Javascript function to calculate the number of` `// ways to achieve sum x in n no of throws` `const mod = 1000000007;` `let dp = ` `new` `Array(55);` `for` `(let i = 0; i < 55; i++)` ` ` `dp[i] = ` `new` `Array(55).fill(-1);` `// Function to calculate recursively the` `// number of ways to get sum in given` `// throws and [1..m] values` `function` `NoofWays(face, throws, 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];` ` ` `let ans = 0;` ` ` `for` `(let 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` ` ` `let faces = 6, throws = 3, sum = 12;` ` ` `document.write(NoofWays(faces, throws, sum));` `</script>` |

**Output:**

25

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**