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|68000 Assembly}}==

* popLong = <tt>MOVE.L (SP)+,___</tt>

 

;Ram Variables

Cursor_X equ $00FF0000 ;Ram for Cursor Xpos

DC.B $80 ;23 DMA source address high (C=CMD) CCHHHHHH

VDPSettingsEnd:

{{out}}

[https://ibb.co/VN4KbSL Screenshot of emulator]

{{works with|ABAP|7.4 SP05 or Above only}}

For the proposed task use ''10,9;10,10;10,11'' on screen field P_POS. Can be left blank for random filling

*&---------------------------------------------------------------------*

*& Report ZCONWAYS_GAME_OF_LIFE

leave list-processing.

endcase.

 

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

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

This handler creates and returns a "universe" script object initialised with given "seed" text and dimensions. For convenience, the seed text's visible characters can be anything, the set-up code itself replacing them with "■" characters. The use of the returned universe is demo'd later.

 

use framework "Foundation" -- For the regex at the top of newUniverse()

use scripting additions

return universe

 

In conjunction with the above, this fulfills the task as set:

 

-- Create a universe and start a list with its initial state.

set universe to newUniverse(seed, dimensions)

 

-- Return text containing the original and three generations of a "blinker" in a 3 x 3 grid.

 

{{output}}

■■■

■

Generation 3

 

This alternative to the task code runs an animation of a "Gosper glider gun" in TextEdit, the AppleScriptable text editor included with macOS. The animation's achieved by replacing the entire text of a document with successive universe states. It's faster than it sounds, but the universe size specified shouldn't be much greater than 150 x 150 with current machines.

 

-- Create an RTF file set up for Menlo-Regular 12pt, half spacing, and a reasonable window size.

set fontName to "Menlo-Regular"

**"

-- Run for 500 generations in a 100 x 100 universe.

 

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

==={{header|CASIO BASIC}}===

{{works with|https://community.casiocalc.org/topic/7586-conways-game-of-life-fx-9750gii9860giii/#entry60579 Conway's Game of Life fx-9750GII/9860GI/II|1.1}}

Cls

20→D

Next

Goto 1

 

==={{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|GW-BASIC}}===

Allows a blinker to be loaded. It also has a routine for randomising the grid; common objects like blocks, gliders, etc turn up semi-frequently so it won't take long to verify that these all work.

 

20 REM 30x30 grid, padded with zeroes as the boundary

30 DIM WORLD(31, 31, 1)

520 NEXT YY

530 NEXT XX

 

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

It will run slow for grids above say 25!

nomainwin

 

close #w

end

 

==={{header|MSX Basic}}===

10 DEFINT A-Z

20 DIM L(16,16), N(16,16)

1350 G=G+1

1360 GOTO 1090

 

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

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

Xmax = 13 : Ymax = 20

Until Inkey() <> ""

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

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

Yo solo lo transcrito y comento al español.<br>

I just transcribed it and comment it in Spanish.

 

RANDOMIZE TIMER

LOOP UNTIL y > 80

PCOPY 0, 1

 

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

 

=={{header|BQN}}==

r←¯1(⌽⎉1)¯1⌽(2+≢𝕩)↑𝕩

s←∨´ (1∾<r) ∧ 3‿4 = <+´⥊ ¯1‿0‿1 (⌽⎉1)⌜ ¯1‿0‿1 ⌽⌜ <r

 

blinker←>⟨0‿0‿0,1‿1‿1,0‿0‿0⟩

{{out}}

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

 

===C for Arduino===

Play game of life on your arduino (using FastLED) - based on the C example.

#include <FastLED.h>

 

FastLED.delay(1000/FRAMERATE);

}

 

===C for Arduino===

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

config const gridHeight: int = 3;

config const gridWidth: int = 3;

}

}

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.

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>

{{Trans|Go}}

Thanks Rudy Velthuis for the [https://github.com/rvelthuis/Consoles Velthuis.Console] library.

program game_of_life;

 

end;

readln;

{{out}}

<pre> * *** * * *

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

[https://easylang.online/apps/game-of-life.html Run it]

 

n += 1

subr init

len p[] n * n + n + 1

call init

 

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

ELENA 5.0, using cellular library

import system'threading;

import cellular;

 

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

;{square grid with wrap-around boundaries}

 

 

!!'John Horton Conway (26 December 1937 – 11 April 2020)';

{{out}} One iteration starting from random soup, showing a few well-known objects (blinker, block, glider, beehive, loaf)

<pre>

'''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:

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

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

#!/bin/ksh

# # Version AJM 93u+ 2012-08-01

_game ${h} ${w}

 

 

 

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

Module Life {

Font "courier new"

}

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

This GUI implementation is for use with [http://miniscript.org/MiniMicro Mini Micro].

clear

rows = 64; rowRange = range(0, rows-1)

display(curIdx).mode = displayMode.off

curIdx = newIdx

 

=={{header|Nim}}==

{{trans|C}}

 

randomize()

swap(univ,utmp)

 

 

=={{header|OCaml}}==

try g.(x).(y)

with _ -> 0

done;

print_newline ()

 

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

Compile with: <pre>opam install graphics && ocamlopt -o life -I $(ocamlfind query graphics) graphics.cmxa life.ml</pre> and run with <pre>./life acorn 250 250</pre> If you run the blinker it will probably blink too fast to see unless you choose a large grid size.

 

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

would do 15 iterations over 5 rows and 10 columns.

 

my $printed;

printlife @life;

}

 

my $h = `tput lines` - 1;

my $r = "\033[H";

print map((map($_ ? "#" : " ", @$_), "\n"), @universe);

iterate;

===Next Generation in a Single Substitution Operator===

 

print $_ = <<'' =~ tr/./ /r; # test case, dots only for layout

s/$neighborhood/ substr " $&# ", "$1$2$3$4" =~ tr|#||, 1 /ge;

print;

{{out}}

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/conways_game_of_life.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Conways_Game_of_Life.exw

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

 

=={{header|Picat}}==

===Blinker===

Rows = 3,

Cols = 3,

[1,1,1],

[0,0,0]],

 

{{out}}

 

===Testing some more forms===

Rows = 20,

Cols = 20,

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

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

 

=={{header|PicoLisp}}==

an array of multiply linked objects, and are also used in the chess program and

other games in the distribution.

 

(de life (DX DY . Init)

(=: life (: next)) ) ) ) ) )

 

Output:

<pre> 5

 

=={{header|PL/I}}==

Conway: procedure options (main); /* 20 November 2013 */

/* A grid of (1:100, 1:100) is desired; the array GRID is defined as (0:101, 0:101), */

end;

end;

Results:

<pre>

 

=={{header|Pointless}}==

-- Print 100 simulated states of conway's game of life

-- for a glider starting pattern on a wrapping grid

 

showCell(cell) =

 

=={{header|PostScript}}==

%%BoundingBox: 0 0 400 400

 

 

1000 { drawboard showpage iter } repeat

 

=={{header|Prolog}}==

%----------------------------------------------------------------------%

% GAME OF LIFE %

write_line(S,T).

write_line(_,[]) :- !.

 

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

Inspired by Daniel Shiffman's book The Nature of Code (http://natureofcode.com)

 

int cellSize = 10;

int cols, rows;

grid[x][y] = states[grid[x][y]]; // invert

}

 

==={{header|Processing Python mode}}===

sample = 10

play = False # simulation is running

if p != last_cell:

last_cell = p

 

=={{header|Python}}==

of <u>universe</u> returns zero.

 

from collections import defaultdict

 

for c in range(col-1, col+2) )

) ]

{{out}} (sample)

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

A world is represented as a set of (x, y) coordinates of all the alive cells.

 

 

def life(world, N):

 

 

 

{{out}}

 

===Using an array to define the world===

from pandas import DataFrame

import matplotlib.pyplot as plt

 

 

=={{header|R}}==

gen.board <- function(type="random", nrow=3, ncol=3, seeds=NULL)

{

game.of.life(gen.board("blinker"))

game.of.life(gen.board("glider", 18, 20))

 

=={{header|Racket}}==

 

#lang racket

(require 2htdp/image 2htdp/universe)

;;; (game-of-life (thunder) 2)

;;; (game-of-life (cross) 2)

 

Output for an 80x80 cross:

(formerly Perl 6)

 

subset World of Str where {

.lines>>.chars.unique == 1 and m/^^<[.#\n]>+$$/

say $glider++;

say '--';

 

=={{header|Red}}==

Purpose: "Conway's Game of Life"

Author: "Joe Smith"

conway *8-8

]

 

{{out}}

 

=={{header|Retro}}==

 

'World d:create

}}

 

=={{header|REXX}}==

This version has been trimmed down from the original REXX program, otherwise the size of the program (with all its options and optional formatting)

<br>would probably be on the large side for general viewing, &nbsp; and maybe a wee bit complex to demonstrate how to program for this task.

signal on halt /*handle a cell growth interruptus. */

parse arg peeps '(' rows cols empty life! clearScreen repeats generations .

p: return word(arg(1), 1)

pickChar: _=p(arg(1)); arg u .; if u=='BLANK' then _=" "; L=length(_); if L==3 then _=d2c(_); if L==2 then _=x2c(_); return _

This REXX program makes use of &nbsp; '''linesize''' &nbsp; REXX program (or BIF) &nbsp; which is used to determine the screen width (or linesize) of the terminal (console); &nbsp; not all REXXes have this BIF.

 

 

===version 2===

* 02.08.2014 Walter Pachl

* Input is a file containing the initial pattern

Return lineout(dbg,arg(1))

Else

{{out}}

<pre> blinker

 

=={{header|Ruby}}==

board = new_board size

seed board, size, initial_life

game_of_life "blinker", 3, 2, [[1,0],[1,1],[1,2]]

game_of_life "glider", 4, 4, [[1,0],[2,1],[0,2],[1,2],[2,2]]

 

{{out}}

The above implementation uses only methods. Below is one that is object-oriented and feels perhaps a bit more Ruby-ish.

 

def initialize(name, size, generations, initial_life=nil)

@size = size

Game.new "blinker", 3, 2, [[1,0],[1,1],[1,2]]

Game.new "glider", 4, 4, [[1,0],[2,1],[0,2],[1,2],[2,2]]

 

=={{header|Rust}}==

use std::collections::HashMap;

use std::collections::HashSet;

life(glider, 20, 8, 8);

}

 

=={{header|Scala}}==

{{works with|Scheme|implementing R6RS (tested with PLT Scheme, Petite Chez Scheme)}}

 

;;An R6RS Scheme implementation of Conway's Game of Life --- assumes

;;all cells outside the defined grid are dead

(0 0 0 0 0 0 0 0)

(0 0 0 0 0 0 0 0)

 

{{out}}

The game's initial state can be input manually by setting the values of <code>Init_state</code>, or using a bitmap image (or other supported formats). The output can be either printed on Scilab's console, or on a graphic window. For both image input and graphic output, either SIVP or IPCV modules are required, and <code>console_output</code> should be set to false.

 

1 1 1;...

0 0 0];

Curr_state=Next_state;

 

{{out}}

 

=={{header|SenseTalk}}==

 

RunGameOfLife starting_condition

wait 1 second

end repeat

 

=={{header|SequenceL}}==

 

'''SequenceL Code:'''

let

numNeighbors := Cells[I-1,J-1] + Cells[I-1,J] + Cells[I-1,J+1] +

1

foreach y within 1 ... n,

 

'''C++ Driver Code:'''

#include <string>

#include <vector>

}

throw(errno);

 

'''Usage:'''

This version uses a live cell set representation (set of coordinate pairs.)

This example first appeared [http://www.setl-lang.org/wiki/index.php/Conway%27s_Game_of_Life here].

 

const

end proc;

 

 

=={{header|Shen}}==

Somewhat verbose but functional and type-checked implementation (tested with chibi-scheme and Shen/SBCL). Running this shows ten iterations of a toad.

 

(datatype subtype

[0 1 1 1 0 0]

[0 0 0 0 0 0]

 

=={{header|Sidef}}==

{{trans|Perl}}

var h = Num(`tput lines`)

var r = "\033[H"

say universe.map{|row| row.map{|cell| cell ? '#' : ' '}.join }.join("\n")

iterate()

 

=={{header|Simula}}==

{{trans|Scheme}}

COMMENT ALL CELLS OUTSIDE THE DEFINED GRID ARE DEAD ;

 

 

END.

{{out}}

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

This implementation has been developed using '''Cuis Smalltalk''' [https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev].

Here are different configurations:

"Blinker"

GameOfLife withAliveCells: { 4@2. 4@3. 4@4. 3@3. 4@3. 5@3 } ofSize: 10@10.

"Toad"

GameOfLife withAliveCells: { 2@4. 3@4. 4@4. 3@3. 4@3. 5@3 } ofSize: 10@10

This is the implementation:

Object subclass: #GameOfLife

instanceVariableNames: 'aliveCells boardSize'

numberOfAliveNeighborsOf: aCell

^aCell eightNeighbors count: [ :aNeighbor | self isAlive: aNeighbor ]

The implementation was developed using TDD. This are the tests used to implement it.

TestCase subclass: #GameOfLifeTest

instanceVariableNames: ''

raise: Error - MessageNotUnderstood

withMessageText: 'Cell 1@4 out of range'

If you want to have a visual representation, here is a view for it:

ImageMorph subclass: #GameOfLifeView

instanceVariableNames: 'game'

self showBoard.

self redrawNeeded.

 

=={{header|SQL}}==

 

{{works with|Oracle}}

-- save these lines in a file called

-- setupworld.sql

from output

order by y desc;

 

<pre>

{{trans|Rust}}

 

var x: Int

var y: Int

 

print("Glider: ")

 

{{out}}

=={{header|SystemVerilog}}==

Note using non-blocking assignments, so that the code behaves as if every cell is updated in parallel on each clock edge. (I didn't need to use a clock here, but doing so looks more like standard verilog coding that is familiar to hardware designers).

 

parameter NUM_ROWS = 20;

end

 

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

 

proc main {} {

}

 

<pre style='height:30ex; overflow:scroll'>blinker generation 1:

. # .

{{works with|Korn Shell}}

{{works with|Z Shell}}

function main {

typeset blinker=(000 111 000)

}

 

 

{{Out}}

sequence of n boards evolving from it.

 

#import nat

 

neighborhoods = ~&thth3hthhttPCPthPTPTX**K7S+ swin3**+ swin3@hNSPiCihNCT+ --<0>*+ 0-*

 

test program:

 

(==`O)**t -[

#show+

 

{{out}}

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

Two <tt>Replace</tt> commands are then used to change characters into '.' or 'O' to represent dead and living cells in the new generation.

 

IT(".O.") IN

IT(".O.") IN

Ins_Char(Cur_Char+1,OVERWRITE)

}

 

{{out}}

=={{header|Wortel}}==

Mapping over a matrix.

life &m ~!* m &[a y] ~!* a &[v x] @let {

neigh @sum [

!^life 2 blinker

]]

{{out}}

<pre>[

 

Different solution by using functions that operate on matrices.

; Translation of the APL game of life (http://catpad.net/michael/apl/).

life &m @let {

!^life 2 blinker

]]

{{out}}

<pre>[

=={{header|VBScript}}==

I have used ANSI escape codes, so the program will not whork from W2000 to W8.1, where Microsoft did see fit to remove support to these codes. The game wraps around at borders, so the gliders are always alive. Must be invoked from cscript.

option explicit

const tlcr=3, tlcc=3

next

end function

<pre>

Conway's Game of Life

</pre>

A fast version using a thechnique from Abrash's Black Book. Set your console to 34 rows minimum, as it uses a 32x32 cells world

option explicit

const pix="##"

nextgen=nextgen+1

end sub

 

=={{header|Vlang}}==

{{trans|Go}}

import strings

import time

time.sleep(time.second / 30)

}

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

import "timer" for Timer

 

}

System.print()

 

{{out}}

 

=={{header|XPL0}}==

char NowGen(M+2, M+2), \size with surrounding borders

NewGen(M+2, M+2);

I:= NowGen; NowGen:= NewGen; NewGen:= I; \swap arrays

];

 

{{out}}

=={{header|XSLT}}==

So when the following templates

<table>

<xsl:apply-templates />

<xsl:template name="live">

<td>X</td>

are applied against the document

<tr><td>_</td><td>X</td><td>_</td></tr>

<tr><td>_</td><td>X</td><td>_</td></tr>

<tr><td>_</td><td>X</td><td>_</td></tr>

then the transformed XML document contains the new universe evolved by one tick:

<tr><td>_</td><td>_</td><td>_</td></tr>

<tr><td>X</td><td>X</td><td>X</td></tr>

<tr><td>_</td><td>_</td><td>_</td></tr>

 

=={{header|Z80 Assembly}}==

if INITLINES is set to 0 the code will show the blinker

 

CHPUT equ 000A2H ;print character A

CHGET equ 0009FH ;wait for keyboard input

;force 16k ROM size binary output

EndOfCode dc 0x8000 - EndOfCode, 0xFF

 

=={{header|Yabasic}}==

{{output?|Yabasic}}

{{trans|BASIC256}}

X = 59 : Y = 35 : H = 4

else

print "Stabilized in ", s-2, " iterations"

 

=={{header|zkl}}==

fcn init(n, r1,c1, r2,c2, etc){

var N=n, cells=Data(n*n), tmp=Data(n*n),

}

fcn dance(n=300){ do(n){ toAnsi().print(); Atomic.sleep(0.2); cycle(); } }

The data structure is a Data, which is a linear block of bytes.

do(3){ cells.println("="*4); cells.cycle(); }

 

cells:=Life(30, 0,1, 1,2, 2,0, 2,1, 2,2); // glider

{{out}}

Just the glider (reformatted), if you have an ANSI terminal (eg xterm), you'll see the glider moving down the screen.

 

=={{header|ZPL}}==

 

config var

TW := (TW & NN = 2) | ( NN = 3);

until !(|<< TW);

 

=={{header|ZX Spectrum Basic}}==

 

The ZX Spectrum was shipped with a demo tape called ''Horizons'', which included an implementation of Life; however, it relied on machine code.

20 LET w=32*22

30 DIM w$(w): DIM n$(w)

190 PRINT AT 0,0;w$

200 LET w$=n$