Dice game probabilities: Difference between revisions

Two players have a set of dice each. The first player has nine dice with four faces each, with numbers one to four. The second player has six normal dice with six faces each, each face has the usual numbers from one to six.

 

This task was adapted from the Project Euler Problem n.205:

https://projecteuler.net/problem=205

 

=={{header|C}}==

#include <stdint.h>

 

printf("%1.16f\n", beating_probability(10, 5, 7, 6));

return 0;

{{out}}

<pre>0.5731440767829801

0.6427886287176260</pre>

 

=={{header|D}}==

===version 1===

 

void throwDie(in uint nSides, in uint nDice, in uint s, uint[] counts)

writefln("%1.16f", beatingProbability!(4, 9, 6, 6));

writefln("%1.16f", beatingProbability!(10, 5, 7, 6));

{{out}}

<pre>0.5731440767829801

===version 2 (Faster Alternative Version)===

{{trans|Python}}

 

ulong[] combos(R)(R sides, in uint n) pure nothrow @safe

writefln("%1.16f", winning(iota(1u, 5u), 9, iota(1u, 7u), 6));

writefln("%1.16f", winning(iota(1u, 11u), 5, iota(1u, 8u), 6));

{{out}}

<pre>0.5731440767829801

0.6427886287176262</pre>

 

=={{header|J}}==

'''Solution:'''

 

beating_probability =: dyad define

'C1 P1' =. gen_dict/ y

(C0 +/@:,@:(>/&:({."1) * */&:({:"1)) C1) % (P0 * P1)

'''Example Usage:'''

┌─────────────────────┬────────┐

│3781171969r5882450000│0.642789│

┌─────────────────┬────────┐

│48679795r84934656│0.573144│

gen_dict explanation:<br>

<code>gen_dict</code> is akin to <code>gen_dict</code> in the python solution and

 

=={{header|Java}}==

 

public class Dice{

System.out.println("p1 wins " + (100.0 * p1Wins / rolls) + "% of the time");

}

{{out}}

<pre>10000 rolls, p1 = 9d4, p2 = 6d6

1000000 rolls, p1 = 5d10, p2 = 6d7

p1 wins 64.279% of the time</pre>

 

=={{header|Kotlin}}==

{{trans|C}}

 

fun throwDie(nSides: Int, nDice: Int, s: Int, counts: IntArray) {

 

var tot = 0.0

tot += c1[i] * c2[j] / p12

return tot

}

println(beatingProbability(4, 9, 6, 6))

println(beatingProbability(10, 5, 7, 6))

 

{{out}}

0.6427886287176273

</pre>

 

=={{header|ooRexx}}==

===Algorithm===

Call test '9 4 6 6'

Call test '5 10 6 7'

psum+=p1.x

End

{{out}}

<pre>Player 1 has 9 dice with 4 sides each

 

===Algorithm using rational arithmetic===

Call test '9 4 6 6'

Call test '5 10 6 7'

Parse Arg a,b

if b = 0 then return abs(a)

{{out}}

<pre>Player 1 has 9 dice with 4 sides each

===Algorithm using class fraction===

Class definition adapted from Arithmetic/Raional.

Call test '9 4 6 6'

Call test '5 10 6 7'

::attribute denominator GET

 

{{out}}

<pre>Player 1 has 9 dice with 4 sides each

===Test===

Result from 10 million tries.

Call test '9 4 6 6'

Call test '5 10 6 7'

o:

Say arg(1)

 

{{out}}

=={{header|Perl}}==

{{trans|Python}}

 

sub comb {

 

print '(', join(', ', winning([1 .. 4], 9, [1 .. 6], 6)), ")\n";

{{out}}

<pre>

</pre>

 

{{out}}

 

=={{header|PL/I}}==

===version 1===

dicegame: Proc Options(main);

Call test(9, 4,6,6);

End;

End;

{{out}}

<pre>Player 1 has 9 dice with 4 sides each

Probability for player 1 to win: 0.642703175544738770</pre>

===version 2 using rational arithmetic===

dgf: Proc Options(main);

Call test(9, 4,6,6);

End;

 

{{out}}

<pre>Player 1 has 9 dice with 4 sides each

 

=={{header|Python}}==

 

def gen_dict(n_faces, n_dice):

 

print beating_probability(4, 9, 6, 6)

{{out}}

<pre>0.573144076783

 

To handle larger number of dice (and faster in general):

 

def combos(sides, n):

 

# mountains of dice test case

{{out}}

<pre>

 

If we further restrict die faces to be 1 to n instead of arbitrary values, the combo generation can be made much faster:

from itertools import accumulate # Python3 only

 

print(winning(5, 10, 6, 7))

 

{{out}}

<pre>

0.6427886287176262

</pre>

 

=={{header|Racket}}==

 

 

(define probs# (make-hash))

 

(printf "GAME 2 (5D10 vs 6D7) [what is a D7?]~%")

 

{{out}}

P(P2 win): 0.312715

(3781171969/5882450000 523491347/11764900000 735812943/2352980000)</pre>

 

=={{header|REXX}}==

{{trans|ooRexx}}

(adapted for Classic Rexx)

Call test '9 4 6 6'

Call test '5 10 6 7'

res=res p.x

End

{{out}}

<pre>

Call test '9 4 6 6'

Call test '5 10 6 7'

o:

Say arg(1)

{{out}}

 

===optimized===

call game 9 4, 6 6 /*1st player: 9 dice, 4 sides; 2nd player: 6 dice, 6 sides*/

call game 5 10, 6 7 /* " " 5 " 10 " " " 6 " 7 " */

/*──────────────────────────────────────────────────────────────────────────────────────*/

game: parse arg w.1 s.1, w.2 s.2 /*1st player(dice sides), 2nd player···*/

do k=w.j to w.j*s.j; parse var @@.j p.j.k @@.j; end /*k*/

end /*j*/

do j=w.1 to w.1*s.1

end /*j*/

end /*j*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

Player 1 has 9 dice with 4 sides each.

Player 2 has 6 dice with 6 sides each.

 

Player 1 has 5 dice with 10 sides each.

Player 2 has 6 dice with 7 sides each.

</pre>

 

=={{header|Ruby}}==

return [[0,1]] if n_dice.zero?

one = [1] * n_faces

puts "Probability for player 1 to win: #{win[1]} / #{sum}",

" -> #{win[1].fdiv(sum)}", ""

 

{{out}}

Probability for player 1 to win: 7562343938 / 11764900000

-> 0.6427886287176262

</pre>

 

=={{header|Sidef}}==

{{trans|Python}}

n || return [1]

var ret = ([0] * (n*sides.max + 1))

var (win,loss,tie) = (0,0,0)

p1.each_kv { |i, x|

}

}

 

say "=> #{title}"

for name, prob in (%w(p₁\ win tie p₂\ win) ~Z res) {

}

print "\n"

 

display_results('9D4 vs 6D6', winning(range(1, 4), 9, range(1,6), 6))

{{out}}

<pre>

 

To handle the nested loop in <tt>NdK</tt>, [[Tcl]]'s metaprogramming abilities are exercised. The goal is to produce a script that looks like:

foreach d1 {1 2 3 4 5 6} {

...

...

}

 

See the comments attached to that procedure for a more thorough understanding of how that is achieved (with the caveat that <tt>$d0..$dN</tt> are reversed).

Such metaprogramming is a very powerful technique in Tcl for building scripts where other approaches (in this case, recursion) might not be appealing, and should be in every programmer's toolbox!

 

set a 0

set res {}

puts [format "p1 has %dd%d; p2 has %dd%d" {*}$p1 {*}$p2]

puts [format " p1 wins with Pr(%s)" [win_pr [NdK {*}$p1] [NdK {*}$p2]]]

 

{{Out}}

I include this to <em>emphasise</em> the importance and power of metaprogramming in a Tcler's toolbox, as well as sharing a useful proc.

 

# This proc builds up a nested foreach call, then evaluates it.

#

foreach* {*}$args $script

return $sum

 

=={{header|zkl}}==

{{trans|Python}}

if(not n) return(T(1));

ret:=((0).max(sides)*n + 1).pump(List(),0);

s := p1.sum(0)*p2.sum(0);

return(win.toFloat()/s, tie.toFloat()/s, loss.toFloat()/s);

{{out}}

<pre>