Skip to main content
Became Hot Network Question
further clarification
Source Link

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

A valid example sequence based on these rules would be:

111110000
111101000
111011000
111010100
110110100
110101100
101110010

Another way to state the rules is: "110" -> "101" and "011" -> "101", except "11011" occurs then neither of the first two rules is applied on the central three elements.

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

A valid example sequence based on these rules would be:

111110000
111101000
111011000
111010100
110110100
110101100
101110010

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

A valid example sequence based on these rules would be:

111110000
111101000
111011000
111010100
110110100
110101100
101110010

Another way to state the rules is: "110" -> "101" and "011" -> "101", except "11011" occurs then neither of the first two rules is applied on the central three elements.

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)

Example
Source Link

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

A valid example sequence based on these rules would be:

111110000
111101000
111011000
111010100
110110100
110101100
101110010

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

A valid example sequence based on these rules would be:

111110000
111101000
111011000
111010100
110110100
110101100
101110010

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)

Source Link

Cellular Automaton with larger rules

I want to implement a Cellular Automaton with the following rules:

00011
 010

01011
 110

10011
 010

11000
 010

11010
 011

11001
 010

All remaining patterns shall stay "the same", like:

abcde
 bcd

As these are "larger" rules as compared to the normal nearest neighbour rules I have no idea how to best implement these. Also the should operate on "larger" starting strings like maybe 128 bits long.

Any suggestions welcome. Especially short code is appreciated. (Merry X-max to all)