Simuler un modèle de jeu de la vie 1D


12

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!


8
+1 pour les automates cellulaires. N'est-ce pas cette règle 90?
HighlyRadioactive

2
Le premier cas de test ne devrait-il pas aboutir [0, 1, 0, 0, 1, 0, 1, 1]?
TFeld

4
@jaaq Je fais référence à la règle des automates cellulaires élémentaires (de transformation entre chaque étape ou générations) # 90. Tapez "Rule 90" dans Wolfram | Alpha.
HighlyRadioactive

12
afficher la liste résultante via STDOUT : il est fortement recommandé de simplement s'appuyer sur nos méthodes d'E / S par défaut .
Arnauld

5
@jaaq Pas autant de coïncidence qu'il y a de règle # pour chaque automate cellulaire 1D standard. En effet, 3 bits ont 8 états possibles (voisin gauche, auto, voisin droit) et si vous dites que pour chacun de ces états, une maison donnée sera activée ou désactivée, ce sont 8 valeurs vraies / fausses qui correspondent parfaitement à un octet. Ainsi, la règle # 0-255 peut être utilisée comme raccourci pour décrire l'un de ces ensembles de règles en prenant l'expression binaire comme étant l'état activé / désactivé de la maison résultant dans chacune des 8 situations en fonction de la position dans l'octet. Certaines règles sont considérées comme notables comme le 90, donc la reconnaissance :)
Lunin

Réponses:


8

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




2

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

2

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.


2

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




1

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.