Escriba dos bloques rectangulares de código, cada uno con w caracteres de ancho yh caracteres de alto, que implementen el Juego de la vida de Conway cuando estén dispuestos en una cuadrícula. ( w y h pueden ser enteros positivos)
Por ejemplo, los dos bloques de código pueden ser: ( w = 3, h = 2, no el código real)
XX|
--+
y
|
--+
Trate el primer bloque como si fuera la celda "viva" en el Juego de la Vida y el segundo bloque como si fuera la celda "muerta".
Ahora organice varias copias de estos dos bloques en un programa más grande que represente una cuadrícula de Game of Life, como este planeador :
| | | | |
--+--+--+--+--+
| |XX| | |
--+--+--+--+--+
| | |XX| |
--+--+--+--+--+
|XX|XX|XX| |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
Ahora aquí está el punto clave: cuando se ejecuta este código, la salida debe ser la cuadrícula Game of Life que es la generación posterior a esta, utilizando los mismos bloques de código vivo y muerto para las celdas.
Entonces, el resultado del programa anterior sería la próxima generación del planeador, que también sirve como un programa ejecutable:
| | | | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
|XX| |XX| |
--+--+--+--+--+
| |XX|XX| |
--+--+--+--+--+
| |XX| | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
Ejecutar esto produciría la próxima generación:
| | | | |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
| | |XX| |
--+--+--+--+--+
|XX| |XX| |
--+--+--+--+--+
| |XX|XX| |
--+--+--+--+--+
| | | | |
--+--+--+--+--+
Y así.
El proceso debe ser repetible indefinidamente y funcionar para cualquier arreglo de sus bloques de códigos vivos y muertos en una cuadrícula de Juego de la Vida.
La cuadrícula de salida debe tener las mismas dimensiones que el programa del que proviene (5 por 6 arriba). Los tamaños de cuadrícula tan pequeños como 1 por 1 deberían funcionar, y pueden ser arbitrariamente grandes. Naturalmente, una cuadrícula vacía solo se generará.
Actualización: Sería posible poder simular cuadrículas de cualquier dimensión sin tener que cambiar los "mosaicos", pero dado que esto parece muy difícil, aceptaré respuestas que supongan que la cuadrícula es de cierto tamaño (tal vez alrededor de 16 * 16).
Las reglas del juego de la vida son las siguientes:
- Cualquier célula viva con menos de 2 o más de 3 vecinos vivos ( Moore ) muere.
- Cualquier celda muerta con exactamente 3 vecinos vivos cobra vida.
- Otras células no cambian.
Tanteo
El desafío es hacer esto en el área de bloque de código más pequeña posible. Tu puntaje es w * h . El puntaje más bajo gana. En caso de empate, gana la respuesta más votada.
Detalles
- Además de las nuevas líneas necesarias para hacer que las cosas sean rectangulares, sus dos bloques de código (y, por lo tanto, sus programas de cuadrícula de Game of Life) solo deben contener caracteres ASCII imprimibles (códigos hexadecimales 20 a 7E, sin pestañas, sin nuevas líneas adicionales ).
- Ambos bloques de código deben tener exactamente w * h caracteres (además de las nuevas líneas necesarias) con al menos una diferencia de caracteres. Rellenarlos con espacios o comentarios está bien. No deberían cambiar de una generación a la siguiente.
- La salida debe ir a un archivo o stdout. No hay entrada
- Las condiciones de contorno pueden ser periódicas (donde el borde superior bordea el fondo y el borde izquierdo bordea el derecho) o infinitas (donde todas las celdas fuera de los límites están siempre muertas). Elige lo que más te convenga.
- No está permitido leer su propio código fuente .
- No se permite ningún idioma o herramienta que ya lo haga. (Solo en caso de que exista).
Nota: Los -|+
caracteres anteriores solo se usaron para enfatizar los bordes de las celdas. Sus bloques no necesitan ningún borde distinguible. Sin embargo , al mostrar su salida, sería útil si hubiera una separación distinguible entre bloques, tal vez hecha con un carácter que nunca se usó en el programa, por lo que es fácil de eliminar. p.ej
DD+DD+DD+DD
+++++++++++
AA+DD+AA+DD
en lugar de
DDDDDDDD
AADDAADD
fuente
__SOURCE_CODE__
.Respuestas:
Perl, w * h = 233 * 1 = 233 (por celda)
Las celdas funcionan en cualquier tamaño de cuadrícula (incluso con longitud de fila irregular). Las celdas fuera de los límites se consideran muertas.
Célula muerta
Celula viva
Planeador
genera:
Explicación (no actual)
Perl, w * h = 140 * 2 = 280 (por celda)
La celda multilínea no es eficiente pero puede eliminarse
__LINE__
.Célula muerta
Celula viva
fuente
JavaScript ES6 (239 x 1 caracteres por celda)
Célula muerta:
Célula viva:
La única diferencia es
S[j]=0
paraS[j]=1
células muertas y vivas.El tamaño de la cuadrícula se controla con las variables W (ancho) y H (alto). Las células fuera de la red están muertas.
Versión comentada
Planeador (cuadrícula de 5 x 6)
Salidas de próxima generación:
fuente
|
es un operador bit a bit y funciona solo con números.||
es un operador lógico que devuelve el lado izquierdo si es "verdadero", de lo contrario, el lado derecho.Python, 67x33 = 2,211
Tenga en cuenta que esta es mi bonita versión, donde agregué una línea de "#" a cada línea en una celda de vida, y "" a cada línea en una celda muerta. Además, las celdas están separadas por líneas "#". De esta manera, puede colocar una configuración inicial en un archivo de texto, por ejemplo
GOL.py
, y mirarla con una fuente pequeña para ver qué sucede en cada paso. Para llegar al siguiente paso, ejecutepython GOL.py > GOL1.py;mv GOL1.py GOL.py
y eche un vistazo nuevamente.Mi solución funciona en una cuadrícula de tamaño arbitrario y asume condiciones de contorno periódicas. No he probado diferentes anchos de línea, pero definitivamente hay capacidad para eso.
También debo mencionar que el éxito de esta solución depende de
__del__
ser llamado cuandoa
se destruye al final del programa. La documentación de Python diceEntonces, solo espero que esto no solo funcione con mi intérprete.
Célula viva:
Célula muerta:
Python, 67x17 = 1,139 Para obtener una versión de golf, aún con alguna forma de reconocer las células de la vida desde lejos, se elimina la segunda declaración de impresión en las líneas 19 y 31, así como todas las demás líneas.
Célula viva:
Célula muerta:
Si hay demanda, con mucho gusto explicaré el funcionamiento interno de mi solución cuando encuentre el momento.
fuente
<sup><sub>...</sub></sup>
dentro de un<pre><code>
bloque. Esto no disminuye la altura de una línea, pero la fuente del texto se reduce para cada aparición. Usar solo subíndice o solo superíndice hará que el código flote hacia abajo o hacia arriba fuera del marcado, pero alternando lo mantendrá centrado verticalmente.