 Open in App
Not now

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

• Difficulty Level : Hard
• Last Updated : 16 Nov, 2022

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 :
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

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 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 ``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 donot``    ``// move into re-computation``    ``if` `(dp[throws][sum] != -1)``        ``return` `dp[throws][sum];` `    ``int` `ans = 0;``    ``for` `(``int` `i = 1; i <= face; i++) {` `        ``// Recursively 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 donot``        ``// move into re-computation``        ``if` `(dp[throwsVal][sum] != -``1``)``        ``{``            ``return` `dp[throwsVal][sum];``        ``}` `        ``int` `ans = ``0``;``        ``for` `(``int` `i = ``1``; i <= face; i++)``        ``{` `            ``// Recursively 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 donot``    ``# move into re-computation``    ``if` `(dp[throws][``sum``] !``=` `-``1``) :``        ``return` `dp[throws][``sum``];` `    ``ans ``=` `0``;``    ``for` `i ``in` `range``(``1``, face ``+` `1``) :` `        ``# Recursively 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 donot``        ``// move into re-computation``        ``if` `(dp[throwsVal,sum] != -1)``        ``{``            ``return` `dp[throwsVal,sum];``        ``}` `        ``int` `ans = 0;``        ``for` `(``int` `i = 1; i <= face; i++)``        ``{` `            ``// Recursively 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

 ``

Output:

`25`

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

My Personal Notes arrow_drop_up