Utilizing Excel's turing capabilities to create Conway's 'Game of Life'

INDEX can be used with an array of row and column numbers to transform the board into a table of records for each cell and its neighbors. Since INDEX does not trigger an error when 0 is provided as the row and/or column number, a logical test is needed to handle out-of-scope references for the outer edges of the board. From there, BYROW-SUM is used to get the total number of live neighbors for each cell, and WRAPROWS returns the new board back to its original dimensions.

=IF(
   NOT(IterationsA),
   board,
   LET(
      h, ROWS(board),
      w, COLUMNS(board),
      i, TOCOL(IFNA(SEQUENCE(h),board))+{0,0,0,1,1,1,-1,-1,-1},
      j, TOCOL(IFNA(SEQUENCE(,w),board))+{0,1,-1,0,1,-1,0,1,-1},
      t, i*j*(i<=h)*(j<=w),
      REDUCE(
         board,
         SEQUENCE(IterationsA),
         LAMBDA(arr,num,
            LET(
               a, IF(t,INDEX(arr,i,j),0),
               n, BYROW(DROP(a,,1),SUM),
               WRAPROWS(TAKE(a,,1)*(n=2)+(n=3),w)
            )
         )
      )
   )
)

Alternatively, you could EXPAND the board to add an outer border of 0's, then DROP the appropriate number of rows and/or columns to shift the entire board in each of the 8 directions, to identify all neighbors at once.

=IF(
   NOT(IterationsB),
   BigBoard,
   LET(
      h, ROWS(BigBoard)+1,
      w, COLUMNS(BigBoard)+1,
      i, EXPAND(0,h+1,,0),
      j, EXPAND(0,,w,0),
      REDUCE(
         BigBoard,
         SEQUENCE(IterationsB),
         LAMBDA(arr,num,
            LET(
               a, HSTACK(i,VSTACK(j,EXPAND(arr,h,w,0))),
               ↑, DROP(DROP(a,,1),-2,-1),
               ↓, DROP(DROP(a,2,1),,-1),
               ←, DROP(DROP(a,1),-1,-2),
               →, DROP(DROP(a,1,2),-1),
               ↖, DROP(a,-2,-2),
               ↙, DROP(a,2,-2),
               ↗, DROP(a,-2,2),
               ↘, DROP(a,2,2),
               n, ↑ + ↓ + ← + → + ↖ + ↙ + ↗ + ↘,
               arr*(n=2)+(n=3)
            )
         )
      )
   )
)

This can also be done systematically with MAP and REDUCE, which is demonstrated in the attached workbook. I've also included two boards that loop/repeat, so you can just click and hold the spinner button to watch it go!

Cheers!

Patrick2788 

You have prompted me to have another go.  I have made some minor changes to your solution such as using REDUCE rather than recursion and a DROP/TAKE combination to isolate neighbourhoods.

The fun step was then to switch REDUCE to SCAN and produce the result as an array of thunks.  That allows the user to iterate the board in place or display the entire sequence of results.

Worksheet formula
= LET(
    result, SCAN(THUNK(board), SEQUENCE(generations), Stepλ),
    EVALTHUNKARRλ(IF(ShowAll, result, TAKE(result,-1)))
  )


//A simulation of Conway's Game of Life
Stepλ 
=LAMBDA(gridϑ, k,
    LET(
        grid, gridϑ(),
        life, MAKEARRAY(
            ROWS(grid),
            COLUMNS(grid),
            LAMBDA(r, c,
                LET(
                    border?, OR(r=1, c=1, r=ROWS(grid), c=COLUMNS(grid)),
                    // Identify neighbourhood and cell state
                    neighbourhood, TAKE(DROP(grid, r - 2, c - 2), 3, 3),
                    alive, INDEX(neighbourhood, 2, 2),
                    //total the neighbours
                    count, SUM(neighbourhood) - alive,
                    //cell has 3 neighbors or is alive and has 2 neighbors - keep
                    IF(border?, "x",  alive * (count = 2) + (count = 3))
                )
            )
        ),

    THUNK(life))
);

This updated approach for 2025 uses a kernel and MAP to do the heavy lifting.  I tend to err on the side of more parameters and readability.

//Kernel coordinates:
x = {-1;-1;-1;0;1;1;1;0};
y = {-1;0;1;1;1;0;-1;-1};


//A simulation of Conway's Game of Life
Conwayλ =

LAMBDA(config,n,
    LET(
    //determine dimensions of the board
        h,ROWS(config),
        w,COLUMNS(config),
    //create matrices of coordinates
        i,SEQUENCE(h)*SEQUENCE(,w,1,0),
        j,TRANSPOSE(i),
    //determine if cell is to be kept or discarded
        generate,MAP(i,j,LAMBDA(i_,j_,
            LET(
                each_cell,INDEX(config,i_,j_),
            //generate coordinates for each cell
            //discard certain coordinates if cell is on perimeter of board
                kernel,(i_+ x>0)*(j_+y>0)*(i_+ x<=h)*(j_+y<=w),
                r,FILTER(i_ + x,kernel),
                c,FILTER(j_+ y, kernel),
            //total the neigbors
                neighbors,SUM(INDEX(config,r,c)),
            //cell is 0 but has exactly 3 neighbors - keep
                revive,(each_cell=0)*(neighbors=3),
            //cell is alive and has 2 or 3 neighbors - keep
                keep,(each_cell=1)*(neighbors=2)+(neighbors=3),
                IF(revive,1,IF(keep,1,0))))),
        IF(n=0,config,Conwayλ(generate,n-1))))

Patrick2788 

INDEX was far from my first choice too, but I eventually settled for testing row and column numbers for 0 and n+1.  I also tested Riny_van_Eekelen 's start and at iteration 4 it returned the same shape but displaced. 

Your original pattern became static at iteration 50.  An advantage of recursion is that one could terminate the calculation there whereas REDUCE bashed on for the full 100 that I had set.

Patrick2788 Interesting. I remember doing this in machine code on my Comodore64 in the late 70's. Especially the famous 'Slider' figure that just continues to in a sequence of repeating patterns. It can be seen in the wiki link you provided.

The start is like this:

The 2nd generation becomes:

And the third should be like below though the red cells do not become alive in your formula:

Stepping back to the previous state and highlighting these two red cells, and it's clear that they should become alive in the next generation as the both have three neighbors that are alive at the time. Or have I misunderstood?

Patrick2788 

I too had a one-step success, followed by failure.  I started by just exploring a single step of the process and came up with

Stepλ
"Calculates outturn for a single cell"
= LET(
    count, SUM(OFFSET(cell, -1, -1, 3, 3)) - cell,
    IF(cell, SUM(SIGN(count = {2, 3})), SIGN(count = 3))
  )

For the entire board

= MAP(start, Stepλ)

worked fine but

= REDUCE(start, SEQUENCE(2), LAMBDA(board,k, MAP(board, Stepλ)))

failed because OFFSET is a range operator and, at step 2, I was offering it an array.  Back to the drawing board!  I would probably stick with REDUCE but it is back to the start with OFFSET.

At the moment I see myself as going with MAKEARRAY in order to generate indices and 

= SUM(INDEX(start,r+δr,c+δc)) - INDEX(start,r,c)

δr = {1;0;-1}
δc = {1,0,-1}

Still some edge conditions to sort, though.