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

{{works with|Factor|0.99 development release 2019-03-17}}

combinators.short-circuit fonts fry generalizations kernel

literals locals math math.ranges math.vectors namespaces opengl

{ window-controls

{ normal-title-bar close-button minimize-button } }

{{out}}

Image taken from the program mid-animation: [https://i.imgur.com/E2ge7LE.png]

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

=={{header|JavaScript}}==

Works with NodeJs

 

/**

};

 

{{out}}

<pre>

{{works with|Julia|1.0}}

 

function drawball(timer)

global r, c, d

while r < 15 sleep(0.01) end

print("\e[40;1H") # move cursor far down

{{out}}

<pre>

=={{header|Kotlin}}==

{{trans|D}}

 

import java.util.Random

for (b in balls) b.doStep()

}

 

Sample output (showing final step only):

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

User can choose the number of balls to run through the simulation.

[setup]

nomainwin

unloadbmp "bg"

end

 

=={{header|Perl}}==

Output shows of final state for a run with 50 coins.

{{trans|Raku}}

use warnings;

 

? not 0 == ($x - $y) % 2

: 0

{{out}}

<pre> ^

▀ █ █

█

</pre>

 

=== console ===

First, a console version:

{{out}}

<pre>

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

{{libheader|Phix/pGUI}}

 

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

[[File:Galton_box_perl6.gif|thumb|UPPER HALF BLOCK and LOWER HALF BLOCK alternate to give a somewhat smooth animation.]]

{{works with|rakudo|2015-09-12}}

constant $peg = "*";

$row-count = $peg-lines;

simulate($coins);

 

=={{header|REXX}}==

Balls are dropped continuously &nbsp; (up to a number specified or the default), &nbsp; the default is enough rows of

<br>pins to fill the top &nbsp; <big>¹/₃</big> &nbsp; rows of the terminal screen.

if !all(arg()) then exit /*Any documentation was wanted? Done.*/

signal on halt /*allow the user to halt the program.*/

parse arg rows balls freeze seed . /*obtain optional arguments from the CL*/

if freeze=='' | freeze=="," then freeze= 0 /* " " " " " " */

if datatype(seed, 'W') then call random ,,seed /*Was a seed specified? Then use seed.*/

if sd==0 then sd= 40 /*Not defined by the OS? Use a default*/

if sw==0 then sw= 80 /* " " " " " " " " */

sd= sd - 3 /*define the usable screen depth.*/

if rows==0 then rows= (sw - 2 ) % 3 /*pins are on the first third of screen*/

call gen /*gen a triangle of pins with some rows*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

@.r= center( strip($, 'T'), sw) /*an easy method to build a triangle. */

end /*r*/; #= 0; return /*#: is the number of balls dropped. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

drop: static= 1 /*used to indicate all balls are static*/

x= pos(ball, @.c); y= x - 1 /*X: position of a ball on the C line.*/

if x==0 then iterate /*No balls here? Then nothing to drop.*/

if z==' ' then do; @.n= overlay(ball, @.n, y) /*drop a ball straight down.*/

@.c= overlay(' ' , @.c, y) /*make current ball a ghost.*/

iterate /*go keep looking for balls.*/

end

@.n= overlay(ball, @.n, y+d)

@.c= overlay(' ' , @.c, y )

iterate /*go keep looking for balls.*/

end

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

return

/*══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════*/

halt: say '***warning*** REXX program' !fn "execution halted by user."; exit 1

!all: !!=!;!=space(!);upper !;call !fid;!nt=right(!var('OS'),2)=='NT';!cls=word('CLS VMFCLEAR CLRSCREEN',1+!cms+!tso*2);if arg(1)\==1 then return 0;if wordpos(!,'? ?SAMPLES ?AUTHOR ?FLOW')==0 then return 0;!call=']$H';call '$H' !fn !;!call=;return 1

!rex: parse upper version !ver !vernum !verdate .; !brexx= 'BY'==!vernum; !kexx= 'KEXX'==!ver; !pcrexx= 'REXX/PERSONAL'==!ver | 'REXX/PC'==!ver; !r4= 'REXX-R4'==!ver; !regina= 'REXX-REGINA'==left(!ver, 11); !roo= 'REXX-ROO'==!ver; call !env; return

!sys: !cms= !sys=='CMS'; !os2= !sys=='OS2'; !tso= !sys=='TSO' | !sys=='MVS'; !vse= !sys=='VSE'; !dos= pos('DOS', !sys)\==0 | pos('WIN', !sys)\==0 | !sys=='CMD'; !crx= left(!sys, 6)=='DOSCRX'; call !rex; return

Programming note: &nbsp; the last seven lines of this REXX program are some general purpose (boilerplate code) that, among other things, finds:

::* &nbsp; the REXX program's filename, filetype (file extension), and filemode (and/or path)

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

 

const rand = std.rand;

 

const PEG_LINES = 20;

 

fn boardSize(comptime peg_lines: u16) u16 {

var i: u16 = 0;

var size: u16 = 0;

}

return size;

const BOARD_SIZE = boardSize(PEG_LINES);

 

 

var p: u8 = 0;

var sum: u16 = 0;

while (p <= PEG_LINES) : (p += 1) {

var i: u16 = 0;

} else {

}

}

}

}

}

 

var pegs: u16 = 0;

var sum: u16 = 0;

while (pegs <= PEG_LINES) : (pegs += 1) {

var i: u16 = 0;

i = 0;

}

}

for (count) |n| {

}

}

 

pub fn main() !void {

 

var i: u16 = 0;

 

try printBoard(&board, &bottom_count);

time.sleep(150000000);

}