Dice game probabilities: Difference between revisions

=={{header|11l}}==

{{trans|C}}

I n_dice == 0

counts[s]++

 

print(‘#.16’.format(beating_probability(4, 9, 6, 6)))

 

{{out}}

0.5731440767829814

0.6427886287176272

</pre>

 

=={{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|Factor}}==

IN: rosetta-code.dice-probabilities

 

 

9 4 6 6 winning-prob

{{out}}

<pre>

0.64174

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=ef255e4239a713aba35598a4617af3c9 Click this link to run this code]'''

 

Public Sub Main()

Return iTotal

 

Output:

<pre>

=={{header|Go}}==

{{trans|C}}

 

import(

fmt.Println(beatingProbability(4, 9, 6, 6))

fmt.Println(beatingProbability(10, 5, 7, 6))

 

{{out}}

More idiomatic go:

 

 

import (

fmt.Println(set{9, 4}.beats(set{6, 6}, 1000))

fmt.Println(set{5, 10}.beats(set{6, 7}, 1000))

 

{{out}}

=={{header|Haskell}}==

{{trans|Python}}

import Data.List (group, sort)

 

main = do

print $ (4, 9) `succeeds` (6, 6)

{{out}}

<pre>0.5731440767829815

=={{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|Julia}}==

{{works with|Julia|0.6}}

 

 

simulate(d1::Integer, f1::Integer, d2::Integer, f2::Integer; nrep::Integer=1_000_000) =

 

println("\nPlayer 1: 9 dices, 4 faces\nPlayer 2: 6 dices, 6 faces\nP(Player1 wins) = ", simulate(9, 4, 6, 6))

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

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

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

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

 

{{out}}

=={{header|Lua}}==

===Simulated===

local function simu(ndice1, nsides1, ndice2, nsides2)

local function roll(ndice, nsides)

simu(9, 4, 6, 6)

simu(5, 10, 6, 7)

{{out}}

<pre>

 

===Computed===

local function comp(ndice1, nsides1, ndice2, nsides2)

local function throws(ndice, nsides)

comp(9, 4, 6, 6)

comp(5, 10, 6, 7)

{{out}}

<pre>

computed: p1 = 5d10, p2 = 6d7, prob = 7562343938 / 11764900000 = 0.64278862871763

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

=={{header|Phix}}==

{{trans|Go}}

{{out}}

<small>

=={{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}}

=={{header|Raku}}==

(formerly Perl 6)

my ($dice, $faces) = $roll.comb(/\d+/);

my @counts;

 

# We're using standard DnD notation for dice rolls here.

{{out}}

<pre>0.573144077 <48679795/84934656>

{{trans|ooRexx}}

(adapted for Classic Rexx)

Numeric Digits 30

Call test '9 4 6 6'

res=res p.x

End

{{out}}

<pre>

 

===version 2===

oid='diet.xxx'; 'erase' oid

Call test '9 4 6 6'

o:

Say arg(1)

{{out}}

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

===optimized===

This REXX version is an optimized and reduced version of the first part of the 1^st REXX example.

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···*/

p.= 0

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

end /*j*/

low.= 0

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

end /*j*/

say ' Player 1 has ' w.1 " dice with " s.1 ' sides each.'

say ' Player 2 has ' w.2 " dice with " s.2 ' sides each.'

winP= 0

end /*j*/

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

@= @'_='; do k=1 for n-1; @= @"_"k'+' ; end /*k*/

ns= n*s; do j=0 to ns; p.j= #.j / pow; end /*j*/

do k=n to ns; $= $ p.k; end /*k*/

{{out|output|text=&nbsp; when using the default inputs:}}

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

}

[win, tie, loss] »/» p1.sum*p2.sum

 

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>