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

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC Roll(BYTE sides,dices)

Test(4,9,6,6)

Test(10,5,7,6)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Dice_game_probabilities.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

 

New_Line;

end Main;

{{output}}

<pre>

==={{header|BASIC256}}===

{{trans|Yabasic}}

dado2 = 6: lado2 = 6

total1 = 0: total2 = 0

next lanza

return total

{{out}}

<pre>

==={{header|FreeBASIC}}===

{{trans|Gambas}}

Dim As Integer dado1 = 9, lado1 = 4

Dim As Integer dado2 = 6, lado2 = 6

Next i

 

{{out}}

<pre>

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

dado2 = 6: lado2 = 6

total1 = 0: total2 = 0

next lanza

return total

{{out}}

<pre>

 

=={{header|C}}==

#include <stdint.h>

 

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

return 0;

{{out}}

<pre>0.5731440767829801

 

=={{header|C++}}==

#include <cstdint>

#include <iomanip>

std::cout << probability(5, 10, 6, 7) << '\n';

return 0;

 

{{out}}

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

 

=={{header|Factor}}==

IN: rosetta-code.dice-probabilities

 

 

9 4 6 6 winning-prob

{{out}}

<pre>

{{works with|gforth|0.7.3}}

<br>

 

\ Dice game probabilities

 

bye

 

{{out}}

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

=={{header|JacaScript}}==

===simulating===

let Player = function(dice, faces) {

this.dice = dice;

p2 = new Player(6, 7);

contest(p1, p2, 1e6);

{{out}}

<pre>

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

 

 

beatingProbability(4; 9; 6; 6),

{{out}}

<pre>

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

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

GetProbability[{dice1_List, n_Integer}, {dice2_List, m_Integer}] :=

Module[{a, b, lena, lenb},

]

GetProbability[{Range[4], 9}, {Range[6], 6}]

{{out}}

<pre>48679795/84934656

=={{header|Nim}}==

{{libheader|bignum}}

from math import sum

 

 

echo beatingProbability(9, 4, 6, 6).toFloat

 

{{out}}

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">throwDie</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">nSides</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">nDice</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">counts</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%0.16f\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">beatingProbability</span><span style="color: #0000FF;">(</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">))</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%0.16f\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">beatingProbability</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">))</span>

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

=={{header|R}}==

Solving these sorts of problems by simulation is trivial in R.

{

mean(replicate(10^6, sum(sample(facesCount1, diceCount1, replace = TRUE)) > sum(sample(facesCount2, diceCount2, replace = TRUE))))

}

cat("Player 1's probability of victory is", probability(4, 9, 6, 6),

{{out}}

<pre>Player 1's probability of victory is 0.572652 in the first game and 0.642817 in the second.</pre>

=={{header|Racket}}==

 

 

(define probs# (make-hash))

 

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

 

{{out}}

(formerly Perl 6)

{{works with|Rakudo|2020.08.1}}

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

my @counts;

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

say .gist, "\t", .raku given beating-probability < 9d4 6d6 >;

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

numeric digits 100 /*increase/decrease to heart's desire. */

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

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>

 

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

 

=={{header|Rust}}==

// values can occur.

fn get_totals(dice: usize, faces: usize) -> Vec<f64> {

println!("{}", probability(9, 4, 6, 6));

println!("{}", probability(5, 10, 6, 7));

 

{{out}}

=={{header|Sidef}}==

{{trans|Python}}

n || return [1]

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

 

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

{{trans|Go}}

 

fn min_of(x int, y int) int {

println(beating_probability(4, 9, 6, 6))

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

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

throwDie = Fn.new { |nSides, nDice, s, counts|

if (nDice == 0) {

 

System.print(beatingProbability.call(4, 9, 6, 6))

 

{{out}}

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