Seven-sided dice from five-sided dice: Difference between revisions

{{task|Probability and statistics}}

Given an equal-probability generator of one of the integers 1 to 5

numbers, and check the distribution for at least 1000000 calls using the function created in [[Simple Random Distribution Checker]].

 

combinations are given, otherwise split the other 21 combinations

into 7 groups of three, and return the group index from the rolls.

 

=={{header|Ada}}==

The specification of a package Random_57:

<lang Ada>package Random_57 is

 

 

end Random_57;</lang>

Implementation of Random_57:

<lang Ada> with Ada.Numerics.Discrete_Random;

 

Rand_5.Reset(Gen);

end Random_57;</lang>

A main program, using the Random_57 package:

<lang Ada>with Ada.Text_IO, Random_57;

 

end if;

end Test;

 

begin

Test(10_000_000, Rand'Access, 0.01);

end R57;</lang>

A sample output:

<pre>

Sample Size: 10000

=={{header|ALGOL 68}}==

{{trans|C}} - note: This specimen retains the original [[Seven-sided dice from five-sided dice#C|C]] coding style.

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

C's version using no multiplications, divisions, or mod operators:

<lang algol68>PROC dice5 = INT:

printf(check(rand7, 7, 1000000, .05) ? "flat\n" : "not flat\n");

return 0;

flat

</pre>

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

This solution tries to minimize calls to the underlying d5 by reusing information from earlier calls.

<lang cpp>template<typename F> class fivetoseven

{

 

=={{header|E}}==

{{trans|Common Lisp}}

{{improve|E|Write dice7 in a prettier fashion and use the distribution checker once it's been written.}}

<lang e>def dice5() {

return entropy.nextInt(5) + 1

return d55 %% 7 + 1

}</lang>

<lang e>def bins := ([0] * 7).diverge()

for x in 1..1000 {

Distribution potentially skewed for bucket 6 Expected: 142857 Actual: 142163

Distribution potentially skewed for bucket 7 Expected: 142857 Actual: 142513</pre>

=={{header|Go}}==

<lang go>package main

 

=={{header|Groovy}}==

<lang groovy>random = new Random()

 

(raw % 7) + 1

}</lang>

Test:

<lang groovy>def test = {

test(it)

}</lang>

Output:

<pre style="height:30ex;overflow:scroll;">TRIAL #1

 

=={{header|Icon}} and {{header|Unicon}}==

{{trans|Ruby}}

Uses <code>verify_uniform</code> from [[Simple_Random_Distribution_Checker#Icon_and_Unicon|here]].

<lang Icon>

$include "distribution-checker.icn"

 

getD7=: groupin3s@keepGood@toBase10@roll2xD5</lang>

Here are a couple of variations on the theme that achieve the same result:

<lang j>getD7b=: 0 8 -.~ 3 >.@%~ 5 #. [: <:@rollD5 2 ,~ ]

getD7c=: [: (#~ 7&>:) 3 >.@%~ [: 5&#.&.:<:@rollD5 ] , 2:</lang>

The trouble is that we probably don't have enough D7 rolls yet because we compressed out any double D5 rolls that evaluated to 21 or more. So we need to accumulate some more D7 rolls until we have enough. J has two types of verb definition - tacit (arguments not referenced) and explicit (more conventional function definitions) illustrated below:

 

y $ rolls NB. shape the result according to the vector y

)</lang>

Here's a tacit definition that does the same thing:

<lang j>getNumRolls=: [: >. 0.75 * */@[ NB. calc approx 3/4 of the required rolls

 

=={{header|Lua}}==

<lang lua>dice5 = function() return math.random(5) end

 

<lang Mathematica>sevenFrom5Dice := (tmp$ = 5*RandomInteger[{1, 5}] + RandomInteger[{1, 5}] - 6;

If [tmp$ < 21, 1 + Mod[tmp$ , 7], sevenFrom5Dice])</lang>

<pre>CheckDistribution[sevenFrom5Dice, 1000000, 5]

->Expected: 142857., Generated :{142206,142590,142650,142693,142730,143475,143656}

=={{header|Perl 6}}==

{{works with|Rakudo Star|2010.09}}

Since rakudo is still pretty slow, we've done some interesting bits of optimization.

We factor out the range object construction so that it doesn't have to be recreated each time, and we sneakily <em>subtract</em> the 1's from the 5's, which takes us back to 0 based without having to subtract 6.

}</lang>

And the output:

1 142835 -0.02%

2 143021 +0.11%

5 143258 +0.28%

6 142485 -0.26%

 

=={{header|PicoLisp}}==

 

=={{header|REXX}}==

 

arg trials samp .

if trails=='' then trials=1

if samp=='' then samp=1000000

 

do t=1 for trials

end /*t*/

</lang>

<pre style="height:30ex;overflow:scroll">

───────────────trial: 1 1000000 samples, expect=142857

side 6 had 142971 occurances difference from expected= 114

side 7 had 142800 occurances difference from expected= -57

</pre>

 

=={{header|Ruby}}==

{{trans|Tcl}}

Uses <code>distcheck</code> from [[Simple_Random_Distribution_Checker#Ruby|here]].

<lang ruby>require './distcheck.rb'

loop until j < 21

dice7 = j mod 7 + 1