 Open in App
Not now

# Probability of getting a sum on throwing 2 Dices N times

• Last Updated : 25 Sep, 2022

Given the sum. The task is to find out the probability of occurring that sum on the thrown of the two dice N times.
Probability is defined as the favorable numbers of outcomes upon total numbers of the outcome. Probability always lies between 0 and 1.
Examples:

```Input: sum = 11, times = 1
Output: 2 / 36
favorable outcomes = (5, 6) and (6, 5) i.e 2
Total outcomes = (1, 1), (1, 2), (1, 3)...(6, 6) i.e 36
Probability = (2 / 36)

Input: sum = 7, times = 7
Output: 1 / 279936```

Formula:-

The probability of occurring sum on throwing 2 dices N times = (favorable/total) ^ N

Approach:-

First of All, Calculates the probability of Occurring that sum on thrown of 2 dice 1 times.
Let say it Probability1.
Now, to calculate the Probability of occurring that sum on thrown of 2 dice N times be:
Probability2 = (Probability1) ^ N. i.e Probability1 raise to power N

Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach` `#include ` `using` `namespace` `std;`   `// function that calculates Probability.` `int` `Probability(``int` `sum, ``int` `times)` `{`   `    ``float` `favorable = 0.0, total = 36.0;` `    ``long` `int` `probability = 0;`   `    ``// To calculate favorable outcomes` `    ``// in thrown of 2 dices 1 times.` `    ``for` `(``int` `i = 1; i <= 6; i++) {` `        ``for` `(``int` `j = 1; j <= 6; j++) {` `            ``if` `((i + j) == sum)` `                ``favorable++;` `        ``}` `    ``}`   `    ``int` `gcd1 = __gcd((``int``)favorable, (``int``)total);`   `    ``// Reduce to simplest Form.` `    ``favorable = favorable / (``float``)gcd1;` `    ``total = total / (``float``)gcd1;`   `    ``// Probability of occurring sum on 2 dice N times.` `    ``probability = ``pow``(total, times);`   `    ``return` `probability;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `sum = 7, times = 7;`   `    ``cout << ``"1"` `         ``<< ``"/"` `<< Probability(sum, times);` `    ``return` `0;` `}`

## Java

 `// Java implementation of above approach` `import` `java.io.*;`   `class` `GFG ` `{` `// Recursive function to return` `// gcd of a and b ` `static` `int` `__gcd(``int` `a, ``int` `b) ` `{ ` `    ``// Everything divides 0 ` `    ``if` `(a == ``0``) ` `    ``return` `b; ` `    ``if` `(b == ``0``) ` `    ``return` `a; ` `    `  `    ``// base case ` `    ``if` `(a == b) ` `        ``return` `a; ` `    `  `    ``// a is greater ` `    ``if` `(a > b) ` `        ``return` `__gcd(a - b, b); ` `    ``return` `__gcd(a, b - a); ` `}`   `// function that calculates ` `// Probability.` `static` `long` `Probability(``int` `sum,` `                        ``int` `times)` `{`   `    ``float` `favorable = ``0``, total = ``36``;` `    ``long` `probability = ``0``;`   `    ``// To calculate favorable outcomes` `    ``// in thrown of 2 dices 1 times.` `    ``for` `(``int` `i = ``1``; i <= ``6``; i++) ` `    ``{` `        ``for` `(``int` `j = ``1``; j <= ``6``; j++)` `        ``{` `            ``if` `((i + j) == sum)` `                ``favorable++;` `        ``}` `    ``}`   `    ``int` `gcd1 = __gcd((``int``)favorable, ` `                     ``(``int``)total);`   `    ``// Reduce to simplest Form.` `    ``favorable = favorable / (``float``)gcd1;` `    ``total = total / (``float``)gcd1;`   `    ``// Probability of occurring ` `    ``// sum on 2 dice N times.` `    ``probability = (``long``)Math.pow(total, times);`   `    ``return` `probability;` `}`   `// Driver Code` `public` `static` `void` `main (String[] args) ` `{` `    ``int` `sum = ``7``, times = ``7``;` `    `  `    ``System.out.println( ``"1"` `+ ``"/"` `+ ` `          ``Probability(sum, times));` `}` `}`   `// This code is contributed ` `// by inder_verma`

## Python 3

 `# Python 3 implementation of above approach`   `# from math import everything` `from` `math ``import` `*`   `# function that calculates Probability.` `def` `Probability(``sum``, times) :` `    ``favorable, total, probability ``=` `0.0``, ``36.0``, ``0`   `    ``# To calculate favorable outcomes ` `    ``# in thrown of 2 dices 1 times. ` `    ``for` `i ``in` `range``(``7``) :` `        ``for` `j ``in` `range``(``7``) :` `            ``if` `((i ``+` `j) ``=``=` `sum``) :` `                ``favorable ``+``=` `1`   `    ``gcd1 ``=` `gcd(``int``(favorable), ``int``(total))`   `    ``# Reduce to simplest Form. ` `    ``favorable ``=` `favorable ``/` `gcd1` `    ``total ``=` `total ``/` `gcd1`   `    ``# Probability of occurring sum on 2 dice N times.` `    ``probability ``=` `pow``(total, times)`   `    ``return` `int``(probability)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``sum``, times ``=` `7``, ``7`   `    ``print``(``"1"``,``"/"``,Probability(``sum``, times))`     `# This code is contributed by ANKITRAI1`

## C#

 `// C# implementation of above approach`   `class` `GFG ` `{` `// Recursive function to return` `// gcd of a and b ` `static` `int` `__gcd(``int` `a, ``int` `b) ` `{ ` `    ``// Everything divides 0 ` `    ``if` `(a == 0) ` `    ``return` `b; ` `    ``if` `(b == 0) ` `    ``return` `a; ` `    `  `    ``// base case ` `    ``if` `(a == b) ` `        ``return` `a; ` `    `  `    ``// a is greater ` `    ``if` `(a > b) ` `        ``return` `__gcd(a - b, b); ` `    ``return` `__gcd(a, b - a); ` `}`   `// function that calculates ` `// Probability.` `static` `long` `Probability(``int` `sum,` `                        ``int` `times)` `{`   `    ``float` `favorable = 0, total = 36;` `    ``long` `probability = 0;`   `    ``// To calculate favorable outcomes` `    ``// in thrown of 2 dices 1 times.` `    ``for` `(``int` `i = 1; i <= 6; i++) ` `    ``{` `        ``for` `(``int` `j = 1; j <= 6; j++)` `        ``{` `            ``if` `((i + j) == sum)` `                ``favorable++;` `        ``}` `    ``}`   `    ``int` `gcd1 = __gcd((``int``)favorable, ` `                    ``(``int``)total);`   `    ``// Reduce to simplest Form.` `    ``favorable = favorable / (``float``)gcd1;` `    ``total = total / (``float``)gcd1;`   `    ``// Probability of occurring ` `    ``// sum on 2 dice N times.` `    ``probability = (``long``)System.Math.Pow(total, times);`   `    ``return` `probability;` `}`   `// Driver Code` `public` `static` `void` `Main() ` `{` `    ``int` `sum = 7, times = 7;` `    `  `    ``System.Console.WriteLine( ``"1"` `+ ``"/"` `+ ` `        ``Probability(sum, times));` `}` `}`   `// This code is contributed ` `// by mits`

## PHP

 ``

## Javascript

 ``

Output:

`1/279936`

Time complexity: O(logN), for using gcd and pow functions.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles