Esta questão acabou de rever a revisão de código e imaginei que você poderia adaptá-la como um desafio do codegolf:

Você recebe uma lista não vazia de x casas representadas como booleanos. A cada dia, as casas competem com as adjacentes. 1 representa uma casa "ativa" e 0 representa uma casa "inativa". Se os vizinhos de ambos os lados de uma determinada casa estiverem ativos ou inativos, essa casa ficará inativa no dia seguinte. Caso contrário, ele se torna ativo.

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

Por exemplo, se tivéssemos um grupo de vizinhos [0, 1, 0], a casa em [1] se tornaria 0, pois a casa à esquerda e à direita estão inativas. As células em ambas as extremidades também verificam o lado oposto; portanto, os vizinhos no índice 0 estão no índice length-1e no indexn1 e vice-versa. Mesmo após a atualização da célula, é necessário considerar seu estado anterior ao atualizar as demais, para que as informações de estado de cada célula sejam atualizadas simultaneamente.

A função pega a matriz de estados e várias etapas e deve gerar o estado das casas após o número especificado de etapas.

    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]

Siga a lista e as etapas da maneira que desejar e envie a lista resultante via E / S padrão . As brechas padrão são proibidas. Este é o codegolf, a resposta mais curta em bytes ganha!

05AB1E , 14 13 10 9 6 bytes

Baseado na solução Japt de Shaggy

F©Á®À^

Experimente online!

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

Solução de 9 bytes desnecessariamente inteligente:

F¥DO.øü+É

Experimente online!

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

Experimente online!

Wolfram Language (Mathematica) , 31 bytes

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

Experimente online!

CellularAutomaton assume que a lista de entrada é 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

Experimente online!

Japonês -mh , 11 10 9 bytes

E / S de estados como matrizes 2D singleton.

VÇí^Zé2)é

Tente

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

Experimente online! Toma o número de passos na primeira linha e uma série de 0s e 1s na segunda linha. Explicação:

1A`

Exclua o número de etapas da entrada.

"$+"{

Repita esse número vezes.

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

Copie os dígitos finais para as outras extremidades para simular quebra automática.

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

Execute a operação XOR.

APL (Dyalog Extended) , ^{SBCS de} 12 bytes

Programa completo. Solicita ao stdin a matriz de estados e, em seguida, o número de etapas. Imprime em stdout.

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

Experimente online!

⎕ obtenha entrada avaliada do console (matriz de estados)

⊢ nisso, aplique…

1(… A )⍣⎕ seguinte função tácita, insira o número de vezes, sempre com o 1argumento à esquerda:

 ⌽⍢⌽ gire o argumento da direita 1 passo à esquerda enquanto invertido (ou seja, gire um passo à direita)

 ⌽≠ XOR com o argumento girado 1 passo à esquerda

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

Experimente online!

Geléia , 7 bytes

ṙØ+^/$¡

Experimente online!

Programa completo. Uma saída singleton é representada como em xvez de [x].

Pitão , 24 bytes

AQVH=Gmxhded.:+eG+GhG3;G

Experimente online!

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}

Experimente online!