

'''simple docstring'''






from __future__ import annotations

from PIL import Image

# Define glider example
lowerCAmelCase__   		=      [
    [0, 1, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0, 0, 0, 0],
    [1, 1, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
]

# Define blinker example
lowerCAmelCase__   		=      [[0, 1, 0], [0, 1, 0], [0, 1, 0]]


def 						_A	(       A__ ):






 """simple docstring"""



 __lowercase				    =					[]
 for i in range(len(A__ ) ):
  __lowercase				    =					[]
  for j in range(len(cells[i] ) ):
   # Get the number of live neighbours
   __lowercase				    =					0
   if i > 0 and j > 0:
    neighbour_count += cells[i - 1][j - 1]
   if i > 0:
    neighbour_count += cells[i - 1][j]
   if i > 0 and j < len(cells[i] ) - 1:
    neighbour_count += cells[i - 1][j + 1]
   if j > 0:
    neighbour_count += cells[i][j - 1]
   if j < len(cells[i] ) - 1:
    neighbour_count += cells[i][j + 1]
   if i < len(A__ ) - 1 and j > 0:
    neighbour_count += cells[i + 1][j - 1]
   if i < len(A__ ) - 1:
    neighbour_count += cells[i + 1][j]
   if i < len(A__ ) - 1 and j < len(cells[i] ) - 1:
    neighbour_count += cells[i + 1][j + 1]

   # Rules of the game of life (excerpt from Wikipedia):
   # 1. Any live cell with two or three live neighbours survives.
   # 2. Any dead cell with three live neighbours becomes a live cell.
   # 3. All other live cells die in the next generation.
   #    Similarly, all other dead cells stay dead.
   __lowercase				    =					cells[i][j] == 1
   if (
       (alive and 2 <= neighbour_count <= 3)
       or not alive
       and neighbour_count == 3
   ):
    next_generation_row.append(1 )
   else:
    next_generation_row.append(0 )

  next_generation.append(A__ )
 return next_generation


def 						_A	(       A__	,							A__ ):






 """simple docstring"""



 __lowercase				    =					[]
 for _ in range(A__ ):
  # Create output image
  __lowercase				    =					Image.new('''RGB'''	,							(len(cells[0] ), len(A__ )) )
  __lowercase				    =					img.load()

  # Save cells to image
  for x in range(len(A__ ) ):
   for y in range(len(cells[0] ) ):
    __lowercase				    =					255 - cells[y][x] * 255
    __lowercase				    =					(colour, colour, colour)

        # Save image
  images.append(A__ )
  __lowercase				    =					new_generation(A__ )
 return images


if __name__ == "__main__":
 lowerCAmelCase__   		=      generate_images(GLIDER, 16)
 images[0].save('''out.gif''', save_all=True, append_images=images[1:])



'''simple docstring'''
from __future__ import annotations

from PIL import Image

# Define glider example
lowercase__						       =      [
    [0, 1, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0, 0, 0, 0],
    [1, 1, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
]

# Define blinker example
lowercase__						       =      [[0, 1, 0], [0, 1, 0], [0, 1, 0]]




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__			)  ->							list[list[int]]:


		'''simple docstring'''


		snake_case  :       Optional[Any]     			=						[]
		for i in range(len(SCREAMING_SNAKE_CASE__			)			):
				snake_case  :       str     			=						[]
				for j in range(len(cells[i]			)			):
						# Get the number of live neighbours
						snake_case  :       Any     			=						0
						if i > 0 and j > 0:
								neighbour_count += cells[i - 1][j - 1]
						if i > 0:
								neighbour_count += cells[i - 1][j]
						if i > 0 and j < len(cells[i]			) - 1:
								neighbour_count += cells[i - 1][j + 1]
						if j > 0:
								neighbour_count += cells[i][j - 1]
						if j < len(cells[i]			) - 1:
								neighbour_count += cells[i][j + 1]
						if i < len(SCREAMING_SNAKE_CASE__			) - 1 and j > 0:
								neighbour_count += cells[i + 1][j - 1]
						if i < len(SCREAMING_SNAKE_CASE__			) - 1:
								neighbour_count += cells[i + 1][j]
						if i < len(SCREAMING_SNAKE_CASE__			) - 1 and j < len(cells[i]			) - 1:
								neighbour_count += cells[i + 1][j + 1]

						# Rules of the game of life (excerpt from Wikipedia):
						# 1. Any live cell with two or three live neighbours survives.
						# 2. Any dead cell with three live neighbours becomes a live cell.
						# 3. All other live cells die in the next generation.
						#    Similarly, all other dead cells stay dead.
						snake_case  :       List[Any]     			=						cells[i][j] == 1
						if (
						    (alive and 2 <= neighbour_count <= 3)
						    or not alive
						    and neighbour_count == 3
						):
								next_generation_row.append(1			)
						else:
								next_generation_row.append(0			)

				next_generation.append(SCREAMING_SNAKE_CASE__			)
		return next_generation




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__			)  ->							list[Image.Image]:


		'''simple docstring'''


		snake_case  :       Tuple     			=						[]
		for _ in range(SCREAMING_SNAKE_CASE__			):
				# Create output image
				snake_case  :       List[Any]     			=						Image.new('''RGB''' ,       (len(cells[0]			), len(SCREAMING_SNAKE_CASE__			))			)
				snake_case  :       Optional[Any]     			=						img.load()

				# Save cells to image
				for x in range(len(SCREAMING_SNAKE_CASE__			)			):
						for y in range(len(cells[0]			)			):
								snake_case  :       str     			=						255 - cells[y][x] * 255
								snake_case  :       List[str]     			=						(colour, colour, colour)

        # Save image
				images.append(SCREAMING_SNAKE_CASE__			)
				snake_case  :       Dict     			=						new_generation(SCREAMING_SNAKE_CASE__			)
		return images


if __name__ == "__main__":
						lowercase__						       =      generate_images(GLIDER, 1_6)
						images[0].save("out.gif", save_all=True, append_images=images[1:])


