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!

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])

Python 2 , 72 bytes

f=lambda s,n:n and f([a^b for a,b in zip(s[-1:]+s,s[1:]+s[:1])],n-1)or s

Pruébalo en línea!

Wolfram Language (Mathematica) , 31 bytes

CellularAutomaton[90,#,{{#2}}]&

Pruébalo en línea!

CellularAutomaton asume que la lista de entrada es cíclica.

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!

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

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.

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

Python 2 , 71 bytes

f=lambda a,n:n and f([a[i-1]^(a+a)[i+1]for i in range(len(a))],n-1)or a

Pruébalo en línea!

Jalea , 7 bytes

ṙØ+^/$¡

Pruébalo en línea!

Programa completo Una salida singleton se representa como en xlugar de [x].

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

Ruby , 59 bytes

->r,n{n.times{r=r.rotate.zip(r.rotate -1).map{|a,b|a^b}};r}

Pruébalo en línea!