One-dimensional cellular automata: Difference between revisions

1'''1'''0 -> 1 # Needs one neighbour to survive

1'''1'''1 -> 0 # Starved to death.

 

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

\ one-dimensional automaton

 

bye

 

 

=={{header|ACL2}}==

(if (endp (rest cells))

nil

nil

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

 

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

Generation 8 __##________________

</pre>

 

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

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{trans|Java}}

DECLARE FUNCTION getNeighbors! (group$)

CLS

NEXT i

life$ = newGen$

{{out}}

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

Generation 9 : __##________________</pre>

 

 

 

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

It halts when a stable state has been reached:

<pre>00110000000000000000 9</pre>

 

=={{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> | __###__##_#_##_###__######_###_#####_#__##_____#_#_#######__ |

 

...The sample is now stable.</pre>

 

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

equilibrium achieved

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

000000000000000110000000000000000001100011000000000000000000

000000000000000110000000000000000001100011000000000000000000</pre>

 

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

Generation 8: __##________________

Generation 9: __##________________</pre>

 

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

 

bnd :: String -> Char

bnd "#_#" = '#'

bnd "##_" = '#'

 

nxt :: String -> String

lahmahgaan :: String -> [String]

lahmahgaan xs =

 

main :: IO ()

{{Out}}

 

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

00110000

-></pre>

 

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

end

 

 

 

{{out}}

<pre>

</pre>

 

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

_##________________

</pre>

 

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

{{out}}

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

</pre>

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

{{out}}

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

 

=={{header|Phixmonti}}==

w tolist 0 0 put

0 w 1 + repeat var x2

nl

drop x2

 

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

true .

</pre>

 

=={{header|Python}}==

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

 

nquads = 5

print "Generation %3i: %s" % (i,(''.join(tr[int(t,16)] for t in (fmt%(a>>1)))))

a |= endvals

 

====Python: Sum neighbours == 2====

This example makes use of the observation that a cell is alive in the next generation if the sum with its current neighbours of alive cells is two.

>>> for n in range(10):

print(''.join('#' if cell else '_' for cell in gen))

__##________________

__##________________

 

===Composition of pure functions===

 

Interpreting the rule shown in the task description as Wolfram rule 104, and generalising enough to allow for other rules of this kind:

 

from itertools import islice, repeat

# MAIN -------------------------------------------------

if __name__ == '__main__':

{{Out}}

<pre>Rule 104:

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

█ █ ██ ██ █ ██ █ ██ █ █████ ███ █ ███ █████ ██ ███ </pre>

 

=={{header|R}}==

 

 

maxgenerations = 10

universe <- cellularAutomata(universe, stayingAlive)

cat(format(i, width=3), deadOrAlive2string(universe), "\n")

 

{{out}}

 

=={{header|Racket}}==

 

(define (update cells)

(0 0 1 1 0 0 0 0 0 1 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)

 

Below is an alternative implementation using graphical output in the Racket REPL.

It works with DrRacket and Emacs + Geiser.

 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(apply vc-append 2 (map draw-row (reverse rows)))))

 

 

=={{header|Raku}}==

and it makes the implementation a lot easier.

 

has $.rule;

has @.cells;

$a = Automaton.new: :rule(90), :cells(flat @padding, 1, @padding);

 

{{out}}

| # # # # |

| # # # # # # # # |

</pre>

 

=={{header|Retro}}==

 

Assume an array of cells with an initial distribution of live and

~~~

#10 generations

 

=={{header|REXX}}==

This REXX version will show (as a default) &nbsp; 40 &nbsp; generations, &nbsp; or less if the generations of cellular automata repeat.

parse arg $ gens . /*obtain optional arguments from the CL*/

if $=='' | $=="," then $=001110110101010 /*Not specified? Then use the default.*/

if $==@ then do; say right('repeats', 40); leave; end /*does it repeat? */

$=@ /*now use the next generation of cells.*/

'''output''' when using the default input:

<pre>

 

=={{header|Ring}}==

# Project : One-dimensional cellular automata

 

next

return binsum

Output:

<pre>

generation 8: 00110000000000000000

generation 9: 00110000000000000000

</pre>

 

=={{header|Ruby}}==

([0]+ary+[0]).each_cons(3).map{|a,b,c| a+b+c == 2 ? 1 : 0}

end

until ary == (new = evolve(ary))

printit ary = new

{{out}}

<pre>.###.##.#.#.#.#..#..

 

=={{header|Rust}}==

match windowed {

[false, true, true] | [true, true, false] => true,

}

}

 

=={{header|Scala}}==

{{works with|Scala|2.8}}

def it = Iterator.iterate(s) ( generation =>

("_%s_" format generation).iterator

(it drop 1) zip it takeWhile Function.tupled(_ != _) map (_._2) foreach println

 

Sample:

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

(if (null? petri-dish)

(list)

(- generations 1)))))

 

Output:

<pre>(1 1 1 0 1 1 0 1 0 1 0 1 0 1 0 0 1 0)

A graphical cellular automaton can be found [http://seed7.sourceforge.net/algorith/graphic.htm#cellauto here].

 

 

const string: start is "_###_##_#_#_#_#__#__";

g0 := g1;

end for;

 

Output:

__##________________

__##________________

 

=={{header|SequenceL}}==

 

main(args(2)) :=

1 when (left + cells[i] + right) = 2

else

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

var x = '';

 

seq.gsub!(/(?<=(.))(.)(?=(.))/, {|s1,s2,s3| s1 == s3 ? (s1 ? 1-s2 : 0) : s2});

(x != seq) && (x = seq) || break;

 

{{out}}

 

{{trans|Raku}}

 

method init {

say "|#{auto}|";

auto.next;

 

{{out}}

 

=={{header|Tcl}}==

set new [list]

for {set i 0} {$i < [llength $a]} {incr i} {

set array $new

print $array

 

=={{header|Ursala}}==

it according to the rule. The cells are maintained as a list of booleans

(0 and &) but are converted to characters for presentation in the example code.

#import nat

 

#show+

 

output:

<pre>

 

This implementation writes the calculated patterns into an edit buffer, where the results can viewed and saved into a file if required. The edit buffer also acts as storage during calculations.

#9 = Cur_Col

 

IT("Gen ") Num_Ins(#8, LEFT+NOCR) IT(": ")

Reg_Ins(20)

 

Sample output:

Gen 1: ..#.#####.#.#.#.........

Gen 2: ...##...##.#.#..........

Gen 7: ...##.....#.............

Gen 8: ...##...................

 

=={{header|Wart}}==

===Simple===

prn l

repeat n

def (next a b c) # next state of b given neighbors a and c

if (and a c) not.b

 

Output looks a little ugly:

Computing the next generation becomes much cleaner once you invest a few LoC in a new datatype.

 

(tag uca (list l len.l))

 

def (next a b c)

if (and a c) not.b

 

Output is prettier now:

__##________________

__##________________</pre>

 

=={{header|XPL0}}==

int Gen, Now, New, I;

[Now:= $076A_A400;

Now:= New;

];

 

{{out}}

______##________________________

</pre>

 

=={{header|zkl}}==

{{trans|Groovy}}

right:=line[1,*] + False; // shift left, False fill

left :=T(False).extend(line[0,-1]); // shift right

left.zip(line,right).apply(fcn(hood){ hood.sum(0)==2 });

cells:="_###_##_#_#_#_#__#__".split("").apply('==("#")); //-->L(False,True,True,True,False...)

Or, using strings instead of lists:

right:=line[1,*] + "_"; // shift left, "_" fill

left :="_" + line[0,-1]; // shift right

fcn(a,b,c){ (String(a,b,c) - "_") == "##" and "#" or "_" },

left,line,right).concat();

{{out}}

<pre>

__##________________

</pre>