Related Articles
Number of ways to get a given sum with n number of m-faced dices
• Difficulty Level : Hard
• Last Updated : 01 Jul, 2019

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
Recommended Articles
Page :