One-dimensional cellular automata: Difference between revisions

{{trans|Python}}

L(n) 10

print(gen.map(cell -> (I cell != 0 {‘#’} E ‘_’)).join(‘’))

gen = [0] [+] gen [+] [0]

{{out}}

=={{header|8th}}==

\ one-dimensional automaton

bye

=={{header|ACL2}}==

(if (endp (rest cells))

nil

nil

(prog2$ (pretty-row (first out))

=={{header|Action!}}==

IF prev='. AND curr='# AND next='# THEN

RETURN ('#)

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/One-dimensional_cellular_automata.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure Cellular_Automata is

Step (Culture);

end loop;

The implementation defines Petri dish type with Boolean items

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

INT universe width = 20;

FORMAT alive or dead = $b("#","_")$;

FI;

universe := next universe

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

INT upb universe = 20;

FORMAT alive or dead = $b("#","_")$;

next universe[UPB universe] := couple(universe[UPB universe - 1: ]);

universe := next universe

{{out}}

<pre>

=={{header|ALGOL W}}==

Using a string to represent the cells and stopping when the next state is th same as the previous one.

string(20) state;

string(20) nextState;

generation := generation + 1

end while_not_finished

{{out}}

<pre>

=={{header|Arturo}}==

ary: [0] ++ arr ++ [0]

ret: new []

newGen: evolve arr

printIt newGen

{{out}}

=={{header|AutoHotkey}}==

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

Loop % n { ; draw a line of checkboxes

GuiClose: ; exit when GUI is closed

=={{header|AWK}}==

BEGIN {

edge = 1

}

}

{{out}}

</pre>

cat automata.awk :

} while (str_ != str_previous)

}

{{out}}

{{works with|QuickBasic|4.5}}

{{trans|Java}}

DECLARE FUNCTION getNeighbors! (group$)

CLS

NEXT i

life$ = newGen$

{{out}}

<pre>Generation 0 : _###_##_#_#_#_#__#__

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

randomize timer

'or Q to exit

loop

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

Works with the unexpanded (1k RAM) ZX81.

20 LET G=1

30 PRINT N$

170 NEXT I

180 LET G=G+1

{{out}}

The program overwrites each cell on the screen as it updates it (which it does quite slowly—there is no difficulty about watching what it is doing), with a counter to the right showing the generation it is currently working on. When it is part of the way through, for example, the display looks like this:

=={{header|BASIC256}}==

dim start = {0,1,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0}

dim sgtes(start[?]+1)

start[j] = sgtes[j]

next j

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

This implementation will not stop showing generations, unless the cellular automata is already stable.

setlocal enabledelayedexpansion

set proc=%newgen%

goto :nextgen

{{out}}

<pre> | __###__##_#_##_###__######_###_#####_#__##_____#_#_#######__ |

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

rule$() = "0", "0", "0", "1", "0", "1", "1", "0"

NEXT cell%

SWAP now$, next$

{{out}}

<pre>Generation 0: 01110110101010100100

=={{header|Befunge}}==

" !!! !! ! ! ! ! ! " ,*25 <v

" " ,*25,,,,,,,,,,,,,,,,,,,,<v

^ >$$$$320p10g1+:9`v > >$"!"> 20g10g1+p 20g1+:20p

^ v_10p10g

=={{header|Bracmat}}==

= n z

. @( !arg

& evolve$!S:?S

)

{{out}}

<pre>11101101010101001001

=={{header|C}}==

#include <string.h>

do { printf(c + 1); } while (evolve(c + 1, b + 1, sizeof(c) - 3));

return 0;

{{out}}

<pre>###_##_#_#_#_#__#__

Similar to above, but without a backup string:

char trans[] = "___#_##_";

do { printf(c + 1); } while (evolve(c + 1, sizeof(c) - 3));

return 0;

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

using System.Collections.Generic;

}

}

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

Uses std::bitset for efficient packing of bit values.

#include <bitset>

#include <string>

std::cout << std::endl;

}

{{out}}

=={{header|Ceylon}}==

shared Character character;

string => character.string;

print("generation `` ++generation `` ``automata``");

}

=={{header|Clojure}}==

(:require (clojure.contrib (string :as s))))

'()

(cons cells (generate (dec n) (next-gen cells)))))

(println cells))

_###_##_#_#_#_#__#__

__##________________

nil

Another way:

(require '[clojure.string :as str])

(do (println g)

(recur (compute-next-genr g)

Yet another way, easier to understand

(def rules

{

(doseq [g (take 10 (iterate nextgen [0 1 1 1 0 1 1 0 1 0 1 0 1 0 1 0 0 1 0 0]))]

(println g))

=={{header|COBOL}}==

Identification division.

Program-id. rc-1d-cell.

end-perform

.

{{out}}

_##_____#__________

_##________________={{header|CoffeeScript}}==

# We could cheat and count the bits, but let's keep this general.

# . = dead, # = alive, middle cells survives iff one of the configurations

simulate (c == '#' for c in ".###.##.#.#.#.#..#..")

{{out}}

<pre>

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

Based upon the Ruby version.

(assert (> (length x) 1))

(coerce x 'simple-bit-vector))

do (princ (if (zerop (bit value i)) #\. #\#)

stream))

for value = #*01110110101010100100 then (next-cycle value)

until (equalp value previous-value)

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

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

=={{header|D}}==

import std.stdio, std.algorithm;

writeln;

}

{{out}}

<pre>__###_##_#_#_#_#__#___

===Alternative Version===

{{trans|Raku}}

import std.stdio, std.algorithm, std.range;

A.swap(B);

} while (A != B);

{{out}}

<pre>_###_##_#_#_#_#__#__

This version saves memory representing the state in an array of bits. For a higher performance a SWAR approach should be tried.

{{trans|C++}}

import std.stdio, std.algorithm, std.range, std.bitmanip;

A.swap(B);

}

The output is the same as the second version.

=={{header|DWScript}}==

const table = [0, 0, 0, 1, 0, 1, 1, 0];

PrintLn('');

end;

{{out}}

<pre>_###_##_#_#_#_#__#__

=={{header|Déjà Vu}}==

0 ]

repeat size:

return print-state drop

{{out}}

<pre>001110011010110111001111110111011111010011000001010111111100

=={{header|E}}==

var result := state(0, 1) # fixed left cell

for i in 1..(state.size() - 2) {

}

return state

" " => " ",

" #" => " ",

8 | ##

9 | ##

=={{header|Eiffel}}==

class

APPLICATION

end

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Ruby}}

def run(list, gen \\ 0) do

print(list, gen)

end

{{out}}

=={{header|Elm}}==

import List exposing (length, tail, reverse, concat, head, append, map3)

import Html exposing (Html, div, h1, text)

, update = update

, subscriptions = subscriptions

Link to live demo: https://dc25.github.io/oneDimensionalCellularAutomataElm/

=={{header|Erlang}}==

-module(ca).

-compile(export_all).

next([1,1,1|T],Acc) ->

next([1,1|T],[0|Acc]).

Example execution:

44> ca:run(9,[0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0]).

0: __###_##_#_#_#_#__#___

8: ___##_________________

9: ___##_________________

=={{header|ERRE}}==

PROGRAM ONEDIM_AUTOMATA

END FOR

END PROGRAM

{{out}}

<pre>

=={{header|Euphoria}}==

function rules(integer tri)

printf(1,"Generation %d: ",n)

{{out}}

=={{header|Factor}}==

IN: cellular

10 [ dup print-cellular step ] times print-cellular ;

MAIN: main-cellular

<pre>( scratchpad ) "cellular" run

_###_##_#_#_#_#__#__

=={{header|Fantom}}==

class Automaton

{

}

}

=={{header|FOCAL}}==

1.2 S OLD(9)=1; S OLD(11)=1; S OLD(13)=1; S OLD(15)=1; S OLD(18)=1

1.3 F N=1,10; D 2

7.1 T "#"

{{output}}

<pre>

=={{header|Forth}}==

0 do dup 1 and c, 2/ loop drop ;

.state 1 do gen .state loop ;

ouput

### ## # # # # #

# ##### # # #

##

## ok

=={{header|Fortran}}==

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

IMPLICIT NONE

END SUBROUTINE Drawgen

{{out}}

<pre>

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

'

' One Dimensional Cellular Automaton

RETURN result%

ENDFUNC

=={{header|Go}}==

===Sequential===

import "fmt"

return g0[1:last]

}

{{out}}

<pre>

Separate read and write phases.

Single array of cells.

import (

write.Wait()

}

Output is same as sequential version.

=={{header|Groovy}}==

Solution:

def right = self[1..-1] + [false]

def left = [false] + self[0..-2]

[left, self, right].transpose().collect { hood -> hood.count { it } == 2 }

Test:

println "Generation 0: ${cells.collect { g -> g ? '#' : '_' }.join()}"

(1..9).each {

cells = life1D(cells)

println "Generation ${it}: ${cells.collect { g -> g ? '#' : '_' }.join()}"

{{out}}

=={{header|Haskell}}==

import System.Random (newStdGen, randomRs)

. take 36

. randomRs (0, 1)

{{Out}}

For example:

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

# One dimensional Cellular automaton

record Automaton(size, cells)

}

end

An alternative approach is to represent the automaton as a string.

the evolve procedure fails if a new generation is unchanged from the previous, stopping the generation cycle early.

A := if *A = 0 then ["01110110101010100100"]

CA := show("0"||A[1]||"0") # add always dead border cells

every newCA[i := 2 to (*CA-1)] := (CA[i-1]+CA[i]+CA[i+1] = 2, "1")

return CA ~== newCA # fail if no change

{{out|A couple of sample runs}}

=={{header|J}}==

{{out|Example use}}

_###_##_#_#_#_#__#__

_#_#####_#_#_#______

__##____#_#_________

__##_____#__________

Alternative implementation:

'_#'{~ (3 ((|.n#:~8#2) {~ #.)\ 0,],0:)^:(i.m)

{{out|Example use}}

_###_##_#_#_#_#__#__

_#_#####_#_#_#______

__##____#_#_________

__##_____#__________

=={{header|Java}}==

This example requires a starting generation of at least length two

(which is what you need for anything interesting anyway).

public static void main(String[] args) throws Exception{

String start= "_###_##_#_#_#_#__#__";

return ans;

}

{{out}}

<pre>Generation 0: _###_##_#_#_#_#__#__

which is local to the <code>evolve</code> method,

and the <code>evolve</code> method returns a boolean.

private static char[] trans = "___#_##_".toCharArray();

}while(evolve(c));

}

{{out}}

<pre>###_##_#_#_#_#__#__

state[i-1] refers to the new cell in question,

(old[i] == 1) checks if the old cell was alive.

var old = [0].concat(old, [0]); // Surround with dead cells.

var state = []; // The new state.

}

return state;

{{out|Example usage}}

shows an alert with "0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,0,0,0,0,0".

=={{header|jq}}==

The main point of interest in the following is perhaps the way the built-in function "recurse" is used to continue the simulation until quiescence.

def next:

# Conveniently, jq treats null as 0 when it comes to addition

# Example:

{{out}}

*** ** * * * * *

* ***** * * *

** * *

** *

=={{header|Julia}}==

This solution creates an automaton with with either empty or periodic bounds. The empty bounds case, is typical of many of the solutions here. The periodic bounds case is a typical physics approach where, in effect, the beginning and end of the list touch each other to form a circular rather than linear array. In practice, the effects of boundary conditions are subtle for long arrays.

function next_gen(a::BitArray{1}, isperiodic=false)

b = copy(a)

a = next_gen(a, true)

end

{{out}}

=={{header|K}}==

{{out|Example usage}}

_XXX_XX_X_X_X_X__X__

_X_XXXXX_X_X_X______

__XX_____X__________

__XX________________

=={{header|Kotlin}}==

{{trans|C}}

val trans = "___#_##_"

}

while (evolve(c,b))

{{out}}

{{works with|Just BASIC}}

{{works with|Run BASIC}}

' does not wrap so fails for some rules

next j

=={{header|Locomotive Basic}}==

20 FOR k=1 TO n

30 FOR j=1 TO w

70 FOR j=1 TO w:x(j)=x2(j):NEXT

80 NEXT

{{out}}

=={{header|Logo}}==

{{works with|UCB Logo}}

make "generations 9

end

{{out}}

<pre>

=={{header|Lua}}==

f = { 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 }

Output( f, l )

{{out}}

<pre>0: _###_##_#_#_#_#__#__

=={{header|M4}}==

define(`set',`define(`$1[$2]',`$3')')

define(`get',`defn(`$1[$2]')')

for(`j',1,10,

`show(x)`'evolve(`x',`y')`'swap(`x',x,`y')

{{out}}

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

Built-in function:

For succinctness, an integral rule can be used:

{{out}}

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

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

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

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

=={{header|MATLAB}} / {{header|Octave}}==

V='_#';

while n>=0;

v = v(3:end)==2;

end;

{{out}}

<pre>octave:27> one_dim_cell_automata('01110110101010100100'=='1',20);

but it segfaults when trying to use <code>BOOLEAN</code> types,

so we use <code>INTEGER</code> instead.

IMPORT IO, Fmt, Word;

Step(culture);

END;

{{out}}

<pre>

=={{header|MontiLang}}==

35 VAR height .

FOR length 0 ENDFOR 1 0 ARR VAR list .

next printArr .

next 0 ADD APPEND . VAR list .

=={{header|Nial}}==

(life.nial)

wi is rest link [write, pass]

% calculate the neighbors by rotating the array left and right and joining them

nextgen is each igen neighbors

% 42

{{out|Using it}}

|I := [0,1,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0]

=={{header|Nim}}==

if map2 == map: break

{{out}}

<pre>_###_##_#_#_#_#__#____________

'''Using a string character counting method''':

const

q0 = q1

q1 = evolve(q0)

{{out}}

<pre>_###_##_#_#_#_#__#__

'''Using nested functions and method calling style:'''

proc evolveInto(x, t : var string) =

for i in x.low..x.high:

swap t, x

{{out}}

=={{header|OCaml}}==

try g.(i)

with _ -> 0

else print_char '#'

done;

put the code above in a file named "life.ml",

=={{header|Oforth}}==

| i s |

l byteSize dup ->s String newSize

: gen( l n -- )

{{out}}

=={{header|Oz}}==

A0 = {List.toTuple unit "_###_##_#_#_#_#__#__"}

do

{System.showInfo "Gen. "#I#": "#{Record.toList A}}

{{out}}

This function generates one generation from a previous one,

passed as a 0-1 vector.

To simulate a run of 10 generations of the automaton, the function above can be put in a loop that spawns a new generation as a function of nth generations passed (n=0 is the initial state):

=== Output ===

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

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

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

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

=={{header|Pascal}}==

{$IFDEF FPC}{$MODE DELPHI}{$ELSE}{$APPTYPE}{$ENDIF}

uses

NextRow(@row[0],High(row));

end;

{{Out}}<pre>

__###_##_#_#_#_#__#__

Convert cells to zeros and ones to set complement state

$_="_###_##_#_#_#_#__#__\n";

do {

s/(?<=(.))(.)(?=(.))/$1 == $3 ? $1 ? 1-$2 : 0 : $2/eg;

} while ($x ne $_ and $x=$_);

Use hash for complement state

$_="_###_##_#_#_#_#__#__\n";

%h=qw(# _ _ #);

s/(?<=(.))(.)(?=(.))/$1 eq $3 ? $1 eq "_" ? "_" : $h{$2} : $2/eg;

} while ($x ne $_ and $x=$_);

{{out}} for both versions:

=={{header|Phix}}==

Ludicrously optimised:

<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"_###_##_#_#_#_#__#__"</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">prev</span><span style="color: #0000FF;">=</span><span style="color: #008000;">'_'</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">curr</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">toggled</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #000000;">toggled</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

{{out}}

<pre style="font-size: 8px">

</pre>

And of course I had to have a crack at that Sierpinski_Triangle:

<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"________________________#________________________"</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">prev</span><span style="color: #0000FF;">=</span><span style="color: #008000;">'_'</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">curr</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">toggled</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre style="font-size: 6px">

=={{header|Phixmonti}}==

w tolist 0 0 put

0 w 1 + repeat var x2

nl

drop x2

=={{header|Picat}}==

% _ # # # _ # # _ # _ # _ # _ # _ _ # _ _

S = [0,1,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0],

rule([1,0,1]) = 1. % Two neighbours giving birth

rule([1,1,0]) = 1. % Needs one neighbour to survive

{{out}}

The program is fairly general. Here's the additional code for the rule 30 CA.

N = 4,

Ns = [0 : _ in 1..N],

rule30([1,0,1]) = 0.

rule30([1,1,0]) = 0.

=={{header|PicoLisp}}==

(do 10

(prinl Cells)

(link "#") ) ) )

Cells )

{{out}}

<pre>_###_##_#_#_#_#__#__

=={{header|Prolog}}==

Works ith SWI-Prolog.

maplist(my_write, L), nl,

length(L, N),

L = [0,1,1,1,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0],

one_dimensional_cellular_automata(L).

{{out}}

<pre> ?- one_dimensional_cellular_automata.

=={{header|PureBasic}}==

Dim cG.i(21)

Dim nG.i(21)

Until Gen > 9

{{out}}

<pre>Generation 0: _###_##_#_#_#_#__#__

===Procedural===

====Python: Straightforward interpretation of spec====

printdead, printlive = '_#'

universe.replace('0', printdead).replace('1', printlive) )

universe = offendvalue + universe + offendvalue

{{out}}

<pre>Generation 0: _###_##_#_#_#_#__#__

====Python: Using boolean operators on bits====

The following implementation uses boolean operations to realize the function.