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: