 Open in App
Not now

# Probability of getting all possible values on throwing N dices

• Difficulty Level : Medium
• Last Updated : 24 Feb, 2022

Given an integer N denoting the number of dices, the task is to find the probability of every possible value that can be obtained by throwing N dices together.

Examples:

Input: N = 1
Output:
1: 0.17
2: 0.17
3: 0.17
4: 0.17
5: 0.17
6: 0.17
Explanation: On throwing a dice, the probability of all values from [1, 6] to appear at the top is 1/6 = 0.17

Input: N = 2
Output:
2: 0.028
3: 0.056
4: 0.083
5: 0.11
6: 0.14
7: 0.17
8: 0.14
9: 0.11
10: 0.083
11: 0.056
12: 0.028
Explanation: The possible values of the sum of the two numbers that appear at the top on throwing two dices together ranges between [2, 12].

Approach: The idea is to use Dynamic programming and DP table to store the probability of each possible value.

• Store the probabilities of all the 6 numbers that can appear on throwing 1 dice.
• Now, for N=2, the probability for all possible sums between [2, 12] is equal to the sum of the product of the respective probability of the two numbers that add up to that sum. For example,

Probability of 4 on throwing 2 dices = (Probability of 1 ) * ( Probability of 3) + (Probability of 2) * ( Probability of 2) + (Probability of 3 ) * ( Probability of 1)

• Hence for N dices,

Probability of Sum S = (Probability of 1) * (Probability of S – 1 using N -1 dices) + (Probability of 2) * (Probability of S – 2 using N-1 dices) + ….. + (Probability of 6) * (Probability of S – 6 using N -1 dices)

• Hence, in order to solve the problem, we need to fill dp[][] table from 2 to N using a top-down approach using the relation:

dp[i][x] = dp[y] + dp[i-1][z] where x = y + z and i denotes the number of dices

• Display all the probabilities stored for N as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ Program to calculate` `// the probability of` `// all the possible values` `// that can be obtained` `// throwing N dices`   `#include ` `using` `namespace` `std;`   `void` `dicesSum(``int` `n)` `{` `    ``// Store the probabilities` `    ``vector > dp(n + 1);` `    ``// Precompute the probabilities` `    ``// for values possible using 1 dice` `    ``dp = { { 1, 1 / 6.0 },` `              ``{ 2, 1 / 6.0 },` `              ``{ 3, 1 / 6.0 },` `              ``{ 4, 1 / 6.0 },` `              ``{ 5, 1 / 6.0 },` `              ``{ 6, 1 / 6.0 } };`   `    ``// Compute the probabilities` `    ``// for all values from 2 to N` `    ``for` `(``int` `i = 2; i <= n; i++) {` `        ``for` `(``auto` `a1 : dp[i - 1]) {` `            ``for` `(``auto` `a2 : dp) {` `                ``dp[i][a1.first + a2.first]` `                    ``+= a1.second * a2.second;` `            ``}` `        ``}` `    ``}` `    ``// Print the result` `    ``for` `(``auto` `a : dp[n]) {` `        ``cout << a.first << ``" "` `             ``<< setprecision(2)` `             ``<< a.second` `             ``<< endl;` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `n = 2;` `    ``dicesSum(n);`   `    ``return` `0;` `}`

## Java

 `// Java program to calculate` `// the probability of all the` `// possible values that can ` `// be obtained throwing N dices` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{`   `static` `void` `dicesSum(``int` `n)` `{` `    `  `    ``// Store the probabilities` `    ``double``[][] dp = ``new` `double``[n + ``1``][``6` `* n + ``1``];`   `    ``// Precompute the probabilities` `    ``// for values possible using 1 dice` `    ``for``(``int` `i = ``1``; i <= ``6``; i++)` `        ``dp[``1``][i] = ``1` `/ ``6.0``;`   `    ``// Compute the probabilities` `    ``// for all values from 2 to N` `    ``for``(``int` `i = ``2``; i <= n; i++)` `        ``for``(``int` `j = i - ``1``; j <= ``6` `* (i - ``1``); j++)` `            ``for``(``int` `k = ``1``; k <= ``6``; k++)` `            ``{` `                ``dp[i][j + k] += (dp[i - ``1``][j] * ` `                                 ``dp[``1``][k]);` `            ``}`   `    ``// Print the result` `    ``for``(``int` `i = n; i <= ``6` `* n; i++)` `    ``{` `        ``System.out.println(i + ``" "` `+ ` `                           ``Math.round(dp[n][i] * ``1000.0``) / ` `                                                 ``1000.0``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``2``;` `    `  `    ``dicesSum(n);` `}` `}`   `// This code is contributed by jithin`

## Python3

 `# Python3 program to calculate` `# the probability of all the ` `# possible values that can ` `# be obtained throwing N dices` `def` `diceSum(n):` `    `  `    ``# Initialize a 2d array upto ` `    ``# (n*total sum possible) sum ` `    ``# with value 0` `    ``dp ``=` `[[ ``0` `for` `j ``in` `range``(n ``*` `6``)]` `              ``for` `i ``in` `range``(n ``+` `1``)]` `                  `  `    ``# Store the probability in a ` `    ``# single throw for 1,2,3,4,5,6` `    ``for` `i ``in` `range``(``6``):` `        ``dp[``1``][i] ``=` `1` `/` `6` `        `  `    ``# Compute the probabilities ` `    ``# for all values from 2 to N ` `    ``for` `i ``in` `range``(``2``, n ``+` `1``):` `        ``for` `j ``in` `range``(``len``(dp[i ``-` `1``])):` `            ``for` `k ``in` `range``(``6``):` `                    `  `                ``if` `(dp[i ``-` `1``][j] !``=` `0` `and` `                    ``dp[i ``-` `1``][k] !``=` `0``):` `                    ``dp[i][j ``+` `k] ``+``=` `(dp[i ``-` `1``][j] ``*` `                                     ``dp[``1``][k])` `    `  `    ``# Print the result ` `    ``for` `i ``in` `range``(``len``(dp[n]) ``-` `n ``+` `1``):` `        ``print``(``"%d %0.3f"` `%` `(i ``+` `n, dp[n][i]))`   `# Driver code` `n ``=` `2`   `# Call the function` `diceSum(n)`   `# This code is contributed by dipesh99kumar`

## C#

 `// C# program to calculate` `// the probability of all the` `// possible values that can ` `// be obtained throwing N dices` `using` `System;` `class` `GFG {` `    `  `    ``static` `void` `dicesSum(``int` `n)` `    ``{` `         `  `        ``// Store the probabilities` `        ``double``[,] dp = ``new` `double``[n + 1,6 * n + 1];` `     `  `        ``// Precompute the probabilities` `        ``// for values possible using 1 dice` `        ``for``(``int` `i = 1; i <= 6; i++)` `            ``dp[1,i] = 1 / 6.0;` `     `  `        ``// Compute the probabilities` `        ``// for all values from 2 to N` `        ``for``(``int` `i = 2; i <= n; i++)` `            ``for``(``int` `j = i - 1; j <= 6 * (i - 1); j++)` `                ``for``(``int` `k = 1; k <= 6; k++)` `                ``{` `                    ``dp[i,j + k] += (dp[i - 1,j] * ` `                                     ``dp[1,k]);` `                ``}` `     `  `        ``// Print the result` `        ``for``(``int` `i = n; i <= 6 * n; i++)` `        ``{` `            ``Console.WriteLine(i + ``" "` `+ ` `                               ``Math.Round(dp[n,i] * 1000.0) / ` `                                                     ``1000.0);` `        ``}` `    ``}`   `  ``static` `void` `Main() {` `    ``int` `n = 2;` ` `  `    ``dicesSum(n);` `  ``}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

Output:

```2 0.028
3 0.056
4 0.083
5 0.11
6 0.14
7 0.17
8 0.14
9 0.11
10 0.083
11 0.056
12 0.028```

Time Complexity: O(N2)
Auxiliary Space: O(N2)

My Personal Notes arrow_drop_up
Related Articles