Galton box animation: Difference between revisions

=={{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|Mathematica}} / {{header|Wolfram Language}}==

MakePathFunction[{path_, acumpath_}] :=

Module[{f1, f2, f3, pf, n = Length[path]},

Disk[#, r] & /@ MakeScene[pfs, zfinals, n, t]},

PlotRange -> {{-n, n}, {Min[zfinals] - 1, n + 2}},

 

=={{header|Nim}}==

{{trans|Go}}

 

const

# Frozen balls are kept in balls slice for simplicity.

for ball in balls:

 

{{out}}

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

{{trans|Raku}}

use warnings;

 

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

: 0

{{out}}

<pre> ^

=== native Perl ===

Runs until a bottom column overflows.

 

use strict; # https://rosettacode.org/wiki/Galton_box_animation

$changes or last;

select undef, undef, undef, 0.05;

{{out}}

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

trace off /*suppress any messages for negative RC*/

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

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

=={{header|Wren}}==

{{trans|D}}

 

var boxW = 41 // Galton box width.

// Frozen balls are kept in balls list for simplicity

for (b in balls) b.doStep()

 

{{out}}

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

}