Simule un modelo 1D Game-of-Life-ish

12

Esta pregunta solo pasó a la revisión de código y pensé que te gustaría adaptarla como un desafío de codegolf:

Se le da una lista no vacía de x casas representadas como booleanos. Cada día, las casas compiten con las adyacentes. 1 representa una casa "activa" y 0 representa una casa "inactiva". Si los vecinos de ambos lados de una casa determinada están activos o ambos inactivos, esa casa se vuelve inactiva al día siguiente. De lo contrario, se vuelve activo.

def get_state_as_pos(thelist, pos):
    if thelist[pos-1] == thelist[pos+1]:
        return 0
    else:
        return 1

Por ejemplo, si tuviéramos un grupo de vecinos [0, 1, 0] entonces la casa en [1] se convertiría en 0 ya que tanto la casa a su izquierda como a la derecha están inactivas. Las celdas en ambos extremos verifican también el lado opuesto, por lo que los vecinos en el índice 0 están en index length-1e indexn1 y viceversa. Incluso después de actualizar la celda, debe tener en cuenta su estado anterior al actualizar las demás para que la información de estado de cada celda se actualice simultáneamente.

La función toma la matriz de estados y una cantidad de pasos y debería generar el estado de las casas después del número de pasos dado.

    input: states = [1, 0, 0, 0, 0, 1, 0, 0], steps = 1
   output should be [0, 1, 0, 0, 1, 0, 1, 1]

    input: states = [1, 1, 1, 0, 1, 1, 1, 1], steps = 2
intermediate state= [0, 0, 1, 0, 1, 0, 0, 0]
   output should be [0, 1, 0, 0, 0, 1, 0, 0]


    input: states = [1], steps=1
    output: states= [0]

Tome la lista y los pasos como desee y envíe la lista resultante a través de E / S predeterminada . Las lagunas estándar están prohibidas. ¡Esto es codegolf, la respuesta más corta en bytes gana!

code-golf cellular-automata jaaq
fuente
8
+1 para autómatas celulares. Sin embargo, ¿no es esta la Regla 90?
HighlyRadioactive
2
¿No debería resultar el primer caso de prueba [0, 1, 0, 0, 1, 0, 1, 1]?
TFeld
44
@jaaq Me refiero a la regla de autómatas celulares elementales (de transformación entre cada paso, o generaciones) # 90. Escriba "Rule 90" en Wolfram | Alpha.
HighRadioactive
12
generar la lista resultante a través de STDOUT : se recomienda encarecidamente confiar en nuestros métodos de E / S predeterminados .
Arnauld
55
@jaaq No es una coincidencia, ya que hay un número de regla para cada autómata celular 1D estándar. Esto se debe a que 3 bits tienen 8 estados posibles (vecino izquierdo, yo mismo, vecino derecho) y si dice que para cada uno de esos estados una casa determinada estará encendida o apagada, son 8 valores verdadero / falso que se asignan perfectamente a un byte. Por lo tanto, la Regla # 0-255 se puede usar como una forma abreviada para describir cualquiera de estos conjuntos de reglas tomando la expresión binaria como el estado de activación / desactivación de la casa resultante en cada una de las 8 situaciones basadas en la posición en el byte. Algunas reglas se consideran notables, como 90, por lo tanto, el reconocimiento :)
Lunin

Respuestas:

8

05AB1E , 14 13 10 9 6 bytes

Basado en la solución Japt de Shaggy

F©Á®À^

Pruébalo en línea!

F                  # repeat n times:
 ©Á                #  the list, rotated right
   ®À              #  the list, rotated left
     ^             #  xor (vectorizes)

Solución innecesariamente inteligente de 9 bytes:

F¥DO.øü+É

Pruébalo en línea!

F                  # repeat n times:
                   #  (examples given for the initial state [0, 1, 1, 0, 1])
 ¥                 #  deltas of the list ([1, 0, -1, 1])
  D                #  duplicate
   O               #  sum (1)
    .ø             #  surround ([1, 1, 0, -1, 1, 1])
      ü+           #  pairwise addition ([2, 1, -1, 0, 2])
        É          #  modulo 2 ([0, 1, 1, 0, 0])
Mugriento
fuente
2

JavaScript (ES6), 57 bytes

Toma entrada como (steps)(array).

s=>g=a=>s--?g(a.map(_=>a[~-i++%l]^a[i%l],i=l=a.length)):a

Pruébalo en línea!

Arnauld
fuente
2

Japt -mh , 11 10 9 bytes

E / S de estados como matrices 2D singleton.

VÇí^Zé2)é

Intentalo

VÇí^Zé2)é     :Implicit input of integer U=steps & array V=[states]
VÇ            :Modify the last element Z in V
  í           :Interleave with
    Zé2       :  Z rotated right twice and
   ^          :  Reduce each pair by XOR
       )      :End interleave
        é     :Rotate right once
              :Repeat U times and implicitly output V
Lanudo
fuente
2

Retina , 51 bytes

1A`
"$+"{`(.).*(.)
$2$&$1
(.)(?=.(\1|(.)))?
$#2*$#3

Pruébalo en línea! Toma el número de pasos en la primera línea y una serie de 0s y 1s en la segunda línea. Explicación:

1A`

Eliminar el número de pasos de la entrada.

"$+"{

Repite ese número veces.

`(.).*(.)
$2$&$1

Copie los dígitos finales a los otros extremos para simular el ajuste.

(.)(?=.(\1|(.)))?
$#2*$#3

Realice la operación XOR.

Neil
fuente
2

APL (Dyalog Extended) , SBCS de 12 bytes

Programa completo Solicita stdin para la matriz de estados y luego para el número de pasos. Imprime en stdout.

1(⌽≠⌽⍢⌽)⍣⎕⊢⎕

Pruébalo en línea!

⎕ obtener entrada evaluada desde la consola (matriz de estados)

⊢ sobre eso, aplique ...

1(... )⍣⎕ la siguiente función tácita, ingrese el número de veces, cada vez con el 1argumento izquierdo:

 ⌽⍢⌽ gire el argumento derecho 1 paso hacia la izquierda mientras está invertido (es decir, gire un paso hacia la derecha)

 ⌽≠ XOR con el argumento girado 1 paso a la izquierda

Adán
fuente
1

Pyth , 24 bytes

AQVH=Gmxhded.:+eG+GhG3;G

Pruébalo en línea!

AQ                        # G, H = Q[0], Q[1] # Q = input in the form [[states],steps]
  VH                      # for i in range(H):
    =G                    # G = 
      m                   #     map(lambda d:                              )
       xhded              #                   d[0] ^ d[-1],
            .:       3    #         substrings(                 , length=3)
              +eG+GhG     #                     G[-1] + G + G[0]
                      ;   # (end for loop)
                       G  # print G
ar4093
fuente