Cette question vient de faire l'objet d'une révision de code et je me suis dit que vous pourriez l'aimer comme un défi de codegolf:

Vous obtenez une liste non vide de x maisons représentées comme des booléens. Chaque jour, les maisons rivalisent avec les maisons adjacentes. 1 représente une maison "active" et 0 représente une maison "inactive". Si les voisins des deux côtés d'une maison donnée sont tous deux actifs ou inactifs, cette maison devient inactive le lendemain. Sinon, il devient actif.

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

Par exemple, si nous avions un groupe de voisins [0, 1, 0], la maison à [1] deviendrait 0 car la maison à gauche et à droite sont toutes les deux inactives. Les cellules aux deux extrémités vérifient également le côté opposé, de sorte que les voisins à l'index 0 sont à l'index length-1et à l'index n1 et vice versa. Même après la mise à jour de la cellule, vous devez tenir compte de son état antérieur lors de la mise à jour des autres afin que les informations d'état de chaque cellule soient mises à jour simultanément.

La fonction prend le tableau des états et un certain nombre d'étapes et doit afficher l'état des maisons après le nombre d'étapes donné.

    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]

Suivez la liste et les étapes comme vous le souhaitez et sortez la liste résultante via les E / S par défaut . Les failles standard sont interdites. Ceci est codegolf, la réponse la plus courte en octets gagne!

05AB1E , 14 13 10 9 6 octets

Basé sur la solution Japt de Shaggy

F©Á®À^

Essayez-le en ligne!

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

Solution inutilement intelligente de 9 octets:

F¥DO.øü+É

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 31 octets

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

Essayez-le en ligne!

CellularAutomaton suppose que la liste d'entrée est cyclique.

JavaScript (ES6), 57 octets

Prend l'entrée comme (steps)(array).

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

Essayez-le en ligne!

Japt -mh , 11 10 9 octets

E / S d'états en tant que tableaux 2D singleton.

VÇí^Zé2)é

Essayez-le

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

Rétine , 51 octets

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

Essayez-le en ligne! Prend le nombre d'étapes sur la première ligne et une chaîne de 0s et 1s sur la deuxième ligne. Explication:

1A`

Supprimez le nombre d'étapes de l'entrée.

"$+"{

Répétez ce nombre de fois.

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

Copiez les chiffres de fin aux autres extrémités pour simuler l'habillage.

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

Effectuez l'opération XOR.

APL (Dyalog Extended) , 12 octets ^SBCS

Programme complet. Demande à stdin le tableau des états, puis le nombre d'étapes. Imprime à stdout.

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

Essayez-le en ligne!

⎕ obtenir une entrée évaluée à partir de la console (tableau d'états)

⊢ là-dessus, appliquez…

1(… )⍣⎕ La fonction tacite suivante, entrée le nombre de fois, à chaque fois avec 1comme argument de gauche:

 ⌽⍢⌽ faire pivoter l'argument de droite d'un pas vers la gauche tout en étant inversé (c'est-à-dire faire pivoter d'un pas vers la droite)

 ⌽≠ XOR avec l'argument tourné d'un pas vers la gauche

Python 2 , 71 octets

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

Essayez-le en ligne!

Gelée , 7 octets

ṙØ+^/$¡

Essayez-le en ligne!

Programme complet. Une sortie singleton est représentée comme xau lieu de [x].

Pyth , 24 octets

AQVH=Gmxhded.:+eG+GhG3;G

Essayez-le en ligne!

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

Rubis , 59 octets

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

Essayez-le en ligne!