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

{{trans|Python}}

 

R random:(1..5)

 

 

distcheck(dice5, 1000000, 1)

 

{{out}}

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

{{out}}

<pre>

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

{{out}}

<pre>

 

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

{{out}}

<pre>

 

=={{header|C}}==

{

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

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

return 0;

{{out}}

<pre>

=={{header|C sharp}}==

{{trans|Java}}

using System;

 

return 1 + random.Next(5);

}

 

=={{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 dice5, do: :rand.uniform( 5 )

IO.inspect VerifyDistribution.naive( fun5, 1000000, 3 )

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

 

{{out}}

=={{header|Forth}}==

{{works with|GNU Forth}}

 

: d5 5 random 1+ ;

: d7

begin d5 d5 2dup discard? while 2drop repeat

{{out}}

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

=={{header|Fortran}}==

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

implicit none

 

call distcheck(rand7, samples, 0.001)

 

{{out}}

<pre>Distribution Uniform

=={{header|FreeBASIC}}==

{{trans|Liberty BASIC}}

Function dice5() As Integer

Return Int(Rnd * 5) + 1

If Not(distCheck(n, 0.05)) Then Print "Test failed" Else Print "Test passed"

Sleep

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

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

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

{{out}}

<pre>

 

=={{header|Groovy}}==

 

int rand5() {

}

(raw % 7) + 1

Test:

(1..6). each {

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

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

test(it)

{{out}}

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

 

=={{header|Haskell}}==

import Data.List

 

let d7 = 5*d51+d52-6

if d7 > 20 then sevenFrom5Dice

{{out}}

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

 

{{out}}

=={{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();

{{out}}

<pre>1 199792

 

=={{header|Julia}}==

 

function dice7()

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

r < 21 ? (r%7 + 1) : dice7()

Distribution check:

<pre>julia> hist([dice5() for i=1:10^6])

 

=={{header|Kotlin}}==

 

import java.util.Random

fun main(args: Array<String>) {

checkDist(::dice7, 1_400_000)

 

Sample output:

 

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

 

=={{header|M2000 Interpreter}}==

 

We check for uniform numbers using +-5% from expected value.

Module CheckIt {

Def long i, calls, max, min

}

CheckIt

 

{{out}}

 

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

<pre>CheckDistribution[sevenFrom5Dice, 1000000, 5]

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

=={{header|Nim}}==

We use the distribution checker from task [[Simple Random Distribution Checker#Nim|Simple Random Distribution Checker]].

 

 

import random

randomize()

 

{{out}}

 

=={{header|OCaml}}==

 

let dice7 =

in

aux

 

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

 

dice7()={

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

(t+2)\3

 

=={{header|Pascal}}==

 

A chi-squared test can be carried out with the help of statistical tables, and is preferred here to an arbitrary "naive" test.

unit UConverter;

(*

until false;

end.

{{out}}

<pre>

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

=={{header|Phix}}==

replace rand7() in [[Verify_distribution_uniformity/Naive#Phix]] with:

<span style="color: #008080;">function</span> <span style="color: #000000;">dice5</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(rand 1 5) )

 

(use R

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

{{out}}

<pre>: (let R NIL

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

=={{header|Quackery}}==

 

 

[ dice5 5 *

6 6 7 7 7 ]

dup 0 = iff

 

{{out}}

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

}

 

=={{header|Racket}}==

#lang racket

(define (dice5) (add1 (random 5)))

(define res (+ (* 5 (dice5)) (dice5) -6))

(if (< res 21) (+ 1 (modulo res 7)) (dice7)))

 

Checking the uniformity using math library:

 

-> (require math/statistics)

-> (samples->hash (for/list ([i 700000]) (dice7)))

(2 . 99927)

(1 . 99622))

 

=={{header|Raku}}==

{{works with|Rakudo|2018.03}}

 

sub d5() { $d5.roll; } # 1d5

 

for @dist.kv -> $i, $v {

say "$i\t$v\t" ~ (($v - $expect)/$expect*100).fmt("%+.2f%%") if $v;

{{out}}

<pre>Expect 142857.143

 

=={{header|REXX}}==

parse arg trials sample seed . /*obtain optional arguments from the CL*/

if trials=='' | trials="," then trials= 1 /*Not specified? Then use the default.*/

' difference from expected:'right(die.j - expect, length(sample) )

end /*j*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 11 </tt>}}

 

 

=={{header|Ring}}==

# Project : Seven-sided dice from five-sided dice

 

rnd = random(4) + 1

return rnd

Output:

<pre>

{{trans|Tcl}}

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

 

def d5

 

distcheck(1_000_000) {d5}

 

{{out}}

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/3RNtNEC/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/Y5qSeW52QiC40l5vJCUMRA Scastie (remote JVM)].

 

object SevenSidedDice extends App {

println("Random number from 1 to 7: " + seven)

 

 

=={{header|Sidef}}==

{{trans|Perl}}

 

func dice7 {

count7.keys.sort.each { |k|

printf("%s: %5.2f%%\n", k, 100*(count7{k}/n * 7 - 1));

{{out}}

<pre>1: -0.00%

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

=={{header|VBA}}==

The original StackOverflow page doesn't exist any longer. Luckily [https://web.archive.org/web/20100730055051/http://stackoverflow.com:80/questions/137783/given-a-function-which-produces-a-random-integer-in-the-range-1-to-5-write-a-fun archive.org] exists.

'Returns true if the observed frequencies pass the Pearson Chi-squared test at the required significance level.

Dim Total As Long, Ei As Long, i As Integer

Next i

Debug.Print "[1] ""Uniform? "; Test4DiscreteUniformDistribution(Bins, 0.05); """"

{{out}}<pre>[1] "Data set:" 142418 142898 142940 142573 143030 143139 143002

Chi-squared test for given frequencies

 

=={{header|VBScript}}==

 

function dice5

loop until j < 21

dice7 = j mod 7 + 1

 

=={{header|Verilog}}==

 

///////////////////////////////////////////////////////////////////////////////

end

endmodule

 

Compiling with Icarus Verilog

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

import "/sort" for Sort

import "/fmt" for Fmt

}

 

 

{{out}}

 

=={{header|zkl}}==

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

 

 

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

{{out}}

<pre>