Conway's Game of Life: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V cellcounty = 5

V celltable = [(1, 2) = 1,

col-1..col+1, (r, c) -> :universe[(r, c)]))

), 0)

 

===More optimal solution===

V cellcounty = 5

V universe = [[0B] * cellcountx] * cellcounty

s += universe[row+1][col+1]

nextgeneration[row][col] = I universe[row][col] {s C 2..3} E s == 3

 

{{out}}

{{works with|http://www.6502asm.com/ 6502asm.com|1.2}}

 

ldx #$02 ;addressing

stx $02

lda $01

sta $03

 

=={{header|ACL2}}==

(if (endp row)

nil

nil

(progn$ (print-grid grid)

 

{{out}}

 

=={{header|Ada}}==

WITH Ada.Text_IO; USE Ada.Text_IO;

Put_And_Step_Generation (3, "Blinker", Blinker);

Put_And_Step_Generation (5, "Glider", Glider);

The solution uses one cell thick border around square Petri dish

as uninhabited dire land. This simplifies computations of neighborhood.

=={{header|ALGOL 68}}==

See [[Conway's Game of Life/ALGOL 68]]

 

=={{header|APL}}==

 

APL \ 1130 example (very old APL dialect via simulator)<br>

The following APL \ 1130 code will need APL385 font installed to display correctly. <br>

See [http://www.dyalog.com/apl-font-keyboard.htm Download APL TT Font]<br>

∇LIFE[⎕]∇

[0] NG←LIFE CG;W

0 0 0 0 0

 

 

=={{header|ARM Assembly}}==

{{works with|TI-Nspire}}

 

 

lcd_ptr .req r4

offsets:

.hword -321, -320, -319, -1, 1, 319, 320, 321

http://i.imgur.com/kV9RirP.gif

 

=={{header|AutoHotkey}}==

ahk [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=143 discussion]

i = -1,0,1, -1,1, -1,0,1 ; neighbors' x-offsets

j = -1,-1,-1, 0,0, 1,1,1 ; neighbors' y-offsets

 

GuiClose: ; exit when GUI is closed

 

=={{header|AWK}}==

running for 220 generations,

using [http://en.wikipedia.org/wiki/ANSI_escape_code ANSI escape-codes] for output to terminal:

BEGIN {

c=220; d=619; i=10000;

}

}

 

{{out}} Finally:

 

This implementation uses the full screen buffer instead of a 3x3 grid. This naive, unoptimized version gets less than 1 FPS.

 

While getKey(0)

End

End

 

=={{header|BASIC}}==

You can find it in the [[Galton box animation#BASIC256|Galton box animation]] example.

 

 

X = 59 : Y = 35 : H = 4

 

dim c(X,Y) : dim cn(X,Y) : dim cl(X,Y)

# Thunderbird methuselah

c[X/2-1,Y/3+1] = 1 : c[X/2,Y/3+1] = 1 : c[X/2+1,Y/3+1] = 1

else

print "Stabilized in "+(s-2)+" iterations"

{{out}}

<pre>

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

{{works with|BBC BASIC for Windows}}

dy% = 64

DIM old&(dx%+1,dy%+1), new&(dx%+1,dy%+1)

SWAP old&(), new&()

WAIT 30

{{out}}

<BR>

[[File:Lifebbc.gif]]

 

==={{header|FreeBASIC}}===

' May 2015

' 07-10-2016 cleanup/little changes

Print " Press any key to exit "

Sleep

 

==={{header|GFA Basic}}===

 

'

' Conway's Game of Life

CLOSEW 1

RETURN

 

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

It will run slow for grids above say 25!

nomainwin

 

close #w

end

 

 

==={{header|PureBasic}}===

Define.i x, y ,Xmax ,Ymax ,N

Xmax = 13 : Ymax = 20

Until Inkey() <> ""

'''Sample output:'''<br>

[[File:Game-of-life-PureBasic.gif‎]]

 

==={{header|Sinclair ZX81 BASIC}}===

 

The graphics character in lines <tt>1030</tt> to <tt>1060</tt> can be obtained by typing <code>SHIFT</code><code>9</code> then <code>SHIFT</code><code>H</code>, and the one in line <tt>1130</tt> by typing <code>SHIFT</code><code>9</code> then <code>SPACE</code>.

1010 DIM N$(M,M)

1020 FOR I=0 TO M+1

1340 NEXT I

1350 LET G=G+1

To run the blinker, add this code:

20 LET L$(1)="000"

30 LET L$(2)="111"

A screenshot of it running can be found [http://www.edmundgriffiths.com/zx81lifeblinker.jpg here].

 

To try a random starting configuration on a 16x16 grid, use this:

20 FOR I=1 TO 16

30 FOR J=1 TO 16

50 IF RND>=.7 THEN LET L$(I,J)="1"

60 NEXT J

A screenshot is [http://www.edmundgriffiths.com/zx81liferandom.jpg here].

 

==={{header|TI-83 BASIC}}===

This implementation is loosely based on the [http://www.processing.org/learning/topics/conway.html Processing Version]. It uses the home screen and draws cells as "X"s. It is extremely slow, and limited to a bounding box of 16 by 8. In order for it to work, you need to initialize arrays [A] and [B] to be 18x10.

:While 1

:For(X,2,9,1)

:[B]→[A]

:End

Here is an additional, very simple program to input the top corner of the GRAPH screen into the starting array. Make sure to draw on pixels in the rectangle (1,1) to (8,16).

:For(I,0,17,1)

:For(J,0,9,1)

:End

:End

 

==={{header|TI-89 BASIC}}===

A further improvement would be to have an option to start with the existing picture rather than clearing, and stop at a point where the picture has clean 2x2 blocks.

 

Local x,y,nt,count,save,xl,yl,xh,yh

Define nt(y,x) = when(pxlTest(y,x), 1, 0)

setGraph("Grid", save[2])

setGraph("Labels", save[3])

 

=={{header|Batch File}}==

If no parameters are parsed, it defaults to 5 iterations of the blinking example.

 

@echo off

setlocal enabledelayedexpansion

 

exit /b

{{out}}

Blinking example:

In Befunge-93, the maximum value for the width and height of the universe is 127, but there is an additional constraint of 4080 cells in total, so the largest universe would really be something like 120x34 or 68x60. Befunge-98 has no real limit on the size, although in practice a much larger universe will probably be unbearably slow.

 

v5\`\"~"::-*3p06!:!-+67:_^#!<*<!g06!<>1+70g*\:3/"P"%v^ ^::+*g04%<*0v`1:%3\gp08<

>6*`*#v_55+-#v_p10g1+10p>^pg08g07+gp08:+8/*8*65\p07:<^ >/10g-50g^87>+1+:01p/8/v

O>"l52?[">:#,_^v/3+2:*g05g04$_>:10p40g0^!:-1,g+4\0%2/+1+`1:%3\g+8<^: $v10!*-g<<

g+70g80gp:#v_$^>1-:::"P"%\"P"/8+:10v >/10g+1-50g+50g%40g*+::3/"P"^>!|>g*70g80g

 

{{in}}

=={{header|Brat}}==

 

height = 3

rounds = 3

p

step

 

{{out}}

-O-

</pre>

 

=={{header|C}}==

Play game of life on your console: <code>gcc -std=c99 -Wall game.c; ./a.out [width] [height]</code>

#include <stdlib.h>

#include <unistd.h>

if (h <= 0) h = 30;

game(w, h);

Also see [[Conway's Game of Life/C]]

 

Play game of life on your arduino (using two MAX7219 led 'screens') - based on the C example.

 

#include <MaxMatrix.h>

}

}

 

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

using System;

using System.Text;

}

 

 

Output:

Frame 1: Frame 2: Frame 3:

██

██████ ██ ██████

██

 

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

Considering that the simplest implementation in C++ would lack any use of the object-oriented paradigm, this code was specifically written to demonstrate the various object-oriented features of C++. Thus, while it is somewhat verbose, it fully simulates Conway's Game of Life and is relatively simple to expand to feature different starting shapes.

#define HEIGHT 4

#define WIDTH 4

gol2.iterate(4);

}

{{out}} first a glider, then a blinker, over a few iterations

(reformatted for convenience).

Another aproach - a pretty simple one.<br />

This version allows you to start the automata with different set of rules. Just for the fun of it.

#include <algorithm>

#include <vector>

return system( "pause" );

}

{{out}}<pre>

+--------------------+ +--------------------+ +--------------------+ +--------------------+

Shows a glider over 20 generations

Board edges wrap around to simulate infinite board

#include <iostream>

#include <vector>

}

}

{{out}}<pre>

generation 0:

 

=={{header|Chapel}}==

 

 

 

}

 

}

Output:

<pre>

Based on the implementation by Christophe Grand here: http://clj-me.cgrand.net/2011/08/19/conways-game-of-life/

This implementation models the live cells as a set of coordinates.

(for [dx [-1 0 1]

dy [-1 0 1]

(def *blinker* #{[1 2] [2 2] [3 2]})

(def *glider* #{[1 0] [2 1] [0 2] [1 2] [2 2]})

 

=={{header|COBOL}}==

program-id. game-of-life-program.

data division.

working-storage section.

05 check-row pic s9.

05 check-cell pic s9.

procedure division.

control-paragraph.

if cell(neighbour-row,neighbour-cell) is equal to '#',

and check-cell is not equal to zero or check-row is not equal to zero,

{{out}}

<pre>GENERATION 0:

 

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

(let* ((dimensions (array-dimensions array))

(results (or results (make-array dimensions :element-type 'bit))))

(terpri out) (print-grid world out)

(psetq world (next-life world result)

 

:element-type 'bit

:initial-contents '((0 0 0)

(1 1 1)

(0 0 0)))

 

produces

A version using a sparse list of living cells rather than an explicit board.

 

(let ((r '(-1 0 1)))

(mapcan

 

(defparameter *blinker* '((1 . 2) (2 . 2) (3 . 2)))

 

=={{header|D}}==

 

struct GameOfLife {

uni.writeln;

}

{{out|Output, first iteration}}

<pre>-------------------------------------------------------------

===Faster Version===

Same output.

std.array, std.conv;

 

uni.writeln;

}

 

=={{header|Dart}}==

* States of a cell. A cell is either [ALIVE] or [DEAD].

* The state contains its [symbol] for printing.

loadBlinker(grid) => blinkerPoints().forEach((point) => grid.set(point, State.ALIVE));

 

 

Test cases driving the design of this code:

 

main() {

});

});

{{out}}

<pre>

 

</pre>

 

=={{header|E}}==

Just does three generations of a blinker in a dead-boundary grid, as specified. ([[User:Kevin Reid]] has graphical and wrapping versions.)

 

def gridHeight := 3

def X := 0..!gridWidth

currentFrame := frame

println(currentFrame)

 

=={{header|EasyLang}}==

 

 

subr init

.

.

subr show

.

.

subr update

.

.

on timer

.

on mouse_down

.

 

=={{header|eC}}==

{{libheader|Ecere}}

 

import "ecere"

 

 

GameOfLife life {};

 

=={{header|Egel}}==

 

import "io.ego"

 

let _ = map [ G -> let _ = print "generation:\n" in printboard G ] {GEN0, GEN1, GEN2} in

nop

 

=={{header|Elena}}==

import system'threading;

import cellular;

 

sealed class Model

{

 

 

}

 

singleton gameOfLifeRuleSet : RuleSet

{

}

 

public extension presenterOp : Space

{

}

 

model.run();

};

 

console.readChar()

 

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

{{trans|Ruby}}

def game_of_life(name, size, generations, initial_life\\nil) do

board = seed(size, initial_life)

Conway.game_of_life("blinker", 3, 2, [{2,1},{2,2},{2,3}])

Conway.game_of_life("glider", 4, 4, [{2,1},{3,2},{1,3},{2,3},{3,3}])

 

{{out}}

 

=={{header|Emacs Lisp}}==

;; -*- lexical-binding: t -*-

;; run: ./conways-life conways-life.config

(swap a b))))

 

 

Configuration file, which defines the size starting patterns and

how long the simulation will run.

(cols . 10)

(generations . 3)

;; This is a custom pattern.

(4 4 (".***"

 

{{out}}

 

=={{header|Erlang}}==

 

-module(life).

list_to_integer(atom_to_list(Atom)).

 

 

=={{header|ERRE}}==

This is a simple implementation of Conway's game of Life with an endless world. Test pattern configuration is 'glider'.

PROGRAM LIFE

 

END PROGRAM

 

 

=={{header|F Sharp|F#}}==

The following F# implementation uses {{libheader|Windows Presentation Foundation}} for visualization and is easily compiled into a standalone executable:

let m, n = a.GetLength 0, a.GetLength 1

let mutable c = 0

Media.CompositionTarget.Rendering.Add update

Window(Content=image, Title="Game of Life")

 

=={{header|Forth}}==

'''gencell''' uses an optimization for the core Game of Life rules: new state = (old state | neighbors == 3).

 

1 6 lshift constant w \ 64

1 4 lshift constant h \ 16

**

*

 

=={{header|Fortran}}==

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

IMPLICIT NONE

END SUBROUTINE NextgenV2

!###########################################################################

{{out}}

<pre style="height:45ex;overflow:scroll">

=={{header|Frink}}==

Simple solution using two dictionaries (a display and a toggle) to store grid and track changes. The program outputs an animation of the game.

start = now[]

// Generate a random 10x10 grid with "1" being on and "0" being off

end = now[]

println["Program run time: " + ((end - start)*1.0 -> "seconds")]

 

=={{header|FunL}}==

import util.Regex

 

 

repeat 5

 

{{out}}

 

=={{header|Furor}}==

// Life simulator (game). Console (CLI) version.

// It is a 'cellular automaton', and was invented by Cambridge mathematician John Conway.

{ „x” } { „y” } { „n” }

 

 

=={{header|Futhark}}==

{{incorrect|Futhark|Futhark's syntax has changed, so this example will not compile}}

 

fun bint(b: bool): int = if b then 1 else 0

fun intb(x: int): bool = if x == 0 then False else True

iteration board in

to_int_board board

 

=={{header|Go}}==

 

import (

time.Sleep(time.Second / 30)

}

Running this program will compute and draw the first 300 "frames". The final frame looks like this:

<pre>

=={{header|Groovy}}==

 

class GameOfLife {

 

game.board = game.createGliderBoard()

game.start()

 

The output of this program:

 

=={{header|Haskell}}==

 

type Grid = UArray (Int,Int) Bool

 

count :: [Bool] -> Int

 

Example of use:

 

 

grid :: [String] -> (Int, Int, Grid)

printGrid w g

 

 

Here's the gridless version. It could probably be improved with some light use of <code>Data.Set</code>, but I leave that as an exercise for the reader. Note that the function <code>lifeStep</code> is the solution in its entirety. The rest of this code deals with printing and test data for the particular model of the world we're using.

 

import Data.List

 

putStrLn "Blinker >> 3"

putStrLn "------------"

 

=={{header|HolyC}}==

 

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

 

procedure main(args)

initial count := 0

return ((count +:= 1) > \limit) | (trim(!g) == " ")

 

A sample run:

->

</pre>

 

=={{header|J}}==

'''Solution:'''

life=: (3 3 (+/ e. 3+0,4&{)@,;._3 ])@pad

NB. the above could also be a one-line solution:

life=: (3 3 (+/ e. 3+0,4&{)@,;._3 ])@(0,0,~0,.0,.~])

 

In other words, given a life instance, the next generation can be found by:

 

'''Example''' (showing generations 0, 1 and 2 of a blinker):

0 0 0

1 1 1

0 0 0

1 1 1

 

'''Example''' (showing start and six following generations of a glider)

 

 

<pre style="line-height: 1"> blocks"2 life^:(i.7) 4 5{.#:1 5 3

=={{header|JAMES II/Rule-based Cellular Automata}}==

{{libheader|JAMES II}}

 

dimensions 2;

ALIVE

*/

Animated output for the blinker example:

 

 

=={{header|Java}}==

public static void main(String[] args){

String[] dish= {

}

}

{{out}}

<pre>Generation 0:

This fills in a random 10% of the grid, then activates the Game on it. Uncomment the call to the setCustomConfig function to use your own input. Just mind the grid limits.

Use the input file given below to create a cool screensaver on your terminal.

//package conway;

 

}

}

 

Glider Gun design. Save it in GOLglidergun.txt and uncomment the setCustomConfig function.

 

===Java 10===

import static java.util.List.of;

 

 

}

Outputs:

<pre>

{{works with|SpiderMonkey}}

{{works with|V8}}

 

this.init = function (turns,width,height) {

print("---\nRandom 5x10");

game.init(5,5,10);

{{out}}

<pre style="height:30ex;overflow:scroll">---

{{libheader|HTML5}}

Essentially the same as the above straight [[JavaScript]] but displayed in an [[HTML5]] Canvas.

<html>

<head>

</canvas><br>

</body>

{{out}} for 3x3 Blinker:

 

 

'''More functional style''':

const _ = require('lodash');

 

displayWorld(world);

}, 1000);

 

'''ES6 + ''':

const alive = 1;

const dead = 0;

run()

 

 

=={{header|jq}}==

In this implementation, a "world" is simply a suitably constructed string as illustrated by world3 and world11 below. The "game" can be played either by creating separate frames (using frames(n))

or by calling animation(n; sleep) with sleep approximately equal to the number of milliseconds between refreshes.

 

# 1. For efficiency, the implementation requires that the world

end )

| [., $lines, $w] ;

'''Animation''':

def cls: "\u001b[2J";

 

# Input: a string representing the initial state

def frames(n): animation(n; -1);

'''Examples''':

"+---+\n" +

"| |\n" +

"| .. |\n" +

"| |\n" +

 

'''Task''':

{{Out}}

<div style="overflow:scroll; height:200px;">

 

+---+

+---+

 

'''Animation example'''

 

=={{header|Jsish}}==

From Javascript, SpiderMonkey entry.

 

function GameOfLife () {

this.title = "Conway's Game of Life";

 

=!EXPECTEND!=

 

{{out}}

Using the '''CellularAutomata''' package: https://github.com/natj/CellularAutomata.jl

 

INFO: Installing CellularAutomata v0.1.2

INFO: Package database updated

 

julia> gameOfLife(15, 30, 5)

 

# ## # ###### ### ### ##

=== GPU calculation based version ===

Requires a CUDA compatible graphics card and uses the ArrayFire library.

using Images

using LinearAlgebra

lifegame("lwss.gif", lwss)

lifegame("glidergun.gif", glidergun, 90, 200)

 

=={{header|Kotlin}}==

The particular random pattern used now needs only 99 generations to reach stability.

 

 

import java.util.Random

println()

}

 

{{out}}

..........##....................................................................

</pre>

 

=={{header|Lua}}==

A slight modernization of my original "life.lua" for Lua 3.x circa 2000 -- heck, we didn't even have for loops back then! :D ''(a copy can be found in the 4.0 source distro if interested in comparing syntax)''

 

local Life = {

end

end

Example usage. Coordinates wrap to simulate an infinite universe, so here a glider/lwss are evolved through one complete period, then advanced forward until returning to starting conditions.

local life = Life:new(5,5)

life:set({ 2,1, 3,2, 1,3, 2,3, 3,3 })

end

for i = 6,20 do life:evolve() end

{{out}}

<pre>GLIDER:

□ □ □ □ □ □ □ □ □ □

□ □ □ □ □ □ □ □ □ □</pre>

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

Module Life {

Font "courier new"

Cls 5, 2

Const Mx=20, My=10

Flush

Data (5,3)

Data (5,4)

A(A,B)=1

End While

Display()

Do

k$=Key$

refresh 500

Display()

Until A()#Sum()=0

Local i, j, tot

For j=1 to My

For i=1 to Mx

tot=-A(i,j)

tot+=A(m, k)

B(i,j)=1

Next

Next

End Function

Sub Display()

Print "Generation:";Generation

Generation++

Print @(width div 2-Mx div 2);

For i=1 to Mx

Next

Print

Next

End Sub

}

Life

 

=={{header|MANOOL}}==

Straightforward implementation useful for benchmarking:

{ {extern "manool.org.18/std/0.3/all"} in

: let { N = 40; M = 80 } in

Out.WriteLine["After " G " generations:"]; Display[B]

}

Using comprehension notation:

{ {extern "manool.org.18/std/0.3/all"} in

: let { N = 40; M = 80 } in

Out.WriteLine["After " G " generations:"]; Display[B]

}

 

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

Mathematica has cellular automaton functionality built in, so implementing Conway's Game of Life is a one-liner:

Example of a glyder progressing 8 steps and showing the 9 frames afterwards as grids of hashes and dots:

gives back:

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

 

=={{header|MATLAB}}==

 

 

Here is an example code, more simple (runs the game of life for N generations in a square of side S) :

 

colormap copper; whitebg('black');

G= round(rand(S));

surf(G); view([0 90]); pause(0.001)

end

 

=={{header|Maxima}}==

[p, q, B: zerofor(A), s],

[p, q]: matrix_size(A),

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

 

=={{header|Nim}}==

{{trans|C}}

 

randomize()

univ[y].newSeq w

utmp[y].newSeq w

univ[y][x] = true

 

swap(univ,utmp)

 

 

=={{header|OCaml}}==

try g.(x).(y)

with _ -> 0

else print_char 'o'

done;

 

put the code above in a file named "life.ml", and then use it in the ocaml toplevel like this:

=== A graphical version ===

This implementation has 6 starting patterns (most get quite large) and a random option, and you can set the grid size.

let dead = 0xFFFFFF

 

disp bd2;

iteration bd2 bd1 width height

 

1st order two variable recurrence relation m-file, will also run under MATLAB.

 

clear all

x=55; % Size of the Lattice (same as LAWE)

pause % each press advances the algorithm one step

endfor

 

=={{header|Ol}}==

{{libheader|OpenGL}}

#!/usr/bin/ol

(import (otus random!))

neighbors)))

#empty generation)))))

 

=={{header|ooRexx}}==

* 07.08.2014 Walter Pachl Conway's Game of life graphical

* Input is a file containing the initial pattern.

Else

Return

{{out}}

<pre>blinker.txt

 

=={{header|Oz}}==

Rules = [rule(c:1 n:[0 1] new:0) %% Lonely

rule(c:1 n:[4 5 6 7 8] new:0) %% Overcrowded

{System.showInfo "\nGen. "#I}

{ForAll {ShowG Gi} System.showInfo}

 

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

Basic implementation; prints a matrix representing the state of the game directly. Supports large games but this example uses only the required 3 X 3 blinker.

my(N=M,W=matsize(M)[1],L=#M,t);

for(l=1,W,for(w=1,L,

};

M=[0,1,0;0,1,0;0,1,0];

 

=={{header|Pascal}}==

Optimized for speed on a Haswell CPU

(without PrintGen ~ 8.5 Cpu-cyles/coordinate )

// Game of life

{$IFDEF FPC}

PrintGen;

end.

 

=={{header|Perl}}==