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

{{task|Probability and statistics}}

1 to 7 in equal probability using only <code>dice5</code> as a source of random

 

'''Implementation suggestion:'''

 

<small>(Task adapted from an answer [http://stackoverflow.com/questions/90715/what-are-the-best-programming-puzzles-you-came-across here])</small>

 

=={{header|Ada}}==

The specification of a package Random_57:

 

type Mod_7 is mod 7;

-- a simple implementation

 

Implementation of Random_57:

 

package body Random_57 is

begin

Rand_5.Reset(Gen);

A main program, using the Random_57 package:

 

procedure R57 is

Test( 1_000_000, Rand'Access, 0.02);

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

<pre>

Sample Size: 10000

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

1 + ENTIER (5*random);

 

distcheck(dice5, 1000000, 5);

distcheck(dice7, 1000000, 7)

<pre>

200598, 199852, 199939, 200602, 199009

 

=={{header|AutoHotkey}}==

{ Random, v, 1, 5

Return, v

IfLess v, 21, Return, (v // 3) + 1

}

<pre>Distribution check:

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

FOR r% = 2 TO 5

check% = FNdistcheck(FNdice7, 10^r%, 0.1)

IF bins%(i%)/(repet%/m%) < 1-delta s% += 1

NEXT

<pre>

Over 100 runs dice7 failed distribution check with 4 bin(s) out of range

 

=={{header|C}}==

{

int r, rand_max = RAND_MAX - (RAND_MAX % 5);

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

return 0;

<pre>

flat

flat

</pre>

 

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

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

{

public:

test_distribution(d5, 1000000, 0.001);

test_distribution(d7, 1000000, 0.001);

 

=={{header|Clojure}}==

Uses the verify function defined in [[Verify distribution uniformity/Naive#Clojure]]

 

(defn dice7 []

(doseq [n [100 1000 10000] [num count okay?] (verify dice7 n)]

(println "Saw" num count "times:"

 

<pre>Saw 0 10 times: not acceptable

=={{header|Common Lisp}}==

{{trans|C}}

(1+ (random 5)))

 

(loop for d55 = (+ (* 5 (d5)) (d5) -6)

until (< d55 21)

 

<pre>> (check-distribution 'd7 1000)

=={{header|D}}==

{{trans|C++}}

import verify_distribution_uniformity_naive: distCheck;

 

distCheck(&fiveToSevenNaive, N, 1);

distCheck(&fiveToSevenSmart, N, 1);

{{out}}

<pre>1 80365

{{trans|Common Lisp}}

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

return entropy.nextInt(5) + 1

}

while ((d55 := 5 * dice5() + dice5() - 6) >= 21) {}

return d55 %% 7 + 1

for x in 1..1000 {

bins[dice7() - 1] += 1

}

 

=={{header|Elixir}}==

def dice7 do

end

d55 = 5*dice5 + dice5 - 6 # 0..24

if d55 < 21, do: rem( d55, 7 ) + 1,

end

 

fun5 = fn -> Dice.dice5 end

fun7 = fn -> Dice.dice7 end

 

{{out}}

 

=={{header|Erlang}}==

-module( dice ).

 

dice7_small_enough( N ) when N < 21 -> N div 3 + 1;

dice7_small_enough( _N ) -> dice7().

 

{{out}}

 

=={{header|Factor}}==

math math.functions math.statistics math.vectors math.ranges ;

IN: rosetta-code.dice7

{ 1 10 100 1000 10000 100000 1000000 }

[| times | 0.02 7 [ dice7 ] times verify ] each

 

<pre>USE: rosetta-code.dice7 verify-all

{ 0 0 0 1 0 0 0 }

 

=={{header|Forth}}==

 

: d5 5 random 1+ ;

: d7

begin d5 d5 2dup discard? while 2drop repeat

<pre>cr ' d7 1000000 7 1 check-distribution .

lower bound = 141429 upper bound = 144285

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

 

call distcheck(rand7, samples, 0.001)

 

<pre>Distribution Uniform

 

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

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

 

=={{header|Go}}==

 

import (

max, flatEnough = distCheck(dice7, 7, calls, 500)

fmt.Println("Max delta:", max, "Flat enough:", flatEnough)

<pre>

Max delta: 356.1428571428696 Flat enough: true

 

=={{header|Groovy}}==

 

int rand5() {

}

(raw % 7) + 1

Test:

(1..6). each {

def counts = [0g, 0g, 0g, 0g, 0g, 0g, 0g]

=============="""

test(it)

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

==============

 

=={{header|Haskell}}==

import Data.List

 

let d7 = 5*d51+d52-6

if d7 > 20 then sevenFrom5Dice

Test:

(1,(142759,True))

(2,(143078,True))

(5,(142896,True))

(6,(143028,True))

 

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

{{trans|Ruby}}

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

$include "distribution-checker.icn"

 

else write ("skewed")

end

 

<pre>

5 142870

=={{header|J}}==

The first step is to create 7-sided dice rolls from 5-sided dice rolls (<code>rollD5</code>):

roll2xD5=: [: rollD5 2 ,~ */ NB. rolls D5 twice for each desired D7 roll (y rows, 2 cols)

toBase10=: 5 #. <: NB. decrements and converts rows from base 5 to 10

groupin3s=: [: >. >: % 3: NB. increments, divides by 3 and takes ceiling

 

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

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:

 

Here's an explicit definition that accumulates rolls from <code>getD7</code>:

n=. */y NB. product of vector y is total number of D7 rolls required

rolls=. '' NB. initialize empty noun rolls

end.

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

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

accumD7Rolls=: ] , getD7@getNumRolls NB. accumulates getD7 rolls

isNotEnough=: */@[ > #@] NB. checks if enough D7 rolls accumulated

 

The <code>verb1 ^: verb2 ^:_</code> construct repeats <code>x verb1 y</code> while <code>x verb2 y</code> is true. It is like saying "Repeat accumD7Rolls while isNotEnough".

 

Example usage:

6 4 5 1 4 2 4 5 2 5

rollD7t 2 5 NB. 2 by 5 array of D7 rolls

1

($@rollD7x -: $@rollD7t) 2 3 5

 

=={{header|Java}}==

{{trans|Python}}

public class SevenSidedDice

{

return 1+rnd.nextInt(5);

}

 

=={{header|JavaScript}}==

{{trans|Ruby}}

{

return 1 + Math.floor(5 * Math.random());

distcheck(dice5, 1000000);

print();

<pre>1 199792

2 200425

6 142648

7 142619 </pre>

 

=={{header|Julia}}==

 

function dice7()

 

 

=={{header|Liberty BASIC}}==

n=1000000 '1000000 would take several minutes

print "Testing ";n;" times"

dice5=1+int(rnd(0)*5) '1..5: dice5

end function

{{Out}}

<pre>

 

=={{header|Lua}}==

 

function dice7()

if x > 20 then return dice7() end

return x%7 + 1

 

<pre>CheckDistribution[sevenFrom5Dice, 1000000, 5]

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

->"Flat"</pre>

 

=={{header|OCaml}}==

 

let dice7 =

in

aux

 

=={{header|PARI/GP}}==

 

dice7()={

while((t=dice5()*5+dice5()) > 21,);

(t+2)\3

=={{header|Perl}}==

Using dice5 twice to generate numbers in the range 0 to 24. If we consider these modulo 8 and re-call if we get zero, we have eliminated 4 cases and created the necessary number in the range from 1 to 7.

 

sub dice7 {

$count7{dice7()}++ for 1..$n;

printf "%s: %5.2f%%\n", $_, 100*($count7{$_}/$n*7-1) for sort keys %count7;

{{out}}

<pre>

</pre>

 

 

=={{header|PicoLisp}}==

(rand 1 5) )

 

(use R

(until (> 21 (setq R (+ (* 5 (dice5)) (dice5) -6))))

<pre>: (let R NIL

(do 1000000 (accu 'R (dice7) 1))

=={{header|PureBasic}}==

{{trans|Lua}}

ProcedureReturn Random(4) + 1

EndProcedure

ProcedureReturn x % 7 + 1

 

=={{header|Python}}==

 

def dice5():

def dice7():

r = dice5() + dice5() * 5 - 6

Distribution check using [[Simple Random Distribution Checker#Python|Simple Random Distribution Checker]]:

<pre>>>> distcheck(dice5, 1000000, 1)

{1: 142853, 2: 142576, 3: 143067, 4: 142149, 5: 143189, 6: 143285, 7: 142881}

</pre>

 

 

 

 

 

=={{header|R}}==

5-sided die.

Simple but slow 7-sided die, using a while loop.

{

score <- numeric()

score

}

More complex, but much faster vectorised version.

{

morethan2n <- 3 * n + 10 + (n %% 2) #need more than 2*n samples, because some are discarded

} else score

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

</pre>

 

=={{header|Ruby}}==

{{trans|Tcl}}

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

 

def d5

 

distcheck(1_000_000) {d5}

 

{{out}}

6 142605

7 142811</pre>

 

=={{header|Sidef}}==

{{trans|Perl}}

 

func dice7 {

 

var count7 = Hash.new;

 

var n = 1e6;

count7.keys.sort.each { |k|

{{out}}

2: 0.02%

3: 0.23%

5: -0.23%

6: -0.54%

 

=={{header|Tcl}}==

Any old D&D hand will know these as a D5 and a D7...

 

proc D7 {} {

}

}

Checking:

<span class="sy0">%</span> distcheck D5 <span class="nu0">1000000</span>

<span class="sy0">%</span> distcheck D7 <span class="nu0">1000000</span>

1 143121 2 142383 3 143353 4 142811 5 142172 6 143291 7 142869

 

=={{header|VBScript}}==

 

function dice5

loop until j < 21

dice7 = j mod 7 + 1

 

=={{header|zkl}}==

fcn die7{ while((r:=5*die5() + die5())>=27){} r/3-1 }

 

 

println("Looking for ",100.0/7,"%");

{{out}}

<pre>