#左耳音风 Reinicio de la actividad de registro de ARST#
Tabla de contenido
2. Código de resolución de problemas
3. Ideas para resolver problemas
Interpretación de ARTS: complete un ARTS por semana:
● Algoritmo: haga al menos un problema de algoritmo de LeetCode por semana
● Revisión: lea y comente al menos un artículo técnico en inglés
● Consejos: aprenda al menos una habilidad técnica
● Compartir: compartir una técnica artículos con opiniones y pensamientos
Se espera que a través de este evento se pueda reunir una ola de personas amantes de la tecnología y se pueda continuar el espíritu de curiosidad, exploración, práctica y compartir.
1. Tema
Según la Enciclopedia Baidu, el Juego de la Vida, conocido como Vida para abreviar, es un autómata celular inventado por el matemático británico John Horton Conway en 1970.
Dado un panel que contiene cuadrículas de m × n, cada cuadrícula se puede considerar como una celda. Cada celda tiene un estado inicial: 1 para celdas vivas o 0 para celdas muertas. Cada celda y sus ocho vecinos (horizontal, vertical, diagonal) obedecen las siguientes cuatro leyes de supervivencia:
Si el número de células vivas en las ocho posiciones alrededor de las células vivas es inferior a dos, las células vivas en esta posición están muertas;
si hay dos o tres células vivas en las ocho posiciones alrededor de las células vivas, las células vivas en esta posición posición aún están vivas;
si las células vivas Si hay más de tres células vivas en las ocho posiciones circundantes, las células vivas en esta posición mueren;
si hay exactamente tres células vivas alrededor de las células muertas, las células muertas en esta posición son resucitado;
el siguiente estado se obtiene aplicando las reglas anteriores al estado actual al mismo tiempo Cada célula se forma en la que el nacimiento y la muerte de las células ocurren simultáneamente. Le da el estado actual de la placa del panel de cuadrícula mxn, devuelve el siguiente estado.
Ejemplo 1:
Entrada: placa = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
Salida: [[0,0,0],[1 ,0,1],[0,1,1],[0,1,0]]
Ejemplo 2:
Entrada: placa = [[1,1],[1,0]]
Salida: [[1,1],[1,1]]
2. Código de resolución de problemas
def gameOfLife(board):
def getNextBoard(board):
m, n = len(board), len(board[0])
nextBoard = [[0] * n for _ in range(m)]
for i in range(m):
for j in range(n):
liveNeighbors = sum([board[x][y] for x in range(max(i-1, 0), min(i+2, m)) for y in range(max(j-1, 0), min(j+2, n))]) - board[i][j]
if board[i][j] == 1:
if liveNeighbors < 2 or liveNeighbors > 3:
nextBoard[i][j] = 0
else:
nextBoard[i][j] = 1
elif liveNeighbors == 3:
nextBoard[i][j] = 1
return nextBoard
while True:
newBoard = getNextBoard(board)
if newBoard == board:
break
board = newBoard
return board
3. Ideas para resolver problemas
Este código implementa una función llamada `gameOfLife` para resolver el problema del Juego de la Vida.
El Juego de la Vida es un modelo discreto basado en autómatas celulares, el cual está representado por una matriz bidimensional, cada elemento representa una celda, y el estado inicial es 0 o 1. El estado de cada celda se actualiza de acuerdo con el estado de sus ocho vecinos, las reglas específicas son las siguientes:
- Una célula viva muere si hay menos de dos células vivas a su alrededor;
- Una célula viva sobrevive si hay dos o tres células vivas
a su alrededor; célula viva, la célula muere;
- si hay exactamente tres células vivas alrededor de una muerta célula, la célula es revivida.La función `gameOfLife` acepta una lista bidimensional `tablero` como parámetro, que representa el estado actual del juego de la vida. Una función auxiliar `getNextBoard` se define dentro de la función, que se utiliza para calcular el próximo estado del juego de la vida. Esta función auxiliar primero crea una nueva lista bidimensional `nextBoard`, que se utiliza para almacenar el siguiente estado. Luego recorra cada elemento del estado actual (es decir, cada celda), calcule el estado de la celda en el siguiente estado de acuerdo con las reglas anteriores y guárdelo en `nextBoard`. Finalmente devuelve `nextBoard` como resultado.
En la función `gameOfLife`, se usa un bucle while para seguir calculando el siguiente estado hasta que el siguiente estado sea el mismo que el estado actual. Esto se debe a que el Juego de la vida es un proceso iterativo y el estado cambia después de cada iteración, por lo que debe durar una eternidad para obtener el resultado final.