Galton box animation: Difference between revisions

[[Category:Randomness]]

{{omit from|GUISS}}

 

 

 

 

 

 

=={{header|AutoHotkey}}==

Uses an edit box for the (text based) animation

; User settings

bottompegs := 6

StringTrimRight, out, out, 1 ; removes the last newline

return out

<pre>

*

=={{header|BASIC256}}==

[[File:Galton box BASIC-256.gif|right|150px|thumb|Galton box animation created with BASIC-256]]

fastgraphics

color black

iters = iters + 1

refresh

 

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

{{works with|BBC BASIC for Windows}}

[[Image:quincunx_bbc.gif|right]]

DIM ballX%(maxBalls%), ballY%(maxBalls%)

NEXT

tick% += 1

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

Sample out put at begining of a run:<pre>

*

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

Windows GDI version.

#include "stdafx.h"

#include <windows.h>

return myWnd.Run( hInstance );

}

 

=={{header|D}}==

To keep the code simpler some corner cases are ignored.

 

enum int boxW = 41, boxH = 37; // Galton box width and height.

b.doStep;

}

{{out}}

<pre>

| o o o o o o o o o o o |

+---------------------------------------+</pre>

=={{header|Elm}}==

import Time exposing (Time, every, millisecond)

import Color exposing (Color, black, red, blue, green)

, update = update

, subscriptions = subscriptions

 

Link to live demo: http://dc25.github.io/galtonBoxAnimationElm/ . Follow the link, enter a number and press the GO button.

 

=={{header|Go}}==

{{trans|D}}

 

import (

}

}

 

{{out}}

 

=={{header|Haskell}}==

import Graphics.Gloss

import Control.Monad.Random

where balls = mapM makeBall [1..]

makeBall y = Ball (0, y) <$> randomTurns

 

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

[[File:Galtonbox-Unicon.PNG|thumb|right]]

 

 

global pegsize, pegsize2, height, width, delay

initial ballcounts := table(0)

FillArc(x, height-(ballcounts[x] +:= 1)*pegsize, pegsize, pegsize)

 

=={{header|J}}==

First, we need to represent our pins:

 

 

For example:

 

*

* *

* * *

 

Note that we could introduce other pin arrangements, for example a Sierpinski triangle:

 

 

... but this will not be too interesting to use, because of the lack of interior pins for the balls to bounce off of.

Anyways, once we have that, we can add balls to our picture:

 

 

For example:

 

o

o

* *

* * *

 

Now we just need some way of updating our datastructure.

We will need a mechanism to shift a ball left or right if it's above a pin:

 

 

And, a mechanism to make the balls fall:

 

fill=. {.0#,y

x |.!.fill y

 

And then we need to separate out the balls from the pins, so the balls fall and the pins do not. Note also that in this representation, balls will have to fall when they bounce because they cannot occupy the same space that a pin occupies.

We will also want some way of preventing the balls from falling forever. For this task it's probably sufficient to introduce a baseline just deep enough to hold the stacks (which have passed through the pins) and have later balls instantly fall as close as they can to the baseline once they are passed the pins.

 

balls=: 'o'&=

 

clean2=: ({. , -.&' '"1&.|:&.|.@}.)~ 1 + >./@(# | '*' i:~"1 |:)

clean1=: #~ 1 1 -.@E. *./"1@:=&' '

 

For example:

 

o

* * *

* * * *

 

Or, showing an entire animation sequence:

 

┌─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┬─────────────┐

│ o │ │ │ │ │ │ │ │ │ │ │ │ │ │

│ * * * * * │ * * * * * │ │ │ │ │ │ │ │ │ │ │ │ │

│ │ │ │ │ │ │ │ │ │ │ │ │ │ │

 

=={{header|Java}}==

The balls keep track of where they are, and we just have to move them down and print. You might easily adjust this to take command line input for the numbers of pins and balls. I'm sure that this could be a lot shorter...

import java.util.List;

import java.util.ArrayList;

return result;

}

{{out}}

When only five balls have begun to fall through the pins:

| |o|o|o|o|o|o|o| |

| |o|o|o|o|o|o|o| |</pre>

 

=={{header|Kotlin}}==

{{trans|D}}

 

import java.util.Random

for (b in balls) b.doStep()

}

 

Sample output (showing final step only):

</pre>

 

my @tmpl;

}

}

{

# collect all the output and output it all at once at the end

# make some space above the picture

# place the coins

}

# output the board with its coins

}

# show the statistics

my $padding = 0;

$padding++;

}

}

}

}

}

 

=={{header|Phix}}==

First, a console version:

{{out}}

<pre>

.......................

</pre>

Also, here is a slightly nicer and resize-able gui version:

 

=={{header|PicoLisp}}==

(let (Bins (need (inc (* 2 Pins)) 0) X 0 Y 0)

(until (= Height (apply max Bins))

(prin (if (>= B H) "o" " ")) )

(prinl) )

Test:

{{Out}}

<pre># Snapshot after a few seconds:

=={{header|Prolog}}==

Works with SWI-Prolog and XPCE.[[File:Prolog_Galton_Box_1.png|thumb|Sample display of Prolog solution]]

:- dynamic balls/2.

:- dynamic stop/1.

send(Ch, append, T),

send(D, display, T))).

 

=={{header|PureBasic}}==

{{trans|Unicon}}

[[File:PureBasic_galtonbox.png|thumb|Sample display of PureBasic solution]]

 

Procedure eventLoop()

If Not galton(pegRows): Break: EndIf

Next

=={{header|Python}}==

 

import sys, os

 

if __name__=="__main__":

 

=={{header|Racket}}==

Multiple balls are added each step, but they do not collide.

 

;a ball's position...row is a natural number and col is an integer where 0 is the center

(define-struct pos (row col))

(on-tick (λ (ps) (tock height ps)) 0.5)

(to-draw (λ (ps) (draw height ps)))))

 

=={{header|Ruby}}==

{{libheader|Shoes}}

[[File:galtonbox.shoes.png|thumb|Sample display of Ruby solution]]

$width = $rows_of_pins * 10 + ($rows_of_pins+1)*14

 

end

end

 

=={{header|Tcl}}==

{{trans|C}}

 

oo::class create GaltonBox {

board show

if {[board step]} {after 60} break

After a sample run with input parameters <tt>10 55</tt>:

<pre>

</pre>

There is a much more comprehensive solution to this on the [http://wiki.tcl.tk/8825 Tcler's Wiki].<!-- Too long to reproduce here -->

 

=={{header|XPL0}}==

This ''Peeks'' into some IBM-PC specific locations and hence is not entirely portable.

 

define Balls = 80; \maximum number of balls

int Bx(Balls), By(Balls), \character cell coordinates of each ball

Sound(0, 3, 1); \delay about 1/6 second

until KeyHit; \continue until a key is struck

 

{{Out}}

 

=={{header|Yabasic}}==

obst$ = "000000"

 

next n

loop