Questa domanda è appena passata alla revisione del codice e ho pensato che ti potrebbe piacere adattarsi come una sfida di codegolf:

Ti viene dato un elenco non vuoto di x case rappresentate come booleane. Ogni giorno, le case competono con quelle adiacenti. 1 rappresenta una casa "attiva" e 0 rappresenta una casa "inattiva". Se i vicini su entrambi i lati di una determinata casa sono entrambi attivi o entrambi inattivi, quella casa diventa inattiva il giorno successivo. Altrimenti diventa attivo.

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

Ad esempio, se avessimo un gruppo di vicini [0, 1, 0], la casa in [1] diventerebbe 0 poiché entrambe le case alla sua sinistra e alla destra sono entrambe inattive. Le celle su entrambe le estremità controllano anche il lato opposto, quindi i vicini all'indice 0 sono all'indice length-1e indexn1 e viceversa. Anche dopo aver aggiornato la cella, è necessario considerare il suo stato precedente quando si aggiornano le altre in modo che le informazioni sullo stato di ciascuna cella vengano aggiornate contemporaneamente.

La funzione accetta la matrice di stati e un numero di passaggi e dovrebbe generare lo stato delle case dopo il dato numero di passaggi.

    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]

Prendi l'elenco e i passaggi che preferisci e visualizza l'elenco risultante tramite l' I / O predefinito . Sono vietate le scappatoie standard. Questo è codegolf, vince la risposta più breve in byte!

05AB1E , 14 13 10 9 6 byte

Basato sulla soluzione Japt di Shaggy

F©Á®À^

Provalo online!

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

Soluzione a 9 byte inutilmente intelligente:

F¥DO.øü+É

Provalo 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 byte

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

Provalo online!

Wolfram Language (Mathematica) , 31 byte

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

Provalo online!

CellularAutomaton presume che l'elenco di input sia ciclico.

JavaScript (ES6), 57 byte

Accetta input come (steps)(array).

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

Provalo online!

Japt -mh , 11 10 9 byte

I / O degli stati come array 2D singleton.

VÇí^Zé2)é

Provalo

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 byte

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

Provalo online! Prende il numero di passi sulla prima linea e una serie di 0s e 1s sulla seconda riga. Spiegazione:

1A`

Elimina il numero di passaggi dall'input.

"$+"{

Ripeti quel numero di volte.

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

Copia le cifre finali alle altre estremità per simulare il wrapping.

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

Eseguire l'operazione XOR.

APL (Dyalog Extended) , 12 byte ^SBCS

Programma completo. Richiede stdin per array di stati e quindi per numero di passaggi. Stampa su stdout.

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

Provalo online!

⎕ ottenere input valutati dalla console (array di stati)

⊢ su questo, applicare ...

1(... )⍣⎕ la seguente funzione tacita, inserisci il numero di volte, ogni volta con 1l'argomento sinistro:

 ⌽⍢⌽ ruota l'argomento destro di 1 passo a sinistra mentre è invertito (cioè ruota di un passo a destra)

 ⌽≠ XOR con l'argomento ruotato di 1 passo a sinistra

Python 2 , 71 byte

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

Provalo online!

Gelatina , 7 byte

ṙØ+^/$¡

Provalo online!

Programma completo. Un output singleton è rappresentato come xanziché [x].

Pyth , 24 byte

AQVH=Gmxhded.:+eG+GhG3;G

Provalo 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

Rubino , 59 byte

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

Provalo online!